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