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