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