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