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