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