Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 9f47dc76a1868b73582df3aeb17ca07588afb714 / . / include / xgl.h
blob: 52a5f80d412b2933f32e1d4cc6db8ba507b53dca [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 Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]289 XGL_SLOT_NEXT_DESCRIPTOR_SET = 0x00000004,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]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,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]771// IMG CHANGE BEGIN - support for vertex input description
772 XGL_CH_FMT_R8G8B8 = 31,
773 XGL_CH_FMT_R16G16B16 = 32,
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]774
775 // optional? TBD'
776 XGL_CH_FMT_B10G10R10A2 = 33,
777 XGL_CH_FMT_R64 = 34,
778 XGL_CH_FMT_R64G64 = 35,
779 XGL_CH_FMT_R64G64B64 = 36,
780 XGL_CH_FMT_R64G64B64A64 = 37,
781
782 XGL_MAX_CH_FMT = XGL_CH_FMT_R64G64B64A64,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]783// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]784 XGL_MAX_ENUM(_XGL_CHANNEL_FORMAT)
785} XGL_CHANNEL_FORMAT;
786
787typedef enum _XGL_NUM_FORMAT
788{
789 XGL_NUM_FMT_UNDEFINED = 0,
790 XGL_NUM_FMT_UNORM = 1,
791 XGL_NUM_FMT_SNORM = 2,
792 XGL_NUM_FMT_UINT = 3,
793 XGL_NUM_FMT_SINT = 4,
794 XGL_NUM_FMT_FLOAT = 5,
795 XGL_NUM_FMT_SRGB = 6,
796 XGL_NUM_FMT_DS = 7,
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]797// IMG CHANGE BEGIN - support for vertex input description
798 XGL_NUM_FMT_USCALED = 8,
799 XGL_NUM_FMT_SSCALED = 9,
800 XGL_MAX_NUM_FMT = XGL_NUM_FMT_SSCALED,
801// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]802 XGL_MAX_ENUM(_XGL_NUM_FORMAT)
803} XGL_NUM_FORMAT;
804
805typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
806{
807 XGL_PROVOKING_VERTEX_FIRST = 0,
808 XGL_PROVOKING_VERTEX_LAST = 1,
809
810 XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
811 XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
812 XGL_NUM_PROVOKING_VERTEX_CONVENTIONS = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
813 XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
814} XGL_PROVOKING_VERTEX_CONVENTION;
815
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]816// IMG CHANGE BEGIN - support for vertex input description
817typedef enum _XGL_VERTEX_INPUT_STEP_RATE
818{
819 XGL_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0,
820 XGL_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1,
821 XGL_VERTEX_INPUT_STEP_RATE_DRAW = 0x2,
822 XGL_MAX_ENUM(_XGL_VERTEX_INPUT_STEP_RATE)
823} XGL_VERTEX_INPUT_STEP_RATE;
824// IMG CHANGE END
825
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]826typedef struct _XGL_FORMAT
827{
828 XGL_CHANNEL_FORMAT channelFormat;
829 XGL_NUM_FORMAT numericFormat;
830} XGL_FORMAT;
831
832// Shader stage enumerant
833typedef enum _XGL_PIPELINE_SHADER_STAGE
834{
835 XGL_SHADER_STAGE_VERTEX = 0,
836 XGL_SHADER_STAGE_TESS_CONTROL = 1,
837 XGL_SHADER_STAGE_TESS_EVALUATION = 2,
838 XGL_SHADER_STAGE_GEOMETRY = 3,
839 XGL_SHADER_STAGE_FRAGMENT = 4,
840 XGL_SHADER_STAGE_COMPUTE = 5,
841 XGL_MAX_ENUM(_XGL_PIPELINE_SHADER_STAGE)
842} XGL_PIPELINE_SHADER_STAGE;
843
844// Structure type enumerant
845typedef enum _XGL_STRUCTURE_TYPE
846{
847 XGL_STRUCTURE_TYPE_APPLICATION_INFO = 0,
848 XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
849 XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
850 XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4,
851 XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5,
852 XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO = 6,
853 XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7,
854 XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION = 8,
855 XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9,
856 XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10,
857 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11,
858 XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12,
859 XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13,
860 XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14,
861 XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO = 15,
862 XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO = 16,
863 XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO = 17,
864 XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO = 18,
865 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO = 19,
866 XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
867 XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
868 XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
869 XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23,
870 XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24,
871 XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
872 XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
873 XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
Courtney Goeltzenleuchter7f11ed22014-08-15 14:54:58 -0600[diff] [blame]874 XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 28,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]875 XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO = 29,
876 XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 30,
877 XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 31,
878 XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 32,
879 XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 33,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]880// IMG CHANGE BEGIN - support for vertex input description
881 XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 34,
882// IMG CHANGE END
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]883 XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO = 35,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]884 XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
885} XGL_STRUCTURE_TYPE;
886
887// ------------------------------------------------------------------------------------------------
888// Flags
889
890// Device creation flags
891typedef enum _XGL_DEVICE_CREATE_FLAGS
892{
893 XGL_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
894 XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002,
895} XGL_DEVICE_CREATE_FLAGS;
896
897// Queue capabilities
898typedef enum _XGL_QUEUE_FLAGS
899{
900 XGL_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations
901 XGL_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations
902 XGL_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations
903 XGL_QUEUE_EXTENDED_BIT = 0x80000000 // Extended queue
904} XGL_QUEUE_FLAGS;
905
906// Memory heap properties
907typedef enum _XGL_MEMORY_HEAP_FLAGS
908{
909 XGL_MEMORY_HEAP_CPU_VISIBLE_BIT = 0x00000001,
910 XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT = 0x00000002,
911 XGL_MEMORY_HEAP_CPU_UNCACHED_BIT = 0x00000004,
912 XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT = 0x00000008,
913 XGL_MEMORY_HEAP_HOLDS_PINNED_BIT = 0x00000010,
914 XGL_MEMORY_HEAP_SHAREABLE_BIT = 0x00000020,
915} XGL_MEMORY_HEAP_FLAGS;
916
917// Memory allocation flags
918typedef enum _XGL_MEMORY_ALLOC_FLAGS
919{
920 XGL_MEMORY_ALLOC_VIRTUAL_BIT = 0x00000001,
921 XGL_MEMORY_ALLOC_SHAREABLE_BIT = 0x00000002,
922} XGL_MEMORY_ALLOC_FLAGS;
923
924// Image usage flags
925typedef enum _XGL_IMAGE_USAGE_FLAGS
926{
927 XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001,
928 XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002,
929 XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000004,
930 XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000008,
931} XGL_IMAGE_USAGE_FLAGS;
932
933// Image flags
934typedef enum _XGL_IMAGE_CREATE_FLAGS
935{
936 XGL_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
937 XGL_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002,
938 XGL_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004,
939} XGL_IMAGE_CREATE_FLAGS;
940
941// Depth-stencil view creation flags
942typedef enum _XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
943{
944 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
945 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
946} XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS;
947
948// Pipeline creation flags
949typedef enum _XGL_PIPELINE_CREATE_FLAGS
950{
951 XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
952} XGL_PIPELINE_CREATE_FLAGS;
953
954// Semaphore creation flags
955typedef enum _XGL_SEMAPHORE_CREATE_FLAGS
956{
957 XGL_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001,
958} XGL_SEMAPHORE_CREATE_FLAGS;
959
960// Memory reference flags
961typedef enum _XGL_MEMORY_REF_FLAGS
962{
963 XGL_MEMORY_REF_READ_ONLY_BIT = 0x00000001,
964} XGL_MEMORY_REF_FLAGS;
965
966// Format capability flags
967typedef enum _XGL_FORMAT_FEATURE_FLAGS
968{
969 XGL_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001,
970 XGL_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002,
971 XGL_FORMAT_IMAGE_COPY_BIT = 0x00000004,
972 XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT = 0x00000008,
973 XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT = 0x00000010,
974 XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000020,
975 XGL_FORMAT_DEPTH_ATTACHMENT_BIT = 0x00000040,
976 XGL_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080,
977 XGL_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100,
978 XGL_FORMAT_CONVERSION_BIT = 0x00000200,
979} XGL_FORMAT_FEATURE_FLAGS;
980
981// Query flags
982typedef enum _XGL_QUERY_CONTROL_FLAGS
983{
984 XGL_QUERY_IMPRECISE_DATA_BIT = 0x00000001,
985} XGL_QUERY_CONTROL_FLAGS;
986
987// GPU compatibility flags
988typedef enum _XGL_GPU_COMPATIBILITY_FLAGS
989{
990 XGL_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001,
991 XGL_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002,
992 XGL_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004,
993 XGL_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008,
994 XGL_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010,
995 XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020,
996 XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040,
997} XGL_GPU_COMPATIBILITY_FLAGS;
998
999// Command buffer building flags
1000typedef enum _XGL_CMD_BUFFER_BUILD_FLAGS
1001{
1002 XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001,
1003 XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
1004 XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
1005 XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
1006} XGL_CMD_BUFFER_BUILD_FLAGS;
1007
1008// ------------------------------------------------------------------------------------------------
1009// XGL structures
1010
1011typedef struct _XGL_OFFSET2D
1012{
1013 XGL_INT x;
1014 XGL_INT y;
1015} XGL_OFFSET2D;
1016
1017typedef struct _XGL_OFFSET3D
1018{
1019 XGL_INT x;
1020 XGL_INT y;
1021 XGL_INT z;
1022} XGL_OFFSET3D;
1023
1024typedef struct _XGL_EXTENT2D
1025{
1026 XGL_INT width;
1027 XGL_INT height;
1028} XGL_EXTENT2D;
1029
1030typedef struct _XGL_EXTENT3D
1031{
1032 XGL_INT width;
1033 XGL_INT height;
1034 XGL_INT depth;
1035} XGL_EXTENT3D;
1036
1037typedef struct _XGL_VIEWPORT
1038{
1039 XGL_FLOAT originX;
1040 XGL_FLOAT originY;
1041 XGL_FLOAT width;
1042 XGL_FLOAT height;
1043 XGL_FLOAT minDepth;
1044 XGL_FLOAT maxDepth;
1045} XGL_VIEWPORT;
1046
1047typedef struct _XGL_RECT
1048{
1049 XGL_OFFSET2D offset;
1050 XGL_EXTENT2D extent;
1051} XGL_RECT;
1052
1053typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
1054{
1055 XGL_SIZE structSize;
1056 XGL_UINT32 apiVersion;
1057 XGL_UINT32 driverVersion;
1058 XGL_UINT32 vendorId;
1059 XGL_UINT32 deviceId;
1060 XGL_PHYSICAL_GPU_TYPE gpuType;
1061 XGL_CHAR gpuName[XGL_MAX_PHYSICAL_GPU_NAME];
1062 XGL_UINT maxMemRefsPerSubmission;
1063 XGL_GPU_SIZE virtualMemPageSize;
1064 XGL_GPU_SIZE maxInlineMemoryUpdateSize;
1065 XGL_UINT maxBoundDescriptorSets;
1066 XGL_UINT maxThreadGroupSize;
1067 XGL_UINT64 timestampFrequency;
1068 XGL_BOOL multiColorAttachmentClears;
1069} XGL_PHYSICAL_GPU_PROPERTIES;
1070
1071typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE
1072{
1073 XGL_FLOAT maxGpuClock;
1074 XGL_FLOAT aluPerClock;
1075 XGL_FLOAT texPerClock;
1076 XGL_FLOAT primsPerClock;
1077 XGL_FLOAT pixelsPerClock;
1078} XGL_PHYSICAL_GPU_PERFORMANCE;
1079
1080typedef struct _XGL_GPU_COMPATIBILITY_INFO
1081{
1082 XGL_FLAGS compatibilityFlags; // XGL_GPU_COMPATIBILITY_FLAGS
1083} XGL_GPU_COMPATIBILITY_INFO;
1084
1085typedef struct _XGL_APPLICATION_INFO
1086{
1087 XGL_STRUCTURE_TYPE sType; // Type of structure. Should be XGL_STRUCTURE_TYPE_APPLICATION_INFO
1088 XGL_VOID* pNext; // Next structure in chain
1089 const XGL_CHAR* pAppName;
1090 XGL_UINT32 appVersion;
1091 const XGL_CHAR* pEngineName;
1092 XGL_UINT32 engineVersion;
1093 XGL_UINT32 apiVersion;
1094} XGL_APPLICATION_INFO;
1095
1096typedef XGL_VOID* (XGLAPI *XGL_ALLOC_FUNCTION)(
1097 XGL_VOID* pUserData,
1098 XGL_SIZE size,
1099 XGL_SIZE alignment,
1100 XGL_SYSTEM_ALLOC_TYPE allocType);
1101
1102typedef XGL_VOID (XGLAPI *XGL_FREE_FUNCTION)(
1103 XGL_VOID* pUserData,
1104 XGL_VOID* pMem);
1105
1106typedef struct _XGL_ALLOC_CALLBACKS
1107{
1108 XGL_VOID* pUserData;
1109 XGL_ALLOC_FUNCTION pfnAlloc;
1110 XGL_FREE_FUNCTION pfnFree;
1111} XGL_ALLOC_CALLBACKS;
1112
1113typedef struct _XGL_DEVICE_QUEUE_CREATE_INFO
1114{
1115 XGL_UINT queueNodeIndex;
1116 XGL_UINT queueCount;
1117} XGL_DEVICE_QUEUE_CREATE_INFO;
1118
1119typedef struct _XGL_DEVICE_CREATE_INFO
1120{
1121 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO
1122 XGL_VOID* pNext; // Pointer to next structure
1123 XGL_UINT queueRecordCount;
1124 const XGL_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues;
1125 XGL_UINT extensionCount;
1126 const XGL_CHAR*const* ppEnabledExtensionNames;
1127 XGL_VALIDATION_LEVEL maxValidationLevel;
1128 XGL_FLAGS flags; // XGL_DEVICE_CREATE_FLAGS
1129} XGL_DEVICE_CREATE_INFO;
1130
Jon Ashburn183dfd02014-10-22 18:13:16 -0600[diff] [blame]1131typedef struct _XGL_LAYER_CREATE_INFO
1132{
1133 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO
1134 XGL_VOID* pNext; // Pointer to next structure
1135 XGL_UINT layerCount;
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]1136 const XGL_CHAR *const* ppActiveLayerNames; // layer name from the layer's xglEnumerateLayers())
Jon Ashburn183dfd02014-10-22 18:13:16 -0600[diff] [blame]1137} XGL_LAYER_CREATE_INFO;
1138
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1139typedef struct _XGL_PHYSICAL_GPU_QUEUE_PROPERTIES
1140{
1141 XGL_SIZE structSize; // Size of structure in bytes
1142 XGL_FLAGS queueFlags; // XGL_QUEUE_FLAGS
1143 XGL_UINT queueCount;
1144 XGL_UINT maxAtomicCounters;
1145 XGL_BOOL supportsTimestamps;
1146} XGL_PHYSICAL_GPU_QUEUE_PROPERTIES;
1147
1148typedef struct _XGL_PHYSICAL_GPU_MEMORY_PROPERTIES
1149{
1150 XGL_SIZE structSize; // Size of structure in bytes
1151 XGL_BOOL supportsMigration;
1152 XGL_BOOL supportsVirtualMemoryRemapping;
1153 XGL_BOOL supportsPinning;
1154} XGL_PHYSICAL_GPU_MEMORY_PROPERTIES;
1155
1156typedef struct _XGL_MEMORY_HEAP_PROPERTIES
1157{
1158 XGL_SIZE structSize; // Size of structure in bytes
1159 XGL_HEAP_MEMORY_TYPE heapMemoryType; // XGL_HEAP_MEMORY_TYPE
1160 XGL_GPU_SIZE heapSize; // Specified in bytes
1161 XGL_GPU_SIZE pageSize; // Specified in bytes
1162 XGL_FLAGS flags; // XGL_MEMORY_HEAP_FLAGS
1163 XGL_FLOAT gpuReadPerfRating;
1164 XGL_FLOAT gpuWritePerfRating;
1165 XGL_FLOAT cpuReadPerfRating;
1166 XGL_FLOAT cpuWritePerfRating;
1167} XGL_MEMORY_HEAP_PROPERTIES;
1168
1169typedef struct _XGL_MEMORY_ALLOC_INFO
1170{
1171 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
1172 XGL_VOID* pNext; // Pointer to next structure
1173 XGL_GPU_SIZE allocationSize; // Size of memory allocation
1174 XGL_GPU_SIZE alignment;
1175 XGL_FLAGS flags; // XGL_MEMORY_ALLOC_FLAGS
1176 XGL_UINT heapCount;
1177 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1178 XGL_MEMORY_PRIORITY memPriority;
1179} XGL_MEMORY_ALLOC_INFO;
1180
1181typedef struct _XGL_MEMORY_OPEN_INFO
1182{
1183 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO
1184 XGL_VOID* pNext; // Pointer to next structure
1185 XGL_GPU_MEMORY sharedMem;
1186} XGL_MEMORY_OPEN_INFO;
1187
1188typedef struct _XGL_PEER_MEMORY_OPEN_INFO
1189{
1190 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
1191 XGL_VOID* pNext; // Pointer to next structure
1192 XGL_GPU_MEMORY originalMem;
1193} XGL_PEER_MEMORY_OPEN_INFO;
1194
1195typedef struct _XGL_VIRTUAL_MEMORY_REMAP_RANGE
1196{
1197 XGL_GPU_MEMORY virtualMem;
1198 XGL_GPU_SIZE virtualStartPage;
1199 XGL_GPU_MEMORY realMem;
1200 XGL_GPU_SIZE realStartPage;
1201 XGL_GPU_SIZE pageCount;
1202} XGL_VIRTUAL_MEMORY_REMAP_RANGE;
1203
1204typedef struct _XGL_MEMORY_REQUIREMENTS
1205{
1206 XGL_GPU_SIZE size; // Specified in bytes
1207 XGL_GPU_SIZE alignment; // Specified in bytes
1208 XGL_UINT heapCount;
1209 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1210} XGL_MEMORY_REQUIREMENTS;
1211
1212typedef struct _XGL_FORMAT_PROPERTIES
1213{
1214 XGL_FLAGS linearTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1215 XGL_FLAGS optimalTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1216} XGL_FORMAT_PROPERTIES;
1217
1218typedef struct _XGL_MEMORY_VIEW_ATTACH_INFO
1219{
1220 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
1221 XGL_VOID* pNext; // Pointer to next structure
1222 XGL_GPU_MEMORY mem;
1223 XGL_GPU_SIZE offset;
1224 XGL_GPU_SIZE range;
1225 XGL_GPU_SIZE stride;
1226 XGL_FORMAT format;
1227 XGL_MEMORY_STATE state;
1228} XGL_MEMORY_VIEW_ATTACH_INFO;
1229
1230typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
1231{
1232 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
1233 XGL_VOID* pNext; // Pointer to next structure
1234 XGL_IMAGE_VIEW view;
1235 XGL_IMAGE_STATE state;
1236} XGL_IMAGE_VIEW_ATTACH_INFO;
1237
1238typedef struct _XGL_MEMORY_STATE_TRANSITION
1239{
1240 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION
1241 XGL_VOID* pNext; // Pointer to next structure
1242 XGL_GPU_MEMORY mem;
1243 XGL_MEMORY_STATE oldState;
1244 XGL_MEMORY_STATE newState;
1245 XGL_GPU_SIZE offset;
1246 XGL_GPU_SIZE regionSize;
1247} XGL_MEMORY_STATE_TRANSITION;
1248
1249typedef struct _XGL_IMAGE_SUBRESOURCE
1250{
1251 XGL_IMAGE_ASPECT aspect;
1252 XGL_UINT mipLevel;
1253 XGL_UINT arraySlice;
1254} XGL_IMAGE_SUBRESOURCE;
1255
1256typedef struct _XGL_IMAGE_SUBRESOURCE_RANGE
1257{
1258 XGL_IMAGE_ASPECT aspect;
1259 XGL_UINT baseMipLevel;
1260 XGL_UINT mipLevels;
1261 XGL_UINT baseArraySlice;
1262 XGL_UINT arraySize;
1263} XGL_IMAGE_SUBRESOURCE_RANGE;
1264
1265typedef struct _XGL_IMAGE_STATE_TRANSITION
1266{
1267 XGL_IMAGE image;
1268 XGL_IMAGE_STATE oldState;
1269 XGL_IMAGE_STATE newState;
1270 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1271} XGL_IMAGE_STATE_TRANSITION;
1272
1273typedef struct _XGL_IMAGE_CREATE_INFO
1274{
1275 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
1276 const XGL_VOID* pNext; // Pointer to next structure.
1277 XGL_IMAGE_TYPE imageType;
1278 XGL_FORMAT format;
1279 XGL_EXTENT3D extent;
1280 XGL_UINT mipLevels;
1281 XGL_UINT arraySize;
1282 XGL_UINT samples;
1283 XGL_IMAGE_TILING tiling;
1284 XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS
1285 XGL_FLAGS flags; // XGL_IMAGE_CREATE_FLAGS
1286} XGL_IMAGE_CREATE_INFO;
1287
1288typedef struct _XGL_PEER_IMAGE_OPEN_INFO
1289{
1290 XGL_IMAGE originalImage;
1291} XGL_PEER_IMAGE_OPEN_INFO;
1292
1293typedef struct _XGL_SUBRESOURCE_LAYOUT
1294{
1295 XGL_GPU_SIZE offset; // Specified in bytes
1296 XGL_GPU_SIZE size; // Specified in bytes
1297 XGL_GPU_SIZE rowPitch; // Specified in bytes
1298 XGL_GPU_SIZE depthPitch; // Specified in bytes
1299} XGL_SUBRESOURCE_LAYOUT;
1300
1301typedef struct _XGL_CHANNEL_MAPPING
1302{
1303 XGL_CHANNEL_SWIZZLE r;
1304 XGL_CHANNEL_SWIZZLE g;
1305 XGL_CHANNEL_SWIZZLE b;
1306 XGL_CHANNEL_SWIZZLE a;
1307} XGL_CHANNEL_MAPPING;
1308
1309typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
1310{
1311 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
1312 const XGL_VOID* pNext; // Pointer to next structure
1313 XGL_IMAGE image;
1314 XGL_IMAGE_VIEW_TYPE viewType;
1315 XGL_FORMAT format;
1316 XGL_CHANNEL_MAPPING channels;
1317 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1318 XGL_FLOAT minLod;
1319} XGL_IMAGE_VIEW_CREATE_INFO;
1320
1321typedef struct _XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1322{
1323 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1324 XGL_VOID* pNext; // Pointer to next structure
1325 XGL_IMAGE image;
1326 XGL_FORMAT format;
1327 XGL_UINT mipLevel;
1328 XGL_UINT baseArraySlice;
1329 XGL_UINT arraySize;
1330} XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO;
1331
1332typedef struct _XGL_DEPTH_STENCIL_VIEW_CREATE_INFO
1333{
1334 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
1335 const XGL_VOID* pNext; // Pointer to next structure
1336 XGL_IMAGE image;
1337 XGL_UINT mipLevel;
1338 XGL_UINT baseArraySlice;
1339 XGL_UINT arraySize;
1340 XGL_FLAGS flags; // XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
1341} XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
1342
1343typedef struct _XGL_COLOR_ATTACHMENT_BIND_INFO
1344{
1345 XGL_COLOR_ATTACHMENT_VIEW view;
1346 XGL_IMAGE_STATE colorAttachmentState; // XGL_IMAGE_STATE
1347} XGL_COLOR_ATTACHMENT_BIND_INFO;
1348
1349typedef struct _XGL_DEPTH_STENCIL_BIND_INFO
1350{
1351 XGL_DEPTH_STENCIL_VIEW view;
1352 XGL_IMAGE_STATE depthState; // XGL_IMAGE_STATE
1353 XGL_IMAGE_STATE stencilState; // XGL_IMAGE_STATE
1354} XGL_DEPTH_STENCIL_BIND_INFO;
1355
1356typedef struct _XGL_MEMORY_COPY
1357{
1358 XGL_GPU_SIZE srcOffset; // Specified in bytes
1359 XGL_GPU_SIZE destOffset; // Specified in bytes
1360 XGL_GPU_SIZE copySize; // Specified in bytes
1361} XGL_MEMORY_COPY;
1362
1363typedef struct _XGL_IMAGE_COPY
1364{
1365 XGL_IMAGE_SUBRESOURCE srcSubresource;
1366 XGL_OFFSET3D srcOffset;
1367 XGL_IMAGE_SUBRESOURCE destSubresource;
1368 XGL_OFFSET3D destOffset;
1369 XGL_EXTENT3D extent;
1370} XGL_IMAGE_COPY;
1371
1372typedef struct _XGL_MEMORY_IMAGE_COPY
1373{
1374 XGL_GPU_SIZE memOffset; // Specified in bytes
1375 XGL_IMAGE_SUBRESOURCE imageSubresource;
1376 XGL_OFFSET3D imageOffset;
1377 XGL_EXTENT3D imageExtent;
1378} XGL_MEMORY_IMAGE_COPY;
1379
1380typedef struct _XGL_IMAGE_RESOLVE
1381{
1382 XGL_IMAGE_SUBRESOURCE srcSubresource;
1383 XGL_OFFSET2D srcOffset;
1384 XGL_IMAGE_SUBRESOURCE destSubresource;
1385 XGL_OFFSET2D destOffset;
1386 XGL_EXTENT2D extent;
1387} XGL_IMAGE_RESOLVE;
1388
1389typedef struct _XGL_SHADER_CREATE_INFO
1390{
1391 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO
1392 const XGL_VOID* pNext; // Pointer to next structure
1393 XGL_SIZE codeSize; // Specified in bytes
1394 const XGL_VOID* pCode;
1395 XGL_FLAGS flags; // Reserved
1396} XGL_SHADER_CREATE_INFO;
1397
1398struct _XGL_DESCRIPTOR_SET_MAPPING;
1399
1400typedef struct _XGL_DESCRIPTOR_SLOT_INFO
1401{
1402 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1403 union
1404 {
1405 XGL_UINT shaderEntityIndex;// Shader IL slot index for given entity type
1406 const struct _XGL_DESCRIPTOR_SET_MAPPING* pNextLevelSet; // Pointer to next descriptor set level
1407 };
1408} XGL_DESCRIPTOR_SLOT_INFO;
1409
1410typedef struct _XGL_DESCRIPTOR_SET_MAPPING
1411{
1412 XGL_UINT descriptorCount;
1413 const XGL_DESCRIPTOR_SLOT_INFO* pDescriptorInfo;
1414} XGL_DESCRIPTOR_SET_MAPPING;
1415
1416typedef struct _XGL_LINK_CONST_BUFFER
1417{
1418 XGL_UINT bufferId;
1419 XGL_SIZE bufferSize;
1420 const XGL_VOID* pBufferData;
1421} XGL_LINK_CONST_BUFFER;
1422
1423typedef struct _XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO
1424{
1425 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1426 XGL_UINT shaderEntityIndex;
1427} XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO;
1428
1429typedef struct _XGL_PIPELINE_SHADER
1430{
1431 XGL_PIPELINE_SHADER_STAGE stage;
1432 XGL_SHADER shader;
1433 XGL_DESCRIPTOR_SET_MAPPING descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
1434 XGL_UINT linkConstBufferCount;
1435 const XGL_LINK_CONST_BUFFER* pLinkConstBufferInfo;
1436 XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO dynamicMemoryViewMapping;
1437} XGL_PIPELINE_SHADER;
1438
1439typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
1440{
1441 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
1442 const XGL_VOID* pNext; // Pointer to next structure
1443 XGL_PIPELINE_SHADER cs;
1444 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1445} XGL_COMPUTE_PIPELINE_CREATE_INFO;
1446
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]1447// IMG CHANGE BEGIN - support for vertex input description
1448
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]1449//
1450// The shader inputs are mapped to pVertexAttributeDescriptions using a decoration in the BIL.
1451//
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]1452// The binding parameter in xglCmdBindVertexBuffer describes the index into pVertexBindingDescriptions[]
1453//
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]1454//
1455// Formats allowed for attributes (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION.format) will be detailed in
1456// a table in the specification.
1457//
1458//
1459// Queryable limits:
1460//
1461// XGL_VERTEX_INPUT_BINDING_DESCRIPTION.strideInBytes
1462// XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION.offsetInBytes
1463//
1464//
1465
1466typedef struct _XGL_VERTEX_INPUT_BINDING_DESCRIPTION
1467{
1468 XGL_UINT strideInBytes; // Distance between vertices in bytes (0 = no advancement)
1469
1470 XGL_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented
1471} XGL_VERTEX_INPUT_BINDING_DESCRIPTION;
1472
1473typedef struct _XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION
1474{
1475 XGL_UINT binding; // index into vertexBindingDescriptions
1476
1477 XGL_FORMAT format; // format of source data
1478
1479 XGL_UINT offsetInBytes; // Offset of first element in bytes from base of vertex
1480} XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION;
1481
1482typedef struct _XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO
1483{
1484 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
1485 XGL_VOID* pNext; // Pointer to next structure
1486
1487 XGL_UINT bindingCount; // number of bindings
1488 XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions;
1489
1490 XGL_UINT attributeCount; // number of attributes
1491 XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
1492} XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO;
1493// IMG CHANGE END
1494
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1495typedef struct _XGL_PIPELINE_IA_STATE_CREATE_INFO
1496{
1497 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
1498 const XGL_VOID* pNext; // Pointer to next structure
1499 XGL_PRIMITIVE_TOPOLOGY topology;
1500 XGL_BOOL disableVertexReuse;
1501 XGL_PROVOKING_VERTEX_CONVENTION provokingVertex;
1502 XGL_BOOL primitiveRestartEnable;
1503 XGL_UINT32 primitiveRestartIndex;
1504} XGL_PIPELINE_IA_STATE_CREATE_INFO;
1505
1506typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO
1507{
1508 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
1509 const XGL_VOID* pNext; // Pointer to next structure
1510 XGL_UINT patchControlPoints;
1511 XGL_FLOAT optimalTessFactor;
1512 XGL_FLOAT fixedTessFactor;
1513} XGL_PIPELINE_TESS_STATE_CREATE_INFO;
1514
1515typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO
1516{
1517 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
1518 const XGL_VOID* pNext; // Pointer to next structure
1519 XGL_BOOL depthClipEnable;
1520 XGL_BOOL rasterizerDiscardEnable;
1521 XGL_FLOAT pointSize; // Size of points
1522} XGL_PIPELINE_RS_STATE_CREATE_INFO;
1523
1524typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE
1525{
1526 XGL_BOOL blendEnable;
1527 XGL_FORMAT format;
1528 XGL_UINT8 channelWriteMask;
1529} XGL_PIPELINE_CB_ATTACHMENT_STATE;
1530
1531typedef struct _XGL_PIPELINE_CB_STATE_CREATE_INFO
1532{
1533 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
1534 const XGL_VOID* pNext; // Pointer to next structure
1535 XGL_BOOL alphaToCoverageEnable;
1536 XGL_BOOL dualSourceBlendEnable;
1537 XGL_LOGIC_OP logicOp;
1538 XGL_PIPELINE_CB_ATTACHMENT_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1539} XGL_PIPELINE_CB_STATE;
1540
1541typedef struct _XGL_PIPELINE_DB_STATE_CREATE_INFO
1542{
1543 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
1544 const XGL_VOID* pNext; // Pointer to next structure
1545 XGL_FORMAT format;
1546} XGL_PIPELINE_DB_STATE_CREATE_INFO;
1547
1548typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
1549{
1550 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
1551 const XGL_VOID* pNext; // Pointer to next structure
1552 XGL_PIPELINE_SHADER shader;
1553} XGL_PIPELINE_SHADER_STAGE_CREATE_INFO;
1554
1555typedef struct _XGL_GRAPHICS_PIPELINE_CREATE_INFO
1556{
1557 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
1558 const XGL_VOID* pNext; // Pointer to next structure
1559 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1560} XGL_GRAPHICS_PIPELINE_CREATE_INFO;
1561
1562typedef struct _XGL_SAMPLER_CREATE_INFO
1563{
1564 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
1565 const XGL_VOID* pNext; // Pointer to next structure
1566 XGL_TEX_FILTER magFilter; // Filter mode for magnification
1567 XGL_TEX_FILTER minFilter; // Filter mode for minifiation
1568 XGL_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode
1569 XGL_TEX_ADDRESS addressU;
1570 XGL_TEX_ADDRESS addressV;
1571 XGL_TEX_ADDRESS addressW;
1572 XGL_FLOAT mipLodBias;
1573 XGL_UINT maxAnisotropy;
1574 XGL_COMPARE_FUNC compareFunc;
1575 XGL_FLOAT minLod;
1576 XGL_FLOAT maxLod;
1577 XGL_BORDER_COLOR_TYPE borderColorType;
1578} XGL_SAMPLER_CREATE_INFO;
1579
1580typedef struct _XGL_DESCRIPTOR_SET_CREATE_INFO
1581{
1582 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
1583 const XGL_VOID* pNext; // Pointer to next structure
1584 XGL_UINT slots;
1585} XGL_DESCRIPTOR_SET_CREATE_INFO;
1586
1587typedef struct _XGL_DESCRIPTOR_SET_ATTACH_INFO
1588{
1589 XGL_DESCRIPTOR_SET descriptorSet;
1590 XGL_UINT slotOffset;
1591} XGL_DESCRIPTOR_SET_ATTACH_INFO;
1592
1593typedef struct _XGL_VIEWPORT_STATE_CREATE_INFO
1594{
1595 XGL_UINT viewportCount;
1596 XGL_BOOL scissorEnable;
1597 XGL_VIEWPORT viewports[XGL_MAX_VIEWPORTS];
1598 XGL_RECT scissors[XGL_MAX_VIEWPORTS];
1599} XGL_VIEWPORT_STATE_CREATE_INFO;
1600
1601typedef struct _XGL_RASTER_STATE_CREATE_INFO
1602{
1603 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO
1604 const XGL_VOID* pNext; // Pointer to next structure
1605 XGL_FILL_MODE fillMode;
1606 XGL_CULL_MODE cullMode;
1607 XGL_FACE_ORIENTATION frontFace;
1608 XGL_INT depthBias;
1609 XGL_FLOAT depthBiasClamp;
1610 XGL_FLOAT slopeScaledDepthBias;
1611} XGL_RASTER_STATE_CREATE_INFO;
1612
1613typedef struct _XGL_MSAA_STATE_CREATE_INFO
1614{
1615 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO
1616 const XGL_VOID* pNext; // Pointer to next structure
1617 XGL_UINT samples;
1618 XGL_SAMPLE_MASK sampleMask;
1619} XGL_MSAA_STATE_CREATE_INFO;
1620
1621typedef struct _XGL_COLOR_ATTACHMENT_BLEND_STATE
1622{
1623 XGL_BOOL blendEnable;
1624 XGL_BLEND srcBlendColor;
1625 XGL_BLEND destBlendColor;
1626 XGL_BLEND_FUNC blendFuncColor;
1627 XGL_BLEND srcBlendAlpha;
1628 XGL_BLEND destBlendAlpha;
1629 XGL_BLEND_FUNC blendFuncAlpha;
1630} XGL_COLOR_ATTACHMENT_BLEND_STATE;
1631
1632typedef struct _XGL_COLOR_BLEND_STATE_CREATE_INFO
1633{
1634 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO
1635 const XGL_VOID* pNext; // Pointer to next structure
1636 XGL_COLOR_ATTACHMENT_BLEND_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1637 XGL_FLOAT blendConst[4];
1638} XGL_COLOR_BLEND_STATE_CREATE_INFO;
1639
1640typedef struct _XGL_STENCIL_OP_STATE
1641{
1642 XGL_STENCIL_OP stencilFailOp;
1643 XGL_STENCIL_OP stencilPassOp;
1644 XGL_STENCIL_OP stencilDepthFailOp;
1645 XGL_COMPARE_FUNC stencilFunc;
1646 XGL_UINT32 stencilRef;
1647} XGL_STENCIL_OP_STATE;
1648
1649typedef struct _XGL_DEPTH_STENCIL_STATE_CREATE_INFO
1650{
1651 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO
1652 const XGL_VOID* pNext; // Pointer to next structure
1653 XGL_BOOL depthTestEnable;
1654 XGL_BOOL depthWriteEnable;
1655 XGL_COMPARE_FUNC depthFunc;
1656 XGL_BOOL depthBoundsEnable;
1657 XGL_FLOAT minDepth;
1658 XGL_FLOAT maxDepth;
1659 XGL_BOOL stencilTestEnable;
1660 XGL_UINT32 stencilReadMask;
1661 XGL_UINT32 stencilWriteMask;
1662 XGL_STENCIL_OP_STATE front;
1663 XGL_STENCIL_OP_STATE back;
1664} XGL_DEPTH_STENCIL_STATE_CREATE_INFO;
1665
1666typedef struct _XGL_CMD_BUFFER_CREATE_INFO
1667{
1668 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
1669 const XGL_VOID* pNext;
1670 XGL_QUEUE_TYPE queueType;
1671 XGL_FLAGS flags;
1672} XGL_CMD_BUFFER_CREATE_INFO;
1673
1674typedef struct _XGL_MEMORY_REF
1675{
1676 XGL_GPU_MEMORY mem;
1677 XGL_FLAGS flags; // XGL_MEMORY_REF_FLAGS
1678} XGL_MEMORY_REF;
1679
1680typedef struct _XGL_EVENT_CREATE_INFO
1681{
1682 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
1683 const XGL_VOID* pNext; // Pointer to next structure
1684 XGL_FLAGS flags; // Reserved
1685} XGL_EVENT_CREATE_INFO;
1686
1687typedef struct _XGL_FENCE_CREATE_INFO
1688{
1689 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO
1690 const XGL_VOID* pNext; // Pointer to next structure
1691 XGL_FLAGS flags; // Reserved
1692} XGL_FENCE_CREATE_INFO;
1693
1694typedef struct _XGL_QUEUE_SEMAPHORE_CREATE_INFO
1695{
1696 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
1697 const XGL_VOID* pNext; // Pointer to next structure
1698 XGL_UINT initialCount;
1699 XGL_FLAGS flags; // XGL_SEMAPHORE_CREATE_FLAGS
1700} XGL_QUEUE_SEMAPHORE_CREATE_INFO;
1701
1702typedef struct _XGL_QUEUE_SEMAPHORE_OPEN_INFO
1703{
1704 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
1705 const XGL_VOID* pNext; // Pointer to next structure
1706 XGL_QUEUE_SEMAPHORE sharedSemaphore;
1707} XGL_QUEUE_SEMAPHORE_OPEN_INFO;
1708
1709typedef struct _XGL_PIPELINE_STATISTICS_DATA
1710{
1711 XGL_UINT64 fsInvocations; // Fragment shader invocations
1712 XGL_UINT64 cPrimitives; // Clipper primitives
1713 XGL_UINT64 cInvocations; // Clipper invocations
1714 XGL_UINT64 vsInvocations; // Vertex shader invocations
1715 XGL_UINT64 gsInvocations; // Geometry shader invocations
1716 XGL_UINT64 gsPrimitives; // Geometry shader primitives
1717 XGL_UINT64 iaPrimitives; // Input primitives
1718 XGL_UINT64 iaVertices; // Input vertices
1719 XGL_UINT64 tcsInvocations; // Tessellation control shader invocations
1720 XGL_UINT64 tesInvocations; // Tessellation evaluation shader invocations
1721 XGL_UINT64 csInvocations; // Compute shader invocations
1722} XGL_PIPELINE_STATISTICS_DATA;
1723
1724typedef struct _XGL_QUERY_POOL_CREATE_INFO
1725{
1726 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
1727 const XGL_VOID* pNext; // Pointer to next structure
1728 XGL_QUERY_TYPE queryType;
1729 XGL_UINT slots;
1730} XGL_QUERY_POOL_CREATE_INFO;
1731
1732typedef struct _XGL_DRAW_INDIRECT_CMD
1733{
1734 XGL_UINT32 vertexCount;
1735 XGL_UINT32 instanceCount;
1736 XGL_UINT32 firstVertex;
1737 XGL_UINT32 firstInstance;
1738} XGL_DRAW_INDIRECT_CMD;
1739
1740typedef struct _XGL_DRAW_INDEXED_INDIRECT_CMD
1741{
1742 XGL_UINT32 indexCount;
1743 XGL_UINT32 instanceCount;
1744 XGL_UINT32 firstIndex;
1745 XGL_INT32 vertexOffset;
1746 XGL_UINT32 firstInstance;
1747} XGL_DRAW_INDEXED_INDIRECT_CMD;
1748
1749typedef struct _XGL_DISPATCH_INDIRECT_CMD
1750{
1751 XGL_UINT32 x;
1752 XGL_UINT32 y;
1753 XGL_UINT32 z;
1754} XGL_DISPATCH_INDIRECT_CMD;
1755
1756// ------------------------------------------------------------------------------------------------
1757// API functions
Jon Ashburn7e6b61d2014-12-02 08:59:56 -0700[diff] [blame]1758typedef XGL_RESULT (XGLAPI *InitAndEnumerateGpusType)(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb, XGL_UINT maxGpus, XGL_UINT* pGpuCount, XGL_PHYSICAL_GPU* pGpus);
1759typedef XGL_RESULT (XGLAPI *GetGpuInfoType)(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1760typedef XGL_VOID * (XGLAPI *GetProcAddrType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR * pName);
1761typedef XGL_RESULT (XGLAPI *CreateDeviceType)(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
1762typedef XGL_RESULT (XGLAPI *DestroyDeviceType)(XGL_DEVICE device);
1763typedef XGL_RESULT (XGLAPI *GetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pExtName);
1764typedef XGL_RESULT (XGLAPI *EnumerateLayersType)(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE* pOutLayerCount, XGL_VOID* pReserved);
1765typedef XGL_RESULT (XGLAPI *GetDeviceQueueType)(XGL_DEVICE device, XGL_QUEUE_TYPE queueType, XGL_UINT queueIndex, XGL_QUEUE* pQueue);
1766typedef XGL_RESULT (XGLAPI *QueueSubmitType)(XGL_QUEUE queue, XGL_UINT cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence);
1767typedef XGL_RESULT (XGLAPI *QueueSetGlobalMemReferencesType)(XGL_QUEUE queue, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs);
1768typedef XGL_RESULT (XGLAPI *QueueWaitIdleType)(XGL_QUEUE queue);
1769typedef XGL_RESULT (XGLAPI *DeviceWaitIdleType)(XGL_DEVICE device);
1770typedef XGL_RESULT (XGLAPI *GetMemoryHeapCountType)(XGL_DEVICE device, XGL_UINT* pCount);
1771typedef XGL_RESULT (XGLAPI *GetMemoryHeapInfoType)(XGL_DEVICE device, XGL_UINT heapId, XGL_MEMORY_HEAP_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1772typedef XGL_RESULT (XGLAPI *AllocMemoryType)(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem);
1773typedef XGL_RESULT (XGLAPI *FreeMemoryType)(XGL_GPU_MEMORY mem);
1774typedef XGL_RESULT (XGLAPI *SetMemoryPriorityType)(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority);
1775typedef XGL_RESULT (XGLAPI *MapMemoryType)(XGL_GPU_MEMORY mem, XGL_FLAGS flags, XGL_VOID** ppData);
1776typedef XGL_RESULT (XGLAPI *UnmapMemoryType)(XGL_GPU_MEMORY mem);
1777typedef XGL_RESULT (XGLAPI *PinSystemMemoryType)(XGL_DEVICE device, const XGL_VOID* pSysMem, XGL_SIZE memSize, XGL_GPU_MEMORY* pMem);
1778typedef XGL_RESULT (XGLAPI *RemapVirtualMemoryPagesType)(XGL_DEVICE device, XGL_UINT rangeCount, const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges, XGL_UINT preWaitSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores, XGL_UINT postSignalSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
1779typedef XGL_RESULT (XGLAPI *GetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo);
1780typedef XGL_RESULT (XGLAPI *OpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
1781typedef XGL_RESULT (XGLAPI *OpenSharedQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
1782typedef XGL_RESULT (XGLAPI *OpenPeerMemoryType)(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
1783typedef XGL_RESULT (XGLAPI *OpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
1784typedef XGL_RESULT (XGLAPI *DestroyObjectType)(XGL_OBJECT object);
1785typedef XGL_RESULT (XGLAPI *GetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1786typedef XGL_RESULT (XGLAPI *BindObjectMemoryType)(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
1787typedef XGL_RESULT (XGLAPI *CreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence);
1788typedef XGL_RESULT (XGLAPI *GetFenceStatusType)(XGL_FENCE fence);
1789typedef XGL_RESULT (XGLAPI *WaitForFencesType)(XGL_DEVICE device, XGL_UINT fenceCount, const XGL_FENCE* pFences, XGL_BOOL waitAll, XGL_UINT64 timeout);
1790typedef XGL_RESULT (XGLAPI *CreateQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
1791typedef XGL_RESULT (XGLAPI *SignalQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
1792typedef XGL_RESULT (XGLAPI *WaitQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
1793typedef XGL_RESULT (XGLAPI *CreateEventType)(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent);
1794typedef XGL_RESULT (XGLAPI *GetEventStatusType)(XGL_EVENT event);
1795typedef XGL_RESULT (XGLAPI *SetEventType)(XGL_EVENT event);
1796typedef XGL_RESULT (XGLAPI *ResetEventType)(XGL_EVENT event);
1797typedef XGL_RESULT (XGLAPI *CreateQueryPoolType)(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool);
1798typedef XGL_RESULT (XGLAPI *GetQueryPoolResultsType)(XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount, XGL_SIZE* pDataSize, XGL_VOID* pData);
1799typedef XGL_RESULT (XGLAPI *GetFormatInfoType)(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1800typedef XGL_RESULT (XGLAPI *CreateImageType)(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage);
1801typedef XGL_RESULT (XGLAPI *GetImageSubresourceInfoType)(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1802typedef XGL_RESULT (XGLAPI *CreateImageViewType)(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView);
1803typedef XGL_RESULT (XGLAPI *CreateColorAttachmentViewType)(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView);
1804typedef XGL_RESULT (XGLAPI *CreateDepthStencilViewType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView);
1805typedef XGL_RESULT (XGLAPI *CreateShaderType)(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader);
1806typedef XGL_RESULT (XGLAPI *CreateGraphicsPipelineType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
1807typedef XGL_RESULT (XGLAPI *CreateComputePipelineType)(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
1808typedef XGL_RESULT (XGLAPI *StorePipelineType)(XGL_PIPELINE pipeline, XGL_SIZE* pDataSize, XGL_VOID* pData);
1809typedef XGL_RESULT (XGLAPI *LoadPipelineType)(XGL_DEVICE device, XGL_SIZE dataSize, const XGL_VOID* pData, XGL_PIPELINE* pPipeline);
1810typedef XGL_RESULT (XGLAPI *CreatePipelineDeltaType)(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta);
1811typedef XGL_RESULT (XGLAPI *CreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler);
1812typedef XGL_RESULT (XGLAPI *CreateDescriptorSetType)(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET* pDescriptorSet);
1813typedef XGL_VOID (XGLAPI *BeginDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
1814typedef XGL_VOID (XGLAPI *EndDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
1815typedef XGL_VOID (XGLAPI *AttachSamplerDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_SAMPLER* pSamplers);
1816typedef XGL_VOID (XGLAPI *AttachImageViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
1817typedef XGL_VOID (XGLAPI *AttachMemoryViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
1818typedef XGL_VOID (XGLAPI *AttachNestedDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
1819typedef XGL_VOID (XGLAPI *ClearDescriptorSetSlotsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount);
1820typedef XGL_RESULT (XGLAPI *CreateViewportStateType)(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState);
1821typedef XGL_RESULT (XGLAPI *CreateRasterStateType)(XGL_DEVICE device, const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo, XGL_RASTER_STATE_OBJECT* pState);
1822typedef XGL_RESULT (XGLAPI *CreateMsaaStateType)(XGL_DEVICE device, const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo, XGL_MSAA_STATE_OBJECT* pState);
1823typedef XGL_RESULT (XGLAPI *CreateColorBlendStateType)(XGL_DEVICE device, const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo, XGL_COLOR_BLEND_STATE_OBJECT* pState);
1824typedef XGL_RESULT (XGLAPI *CreateDepthStencilStateType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
1825typedef XGL_RESULT (XGLAPI *CreateCommandBufferType)(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer);
1826typedef XGL_RESULT (XGLAPI *BeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_FLAGS flags);
1827typedef XGL_RESULT (XGLAPI *EndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
1828typedef XGL_RESULT (XGLAPI *ResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
1829typedef XGL_VOID (XGLAPI *CmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
1830typedef XGL_VOID (XGLAPI *CmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
1831typedef XGL_VOID (XGLAPI *CmdBindStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state);
1832typedef XGL_VOID (XGLAPI *CmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT index, XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT slotOffset);
1833typedef XGL_VOID (XGLAPI *CmdBindDynamicMemoryViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
1834typedef XGL_VOID (XGLAPI *CmdBindVertexDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT binding);
1835typedef XGL_VOID (XGLAPI *CmdBindIndexDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
1836typedef XGL_VOID (XGLAPI *CmdBindAttachmentsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT colorAttachmentCount, const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments, const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment);
1837typedef XGL_VOID (XGLAPI *CmdPrepareMemoryRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
1838typedef XGL_VOID (XGLAPI *CmdPrepareImagesType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
1839typedef XGL_VOID (XGLAPI *CmdDrawType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
1840typedef XGL_VOID (XGLAPI *CmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount);
1841typedef XGL_VOID (XGLAPI *CmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
1842typedef XGL_VOID (XGLAPI *CmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
1843typedef XGL_VOID (XGLAPI *CmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT x, XGL_UINT y, XGL_UINT z);
1844typedef XGL_VOID (XGLAPI *CmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
1845typedef XGL_VOID (XGLAPI *CmdCopyMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_COPY* pRegions);
1846typedef XGL_VOID (XGLAPI *CmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_IMAGE_COPY* pRegions);
1847typedef XGL_VOID (XGLAPI *CmdCopyMemoryToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
1848typedef XGL_VOID (XGLAPI *CmdCopyImageToMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
1849typedef XGL_VOID (XGLAPI *CmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState);
1850typedef XGL_VOID (XGLAPI *CmdUpdateMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData);
1851typedef XGL_VOID (XGLAPI *CmdFillMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data);
1852typedef XGL_VOID (XGLAPI *CmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_FLOAT color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
1853typedef XGL_VOID (XGLAPI *CmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_UINT32 color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
1854typedef XGL_VOID (XGLAPI *CmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_FLOAT depth, XGL_UINT32 stencil, XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
1855typedef XGL_VOID (XGLAPI *CmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT rectCount, const XGL_IMAGE_RESOLVE* pRects);
1856typedef XGL_VOID (XGLAPI *CmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
1857typedef XGL_VOID (XGLAPI *CmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
1858typedef XGL_VOID (XGLAPI *CmdMemoryAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp);
1859typedef XGL_VOID (XGLAPI *CmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot, XGL_FLAGS flags);
1860typedef XGL_VOID (XGLAPI *CmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot);
1861typedef XGL_VOID (XGLAPI *CmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount);
1862typedef XGL_VOID (XGLAPI *CmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
1863typedef XGL_VOID (XGLAPI *CmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, const XGL_UINT32* pData);
1864typedef XGL_VOID (XGLAPI *CmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY srcMem, XGL_GPU_SIZE srcOffset);
1865typedef XGL_VOID (XGLAPI *CmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1866
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1867// GPU initialization
1868
1869XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
1870 const XGL_APPLICATION_INFO* pAppInfo,
1871 const XGL_ALLOC_CALLBACKS* pAllocCb,
1872 XGL_UINT maxGpus,
1873 XGL_UINT* pGpuCount,
1874 XGL_PHYSICAL_GPU* pGpus);
1875
1876XGL_RESULT XGLAPI xglGetGpuInfo(
1877 XGL_PHYSICAL_GPU gpu,
1878 XGL_PHYSICAL_GPU_INFO_TYPE infoType,
1879 XGL_SIZE* pDataSize,
1880 XGL_VOID* pData);
1881
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]1882XGL_VOID * XGLAPI xglGetProcAddr(
1883 XGL_PHYSICAL_GPU gpu,
1884 const XGL_CHAR* pName);
1885
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1886// Device functions
1887
1888XGL_RESULT XGLAPI xglCreateDevice(
1889 XGL_PHYSICAL_GPU gpu,
1890 const XGL_DEVICE_CREATE_INFO* pCreateInfo,
1891 XGL_DEVICE* pDevice);
1892
1893XGL_RESULT XGLAPI xglDestroyDevice(
1894 XGL_DEVICE device);
1895
1896// Extension discovery functions
1897
1898XGL_RESULT XGLAPI xglGetExtensionSupport(
1899 XGL_PHYSICAL_GPU gpu,
1900 const XGL_CHAR* pExtName);
1901
Jon Ashburn96f28fc2014-10-15 15:30:23 -0600[diff] [blame]1902// Layer discovery function
1903XGL_RESULT XGLAPI xglEnumerateLayers(
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]1904 XGL_PHYSICAL_GPU gpu,
1905 XGL_SIZE maxLayerCount,
1906 XGL_SIZE maxStringSize,
1907 XGL_CHAR* const* pOutLayers,
1908 XGL_SIZE* pOutLayerCount,
1909 XGL_VOID* pReserved);
Jon Ashburn96f28fc2014-10-15 15:30:23 -0600[diff] [blame]1910
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1911// Queue functions
1912
1913XGL_RESULT XGLAPI xglGetDeviceQueue(
1914 XGL_DEVICE device,
1915 XGL_QUEUE_TYPE queueType,
1916 XGL_UINT queueIndex,
1917 XGL_QUEUE* pQueue);
1918
1919XGL_RESULT XGLAPI xglQueueSubmit(
1920 XGL_QUEUE queue,
1921 XGL_UINT cmdBufferCount,
1922 const XGL_CMD_BUFFER* pCmdBuffers,
1923 XGL_UINT memRefCount,
1924 const XGL_MEMORY_REF* pMemRefs,
1925 XGL_FENCE fence);
1926
1927XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
1928 XGL_QUEUE queue,
1929 XGL_UINT memRefCount,
1930 const XGL_MEMORY_REF* pMemRefs);
1931
1932XGL_RESULT XGLAPI xglQueueWaitIdle(
1933 XGL_QUEUE queue);
1934
1935XGL_RESULT XGLAPI xglDeviceWaitIdle(
1936 XGL_DEVICE device);
1937
1938// Memory functions
1939
1940XGL_RESULT XGLAPI xglGetMemoryHeapCount(
1941 XGL_DEVICE device,
1942 XGL_UINT* pCount);
1943
1944XGL_RESULT XGLAPI xglGetMemoryHeapInfo(
1945 XGL_DEVICE device,
1946 XGL_UINT heapId,
1947 XGL_MEMORY_HEAP_INFO_TYPE infoType,
1948 XGL_SIZE* pDataSize,
1949 XGL_VOID* pData);
1950
1951XGL_RESULT XGLAPI xglAllocMemory(
1952 XGL_DEVICE device,
1953 const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
1954 XGL_GPU_MEMORY* pMem);
1955
1956XGL_RESULT XGLAPI xglFreeMemory(
1957 XGL_GPU_MEMORY mem);
1958
1959XGL_RESULT XGLAPI xglSetMemoryPriority(
1960 XGL_GPU_MEMORY mem,
1961 XGL_MEMORY_PRIORITY priority);
1962
1963XGL_RESULT XGLAPI xglMapMemory(
1964 XGL_GPU_MEMORY mem,
1965 XGL_FLAGS flags, // Reserved
1966 XGL_VOID** ppData);
1967
1968XGL_RESULT XGLAPI xglUnmapMemory(
1969 XGL_GPU_MEMORY mem);
1970
1971XGL_RESULT XGLAPI xglPinSystemMemory(
1972 XGL_DEVICE device,
1973 const XGL_VOID* pSysMem,
1974 XGL_SIZE memSize,
1975 XGL_GPU_MEMORY* pMem);
1976
1977XGL_RESULT XGLAPI xglRemapVirtualMemoryPages(
1978 XGL_DEVICE device,
1979 XGL_UINT rangeCount,
1980 const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
1981 XGL_UINT preWaitSemaphoreCount,
1982 const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
1983 XGL_UINT postSignalSemaphoreCount,
1984 const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
1985
1986// Multi-device functions
1987
1988XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
1989 XGL_PHYSICAL_GPU gpu0,
1990 XGL_PHYSICAL_GPU gpu1,
1991 XGL_GPU_COMPATIBILITY_INFO* pInfo);
1992
1993XGL_RESULT XGLAPI xglOpenSharedMemory(
1994 XGL_DEVICE device,
1995 const XGL_MEMORY_OPEN_INFO* pOpenInfo,
1996 XGL_GPU_MEMORY* pMem);
1997
1998XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
1999 XGL_DEVICE device,
2000 const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
2001 XGL_QUEUE_SEMAPHORE* pSemaphore);
2002
2003XGL_RESULT XGLAPI xglOpenPeerMemory(
2004 XGL_DEVICE device,
2005 const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
2006 XGL_GPU_MEMORY* pMem);
2007
2008XGL_RESULT XGLAPI xglOpenPeerImage(
2009 XGL_DEVICE device,
2010 const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
2011 XGL_IMAGE* pImage,
2012 XGL_GPU_MEMORY* pMem);
2013
2014// Generic API object functions
2015
2016XGL_RESULT XGLAPI xglDestroyObject(
2017 XGL_OBJECT object);
2018
2019XGL_RESULT XGLAPI xglGetObjectInfo(
2020 XGL_BASE_OBJECT object,
2021 XGL_OBJECT_INFO_TYPE infoType,
2022 XGL_SIZE* pDataSize,
2023 XGL_VOID* pData);
2024
2025XGL_RESULT XGLAPI xglBindObjectMemory(
2026 XGL_OBJECT object,
2027 XGL_GPU_MEMORY mem,
2028 XGL_GPU_SIZE offset);
2029
2030// Fence functions
2031
2032XGL_RESULT XGLAPI xglCreateFence(
2033 XGL_DEVICE device,
2034 const XGL_FENCE_CREATE_INFO* pCreateInfo,
2035 XGL_FENCE* pFence);
2036
2037XGL_RESULT XGLAPI xglGetFenceStatus(
2038 XGL_FENCE fence);
2039
2040XGL_RESULT XGLAPI xglWaitForFences(
2041 XGL_DEVICE device,
2042 XGL_UINT fenceCount,
2043 const XGL_FENCE* pFences,
2044 XGL_BOOL waitAll,
2045 XGL_UINT64 timeout);
2046
2047// Queue semaphore functions
2048
2049XGL_RESULT XGLAPI xglCreateQueueSemaphore(
2050 XGL_DEVICE device,
2051 const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
2052 XGL_QUEUE_SEMAPHORE* pSemaphore);
2053
2054XGL_RESULT XGLAPI xglSignalQueueSemaphore(
2055 XGL_QUEUE queue,
2056 XGL_QUEUE_SEMAPHORE semaphore);
2057
2058XGL_RESULT XGLAPI xglWaitQueueSemaphore(
2059 XGL_QUEUE queue,
2060 XGL_QUEUE_SEMAPHORE semaphore);
2061
2062// Event functions
2063
2064XGL_RESULT XGLAPI xglCreateEvent(
2065 XGL_DEVICE device,
2066 const XGL_EVENT_CREATE_INFO* pCreateInfo,
2067 XGL_EVENT* pEvent);
2068
2069XGL_RESULT XGLAPI xglGetEventStatus(
2070 XGL_EVENT event);
2071
2072XGL_RESULT XGLAPI xglSetEvent(
2073 XGL_EVENT event);
2074
2075XGL_RESULT XGLAPI xglResetEvent(
2076 XGL_EVENT event);
2077
2078// Query functions
2079
2080XGL_RESULT XGLAPI xglCreateQueryPool(
2081 XGL_DEVICE device,
2082 const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
2083 XGL_QUERY_POOL* pQueryPool);
2084
2085XGL_RESULT XGLAPI xglGetQueryPoolResults(
2086 XGL_QUERY_POOL queryPool,
2087 XGL_UINT startQuery,
2088 XGL_UINT queryCount,
2089 XGL_SIZE* pDataSize,
2090 XGL_VOID* pData);
2091
2092// Format capabilities
2093
2094XGL_RESULT XGLAPI xglGetFormatInfo(
2095 XGL_DEVICE device,
2096 XGL_FORMAT format,
2097 XGL_FORMAT_INFO_TYPE infoType,
2098 XGL_SIZE* pDataSize,
2099 XGL_VOID* pData);
2100
2101// Image functions
2102
2103XGL_RESULT XGLAPI xglCreateImage(
2104 XGL_DEVICE device,
2105 const XGL_IMAGE_CREATE_INFO* pCreateInfo,
2106 XGL_IMAGE* pImage);
2107
2108XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
2109 XGL_IMAGE image,
2110 const XGL_IMAGE_SUBRESOURCE* pSubresource,
2111 XGL_SUBRESOURCE_INFO_TYPE infoType,
2112 XGL_SIZE* pDataSize,
2113 XGL_VOID* pData);
2114
2115// Image view functions
2116
2117XGL_RESULT XGLAPI xglCreateImageView(
2118 XGL_DEVICE device,
2119 const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
2120 XGL_IMAGE_VIEW* pView);
2121
2122XGL_RESULT XGLAPI xglCreateColorAttachmentView(
2123 XGL_DEVICE device,
2124 const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
2125 XGL_COLOR_ATTACHMENT_VIEW* pView);
2126
2127XGL_RESULT XGLAPI xglCreateDepthStencilView(
2128 XGL_DEVICE device,
2129 const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
2130 XGL_DEPTH_STENCIL_VIEW* pView);
2131
2132// Shader functions
2133
2134XGL_RESULT XGLAPI xglCreateShader(
2135 XGL_DEVICE device,
2136 const XGL_SHADER_CREATE_INFO* pCreateInfo,
2137 XGL_SHADER* pShader);
2138
2139// Pipeline functions
2140
2141XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
2142 XGL_DEVICE device,
2143 const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
2144 XGL_PIPELINE* pPipeline);
2145
2146XGL_RESULT XGLAPI xglCreateComputePipeline(
2147 XGL_DEVICE device,
2148 const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
2149 XGL_PIPELINE* pPipeline);
2150
2151XGL_RESULT XGLAPI xglStorePipeline(
2152 XGL_PIPELINE pipeline,
2153 XGL_SIZE* pDataSize,
2154 XGL_VOID* pData);
2155
2156XGL_RESULT XGLAPI xglLoadPipeline(
2157 XGL_DEVICE device,
2158 XGL_SIZE dataSize,
2159 const XGL_VOID* pData,
2160 XGL_PIPELINE* pPipeline);
2161
2162XGL_RESULT XGLAPI xglCreatePipelineDelta(
2163 XGL_DEVICE device,
2164 XGL_PIPELINE p1,
2165 XGL_PIPELINE p2,
2166 XGL_PIPELINE_DELTA* delta);
2167
2168// Sampler functions
2169
2170XGL_RESULT XGLAPI xglCreateSampler(
2171 XGL_DEVICE device,
2172 const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
2173 XGL_SAMPLER* pSampler);
2174
2175// Descriptor set functions
2176
2177XGL_RESULT XGLAPI xglCreateDescriptorSet(
2178 XGL_DEVICE device,
2179 const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
2180 XGL_DESCRIPTOR_SET* pDescriptorSet);
2181
2182XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(
2183 XGL_DESCRIPTOR_SET descriptorSet);
2184
2185XGL_VOID XGLAPI xglEndDescriptorSetUpdate(
2186 XGL_DESCRIPTOR_SET descriptorSet);
2187
2188XGL_VOID XGLAPI xglAttachSamplerDescriptors(
2189 XGL_DESCRIPTOR_SET descriptorSet,
2190 XGL_UINT startSlot,
2191 XGL_UINT slotCount,
2192 const XGL_SAMPLER* pSamplers);
2193
2194XGL_VOID XGLAPI xglAttachImageViewDescriptors(
2195 XGL_DESCRIPTOR_SET descriptorSet,
2196 XGL_UINT startSlot,
2197 XGL_UINT slotCount,
2198 const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
2199
2200XGL_VOID XGLAPI xglAttachMemoryViewDescriptors(
2201 XGL_DESCRIPTOR_SET descriptorSet,
2202 XGL_UINT startSlot,
2203 XGL_UINT slotCount,
2204 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
2205
2206XGL_VOID XGLAPI xglAttachNestedDescriptors(
2207 XGL_DESCRIPTOR_SET descriptorSet,
2208 XGL_UINT startSlot,
2209 XGL_UINT slotCount,
2210 const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
2211
2212XGL_VOID XGLAPI xglClearDescriptorSetSlots(
2213 XGL_DESCRIPTOR_SET descriptorSet,
2214 XGL_UINT startSlot,
2215 XGL_UINT slotCount);
2216
2217// State object functions
2218
2219XGL_RESULT XGLAPI xglCreateViewportState(
2220 XGL_DEVICE device,
2221 const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
2222 XGL_VIEWPORT_STATE_OBJECT* pState);
2223
2224XGL_RESULT XGLAPI xglCreateRasterState(
2225 XGL_DEVICE device,
2226 const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
2227 XGL_RASTER_STATE_OBJECT* pState);
2228
2229XGL_RESULT XGLAPI xglCreateMsaaState(
2230 XGL_DEVICE device,
2231 const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
2232 XGL_MSAA_STATE_OBJECT* pState);
2233
2234XGL_RESULT XGLAPI xglCreateColorBlendState(
2235 XGL_DEVICE device,
2236 const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
2237 XGL_COLOR_BLEND_STATE_OBJECT* pState);
2238
2239XGL_RESULT XGLAPI xglCreateDepthStencilState(
2240 XGL_DEVICE device,
2241 const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
2242 XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
2243
2244// Command buffer functions
2245
2246XGL_RESULT XGLAPI xglCreateCommandBuffer(
2247 XGL_DEVICE device,
2248 const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
2249 XGL_CMD_BUFFER* pCmdBuffer);
2250
2251XGL_RESULT XGLAPI xglBeginCommandBuffer(
2252 XGL_CMD_BUFFER cmdBuffer,
2253 XGL_FLAGS flags); // XGL_CMD_BUFFER_BUILD_FLAGS
2254
2255XGL_RESULT XGLAPI xglEndCommandBuffer(
2256 XGL_CMD_BUFFER cmdBuffer);
2257
2258XGL_RESULT XGLAPI xglResetCommandBuffer(
2259 XGL_CMD_BUFFER cmdBuffer);
2260
2261// Command buffer building functions
2262
2263XGL_VOID XGLAPI xglCmdBindPipeline(
2264 XGL_CMD_BUFFER cmdBuffer,
2265 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2266 XGL_PIPELINE pipeline);
2267
2268XGL_VOID XGLAPI xglCmdBindPipelineDelta(
2269 XGL_CMD_BUFFER cmdBuffer,
2270 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2271 XGL_PIPELINE_DELTA delta);
2272
2273XGL_VOID XGLAPI xglCmdBindStateObject(
2274 XGL_CMD_BUFFER cmdBuffer,
2275 XGL_STATE_BIND_POINT stateBindPoint,
2276 XGL_STATE_OBJECT state);
2277
2278XGL_VOID XGLAPI xglCmdBindDescriptorSet(
2279 XGL_CMD_BUFFER cmdBuffer,
2280 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2281 XGL_UINT index,
2282 XGL_DESCRIPTOR_SET descriptorSet,
2283 XGL_UINT slotOffset);
2284
2285XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(
2286 XGL_CMD_BUFFER cmdBuffer,
2287 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2288 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
2289
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]2290// IMG CHANGE BEGIN - support for vertex input description
2291XGL_VOID XGLAPI xglCmdBindVertexData(
2292 XGL_CMD_BUFFER cmdBuffer,
2293 XGL_GPU_MEMORY mem,
2294 XGL_GPU_SIZE offset,
2295 XGL_UINT binding);
2296// IMG CHANGE END
2297
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2298XGL_VOID XGLAPI xglCmdBindIndexData(
2299 XGL_CMD_BUFFER cmdBuffer,
2300 XGL_GPU_MEMORY mem,
2301 XGL_GPU_SIZE offset,
2302 XGL_INDEX_TYPE indexType);
2303
2304XGL_VOID XGLAPI xglCmdBindAttachments(
2305 XGL_CMD_BUFFER cmdBuffer,
2306 XGL_UINT colorAttachmentCount,
2307 const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments,
2308 const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment);
2309
2310XGL_VOID XGLAPI xglCmdPrepareMemoryRegions(
2311 XGL_CMD_BUFFER cmdBuffer,
2312 XGL_UINT transitionCount,
2313 const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
2314
2315XGL_VOID XGLAPI xglCmdPrepareImages(
2316 XGL_CMD_BUFFER cmdBuffer,
2317 XGL_UINT transitionCount,
2318 const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
2319
2320XGL_VOID XGLAPI xglCmdDraw(
2321 XGL_CMD_BUFFER cmdBuffer,
2322 XGL_UINT firstVertex,
2323 XGL_UINT vertexCount,
2324 XGL_UINT firstInstance,
2325 XGL_UINT instanceCount);
2326
2327XGL_VOID XGLAPI xglCmdDrawIndexed(
2328 XGL_CMD_BUFFER cmdBuffer,
2329 XGL_UINT firstIndex,
2330 XGL_UINT indexCount,
2331 XGL_INT vertexOffset,
2332 XGL_UINT firstInstance,
2333 XGL_UINT instanceCount);
2334
2335XGL_VOID XGLAPI xglCmdDrawIndirect(
2336 XGL_CMD_BUFFER cmdBuffer,
2337 XGL_GPU_MEMORY mem,
2338 XGL_GPU_SIZE offset,
2339 XGL_UINT32 count,
2340 XGL_UINT32 stride);
2341
2342XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(
2343 XGL_CMD_BUFFER cmdBuffer,
2344 XGL_GPU_MEMORY mem,
2345 XGL_GPU_SIZE offset,
2346 XGL_UINT32 count,
2347 XGL_UINT32 stride);
2348
2349XGL_VOID XGLAPI xglCmdDispatch(
2350 XGL_CMD_BUFFER cmdBuffer,
2351 XGL_UINT x,
2352 XGL_UINT y,
2353 XGL_UINT z);
2354
2355XGL_VOID XGLAPI xglCmdDispatchIndirect(
2356 XGL_CMD_BUFFER cmdBuffer,
2357 XGL_GPU_MEMORY mem,
2358 XGL_GPU_SIZE offset);
2359
2360XGL_VOID XGLAPI xglCmdCopyMemory(
2361 XGL_CMD_BUFFER cmdBuffer,
2362 XGL_GPU_MEMORY srcMem,
2363 XGL_GPU_MEMORY destMem,
2364 XGL_UINT regionCount,
2365 const XGL_MEMORY_COPY* pRegions);
2366
2367XGL_VOID XGLAPI xglCmdCopyImage(
2368 XGL_CMD_BUFFER cmdBuffer,
2369 XGL_IMAGE srcImage,
2370 XGL_IMAGE destImage,
2371 XGL_UINT regionCount,
2372 const XGL_IMAGE_COPY* pRegions);
2373
2374XGL_VOID XGLAPI xglCmdCopyMemoryToImage(
2375 XGL_CMD_BUFFER cmdBuffer,
2376 XGL_GPU_MEMORY srcMem,
2377 XGL_IMAGE destImage,
2378 XGL_UINT regionCount,
2379 const XGL_MEMORY_IMAGE_COPY* pRegions);
2380
2381XGL_VOID XGLAPI xglCmdCopyImageToMemory(
2382 XGL_CMD_BUFFER cmdBuffer,
2383 XGL_IMAGE srcImage,
2384 XGL_GPU_MEMORY destMem,
2385 XGL_UINT regionCount,
2386 const XGL_MEMORY_IMAGE_COPY* pRegions);
2387
2388XGL_VOID XGLAPI xglCmdCloneImageData(
2389 XGL_CMD_BUFFER cmdBuffer,
2390 XGL_IMAGE srcImage,
2391 XGL_IMAGE_STATE srcImageState,
2392 XGL_IMAGE destImage,
2393 XGL_IMAGE_STATE destImageState);
2394
2395XGL_VOID XGLAPI xglCmdUpdateMemory(
2396 XGL_CMD_BUFFER cmdBuffer,
2397 XGL_GPU_MEMORY destMem,
2398 XGL_GPU_SIZE destOffset,
2399 XGL_GPU_SIZE dataSize,
2400 const XGL_UINT32* pData);
2401
2402XGL_VOID XGLAPI xglCmdFillMemory(
2403 XGL_CMD_BUFFER cmdBuffer,
2404 XGL_GPU_MEMORY destMem,
2405 XGL_GPU_SIZE destOffset,
2406 XGL_GPU_SIZE fillSize,
2407 XGL_UINT32 data);
2408
2409XGL_VOID XGLAPI xglCmdClearColorImage(
2410 XGL_CMD_BUFFER cmdBuffer,
2411 XGL_IMAGE image,
2412 const XGL_FLOAT color[4],
2413 XGL_UINT rangeCount,
2414 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2415
2416XGL_VOID XGLAPI xglCmdClearColorImageRaw(
2417 XGL_CMD_BUFFER cmdBuffer,
2418 XGL_IMAGE image,
2419 const XGL_UINT32 color[4],
2420 XGL_UINT rangeCount,
2421 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2422
2423XGL_VOID XGLAPI xglCmdClearDepthStencil(
2424 XGL_CMD_BUFFER cmdBuffer,
2425 XGL_IMAGE image,
2426 XGL_FLOAT depth,
2427 XGL_UINT32 stencil,
2428 XGL_UINT rangeCount,
2429 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2430
2431XGL_VOID XGLAPI xglCmdResolveImage(
2432 XGL_CMD_BUFFER cmdBuffer,
2433 XGL_IMAGE srcImage,
2434 XGL_IMAGE destImage,
2435 XGL_UINT rectCount,
2436 const XGL_IMAGE_RESOLVE* pRects);
2437
2438XGL_VOID XGLAPI xglCmdSetEvent(
2439 XGL_CMD_BUFFER cmdBuffer,
2440 XGL_EVENT event);
2441
2442XGL_VOID XGLAPI xglCmdResetEvent(
2443 XGL_CMD_BUFFER cmdBuffer,
2444 XGL_EVENT event);
2445
2446XGL_VOID XGLAPI xglCmdMemoryAtomic(
2447 XGL_CMD_BUFFER cmdBuffer,
2448 XGL_GPU_MEMORY destMem,
2449 XGL_GPU_SIZE destOffset,
2450 XGL_UINT64 srcData,
2451 XGL_ATOMIC_OP atomicOp);
2452
2453XGL_VOID XGLAPI xglCmdBeginQuery(
2454 XGL_CMD_BUFFER cmdBuffer,
2455 XGL_QUERY_POOL queryPool,
2456 XGL_UINT slot,
2457 XGL_FLAGS flags);
2458
2459XGL_VOID XGLAPI xglCmdEndQuery(
2460 XGL_CMD_BUFFER cmdBuffer,
2461 XGL_QUERY_POOL queryPool,
2462 XGL_UINT slot);
2463
2464XGL_VOID XGLAPI xglCmdResetQueryPool(
2465 XGL_CMD_BUFFER cmdBuffer,
2466 XGL_QUERY_POOL queryPool,
2467 XGL_UINT startQuery,
2468 XGL_UINT queryCount);
2469
2470XGL_VOID XGLAPI xglCmdWriteTimestamp(
2471 XGL_CMD_BUFFER cmdBuffer,
2472 XGL_TIMESTAMP_TYPE timestampType,
2473 XGL_GPU_MEMORY destMem,
2474 XGL_GPU_SIZE destOffset);
2475
2476XGL_VOID XGLAPI xglCmdInitAtomicCounters(
2477 XGL_CMD_BUFFER cmdBuffer,
2478 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2479 XGL_UINT startCounter,
2480 XGL_UINT counterCount,
2481 const XGL_UINT32* pData);
2482
2483XGL_VOID XGLAPI xglCmdLoadAtomicCounters(
2484 XGL_CMD_BUFFER cmdBuffer,
2485 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2486 XGL_UINT startCounter,
2487 XGL_UINT counterCount,
2488 XGL_GPU_MEMORY srcMem,
2489 XGL_GPU_SIZE srcOffset);
2490
2491XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
2492 XGL_CMD_BUFFER cmdBuffer,
2493 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2494 XGL_UINT startCounter,
2495 XGL_UINT counterCount,
2496 XGL_GPU_MEMORY destMem,
2497 XGL_GPU_SIZE destOffset);
2498
2499#ifdef __cplusplus
2500} // extern "C"
2501#endif // __cplusplus
2502
2503#endif // __XGL_H__
2504
2505/******************************************************************************************
2506
2507 Open Issues + Missing Features
2508 ------------------------------
2509
2510 Here are a few higher level issues that we'd like to fix given time. A feature missing
2511 from this header (or the following list) isn't necessarily an indication that we want
2512 to drop that feature. Only that we either haven't thought of it or haven't had time
2513 to add it yet.
2514
2515 1) Transform Feedback (XFB)
2516
2517 OpenGL supports transform feedback (XFB). That is not included in this header, but
2518 we feel there is likely value in including it.
2519
2520 To incorporate trasnform feedback, we could create a new pipeline stage. This would
2521 be injected into a PSO by including the following in the chain:
2522
2523 typedef struct _XGL_XFB_CREATE_INFO
2524 {
2525 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
2526 const XGL_VOID* pNext; // Pointer to next structure
2527 // More XFB state, if any goes here
2528 } XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
2529
2530 We expect that only the shader-side configuration (via layout qualifiers or their IR
2531 equivalent) is used to configure the data written to each stream. When transform
2532 feedback is part of the pipeline, transform feedback binding would be available
2533 through a new API bind point:
2534
2535 xglCmdBindTransformFeedbackMemoryView(
2536 XGL_CMD_BUFFER cmdBuffer,
2537 XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
2538 XGL_UINT index,
2539 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
2540
2541 2) Framebuffer Objects
2542
2543 The XGL API here doesn't have a direct equivalent for a framebuffer object. In GL,
2544 the framebuffer object owns attachments, and the indirection table for glDrawBuffers, etc.
2545 The indirection is gone - only identity is supported here.
2546
2547 We may introduce an analog to the framebuffer object that packages all color
2548 attachments. You would create a framebuffer thus:
2549
2550 typedef struct _XGL_FRAMEBUFFER_CREATE_INFO
2551 {
2552 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
2553 const XGL_VOID* pNext; // Pointer to next structure
2554 XGL_UINT32 colorAttachmentCount;
2555 XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments;
2556 XGL_DEPTH_STENCIL_BIND_INFO pDepthStencilAttachment;
2557 } XGL_FRAMEBUFFER_CREATE_INFO;
2558
2559 xglCreateFramebuffer(
2560 XGL_DEVICE device,
2561 const XGL_FRAMEBUFFER_CREATE_INFO* pInfo,
2562 XGL_FRAMEBUFFER* pFramebuffer);
2563
2564 We then replace the xglCmdBindAttachments API with:
2565
2566 xglBindFramebuffer(
2567 XGL_CMD_BUFFER cmdBuffer,
2568 XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
2569 XGL_FRAMEBUFFER framebuffer);
2570
2571 3) "Bindless" + support for non-bindless hardware.
2572
2573 XGL doesn't have bindless textures the way that GL does. It has resource descriptor
2574 sets, or resource tables. Resource tables can be nested and hold references to more
2575 resource tables. They are explicitly sized by the application and have no artificial
2576 upper size limit. An application can still attach as many textures as they want to
2577 a resource descriptor set, and can modify the set asynchronously to GPU work.
2578 Therefore, we can still have "unlimited textures". An application hoping to use
2579 bindless can use an index into a large table of textures and achieve the same effect.
2580
2581 For non-bindless hardware, with fixed (but potentially large) register files for
2582 resource bindings, the table approach should still work if a limited size can be
2583 reported somehow.
2584
2585 4) Clean up some remaining Mantle'isms.
2586
2587 Queue types: It's a bit hand wavey. In Mantle, we have a "universal" queue type that
2588 supports compute and graphics and a "compute" queue that only supports compute. Devices
2589 must support at least one universal queue and DMA queues are an extension. I would like
2590 to do the following (and have attempted to do that here, but am only half done):
2591
2592 a) Separate out the queue capabilities (compute, DMA, graphics) and allow support
2593 for any number of queues with any combination of capabilities each.
2594
2595 b) Allow compute-only or even DMA-only (like video capture or SDI) devices to
2596 be supported.
2597
2598 c) Allow new queue types to be supported by extensions without having to allocate
2599 bits in the bitfield until they're promoted to core.
2600
2601 Terminology: There are still some references to "targets" (render targets) and other
2602 terminology that has been changed from Mantle. Need to do a clean-up pass.
2603
2604 4) The window system interface is an extension in Mantle. We have not tried to fold
2605 any of it into core here. There is no mention of SwapBuffers, presentation, default
2606 framebuffers or anything like that. In the extension, presentation is queued up into
2607 the graphics queue just like any other command.
2608
2609*******************************************************************************************/