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