diff options
| author | Courtney Goeltzenleuchter <courtney@LunarG.com> | 2015-04-08 15:36:08 -0600 |
|---|---|---|
| committer | Chia-I Wu <olv@lunarg.com> | 2015-04-16 17:48:17 +0800 |
| commit | a4131c4e8a3027dbda941e43992fa2435801247e (patch) | |
| tree | 9b2d3b1526d31d16e3a57c5ff096794cd835b44f /include | |
| parent | 63b889ec0ae38e1ba1db8e1970f934caef51ce9e (diff) | |
| download | usermoji-a4131c4e8a3027dbda941e43992fa2435801247e.tar.xz | |
Stage 1 of rename
TODO: re-enable glave build, advance API for glave
v2: get rid of outdated code in tri introduced by rebase
rename wsi_null.c (olv)
Diffstat (limited to 'include')
| -rw-r--r-- | include/xgl.h | 4408 | ||||
| -rw-r--r-- | include/xglDbg.h | 246 | ||||
| -rw-r--r-- | include/xglIcd.h | 16 | ||||
| -rw-r--r-- | include/xglLayer.h | 314 | ||||
| -rw-r--r-- | include/xglPlatform.h | 28 | ||||
| -rw-r--r-- | include/xglWsiWinExt.h | 12 | ||||
| -rw-r--r-- | include/xglWsiX11Ext.h | 78 |
7 files changed, 2551 insertions, 2551 deletions
diff --git a/include/xgl.h b/include/xgl.h index b937d42b..b78a56cd 100644 --- a/include/xgl.h +++ b/include/xgl.h @@ -1,5 +1,5 @@ // -// File: xgl.h +// File: vulkan.h // /* ** Copyright (c) 2014 The Khronos Group Inc. @@ -24,16 +24,16 @@ ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. */ -#ifndef __XGL_H__ -#define __XGL_H__ +#ifndef __VULKAN_H__ +#define __VULKAN_H__ -#define XGL_MAKE_VERSION(major, minor, patch) \ +#define VK_MAKE_VERSION(major, minor, patch) \ ((major << 22) | (minor << 12) | patch) -#include "xglPlatform.h" +#include "vkPlatform.h" -// XGL API version supported by this file -#define XGL_API_VERSION XGL_MAKE_VERSION(0, 67, 0) +// VK API version supported by this file +#define VK_API_VERSION VK_MAKE_VERSION(0, 67, 0) #ifdef __cplusplus extern "C" @@ -42,1275 +42,1275 @@ extern "C" /* *************************************************************************************************** -* Core XGL API +* Core VK API *************************************************************************************************** */ #ifdef __cplusplus - #define XGL_DEFINE_HANDLE(_obj) struct _obj##_T {char _dummy;}; typedef _obj##_T* _obj; - #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj; + #define VK_DEFINE_HANDLE(_obj) struct _obj##_T {char _dummy;}; typedef _obj##_T* _obj; + #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj; #else // __cplusplus - #define XGL_DEFINE_HANDLE(_obj) typedef void* _obj; - #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj; + #define VK_DEFINE_HANDLE(_obj) typedef void* _obj; + #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj; #endif // __cplusplus -XGL_DEFINE_HANDLE(XGL_INSTANCE) -XGL_DEFINE_HANDLE(XGL_PHYSICAL_GPU) -XGL_DEFINE_HANDLE(XGL_BASE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEVICE, XGL_BASE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE, XGL_BASE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_GPU_MEMORY, XGL_BASE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_OBJECT, XGL_BASE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER_VIEW, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE_VIEW, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_ATTACHMENT_VIEW, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_VIEW, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_SHADER, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET_LAYOUT, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET_LAYOUT_CHAIN, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_POOL, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_STATE_OBJECT, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_CMD_BUFFER, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_FENCE, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_SEMAPHORE, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_EVENT, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUERY_POOL, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_FRAMEBUFFER, XGL_OBJECT) -XGL_DEFINE_SUBCLASS_HANDLE(XGL_RENDER_PASS, XGL_OBJECT) - -#define XGL_MAX_PHYSICAL_GPUS 16 -#define XGL_MAX_PHYSICAL_GPU_NAME 256 - -#define XGL_LOD_CLAMP_NONE MAX_FLOAT -#define XGL_LAST_MIP_OR_SLICE 0xffffffff - -#define XGL_TRUE 1 -#define XGL_FALSE 0 - -#define XGL_NULL_HANDLE 0 +VK_DEFINE_HANDLE(VK_INSTANCE) +VK_DEFINE_HANDLE(VK_PHYSICAL_GPU) +VK_DEFINE_HANDLE(VK_BASE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DEVICE, VK_BASE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_QUEUE, VK_BASE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_GPU_MEMORY, VK_BASE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_OBJECT, VK_BASE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER_VIEW, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE_VIEW, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_COLOR_ATTACHMENT_VIEW, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DEPTH_STENCIL_VIEW, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_SHADER, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_PIPELINE, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_SAMPLER, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT_CHAIN, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_POOL, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_STATE_OBJECT, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_VP_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_RS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_CB_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_DS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_CMD_BUFFER, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_FENCE, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_SEMAPHORE, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_EVENT, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_QUERY_POOL, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_FRAMEBUFFER, VK_OBJECT) +VK_DEFINE_SUBCLASS_HANDLE(VK_RENDER_PASS, VK_OBJECT) + +#define VK_MAX_PHYSICAL_GPUS 16 +#define VK_MAX_PHYSICAL_GPU_NAME 256 + +#define VK_LOD_CLAMP_NONE MAX_FLOAT +#define VK_LAST_MIP_OR_SLICE 0xffffffff + +#define VK_TRUE 1 +#define VK_FALSE 0 + +#define VK_NULL_HANDLE 0 // This macro defines INT_MAX in enumerations to force compilers to use 32 bits // to represent them. This may or may not be necessary on some compilers. The // option to compile it out may allow compilers that warn about missing enumerants // in switch statements to be silenced. -#define XGL_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF +#define VK_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF // ------------------------------------------------------------------------------------------------ // Enumerations -typedef enum _XGL_MEMORY_PRIORITY -{ - XGL_MEMORY_PRIORITY_UNUSED = 0x0, - XGL_MEMORY_PRIORITY_VERY_LOW = 0x1, - XGL_MEMORY_PRIORITY_LOW = 0x2, - XGL_MEMORY_PRIORITY_NORMAL = 0x3, - XGL_MEMORY_PRIORITY_HIGH = 0x4, - XGL_MEMORY_PRIORITY_VERY_HIGH = 0x5, - - XGL_MEMORY_PRIORITY_BEGIN_RANGE = XGL_MEMORY_PRIORITY_UNUSED, - XGL_MEMORY_PRIORITY_END_RANGE = XGL_MEMORY_PRIORITY_VERY_HIGH, - XGL_NUM_MEMORY_PRIORITY = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_MEMORY_PRIORITY) -} XGL_MEMORY_PRIORITY; - -typedef enum _XGL_IMAGE_LAYOUT -{ - XGL_IMAGE_LAYOUT_UNDEFINED = 0x00000000, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) - XGL_IMAGE_LAYOUT_GENERAL = 0x00000001, // General layout when image can be used for any kind of access - XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, // Optimal layout when image is only used for color attachment read/write - XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, // Optimal layout when image is only used for depth/stencil attachment read/write - XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, // Optimal layout when image is used for read only depth/stencil attachment and shader access - XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, // Optimal layout when image is used for read only shader access - XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006, // Optimal layout when image is used only for clear operations - XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007, // Optimal layout when image is used only as source of transfer operations - XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008, // Optimal layout when image is used only as destination of transfer operations - - XGL_IMAGE_LAYOUT_BEGIN_RANGE = XGL_IMAGE_LAYOUT_UNDEFINED, - XGL_IMAGE_LAYOUT_END_RANGE = XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, - XGL_NUM_IMAGE_LAYOUT = (XGL_IMAGE_LAYOUT_END_RANGE - XGL_IMAGE_LAYOUT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_IMAGE_LAYOUT) -} XGL_IMAGE_LAYOUT; - -typedef enum _XGL_PIPE_EVENT -{ - XGL_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the GPU starts processing subsequent command - XGL_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete - XGL_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003, // Set event when all pending fragment shader executions are complete, within each fragment location - XGL_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004, // Set event when all pending fragment shader executions are complete - XGL_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005, // Set event when all pending graphics operations are complete - XGL_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006, // Set event when all pending compute operations are complete - XGL_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007, // Set event when all pending transfer operations are complete - XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE = 0x00000008, // Set event when all pending GPU work is complete - - XGL_PIPE_EVENT_BEGIN_RANGE = XGL_PIPE_EVENT_TOP_OF_PIPE, - XGL_PIPE_EVENT_END_RANGE = XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE, - XGL_NUM_PIPE_EVENT = (XGL_PIPE_EVENT_END_RANGE - XGL_PIPE_EVENT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_PIPE_EVENT) -} XGL_PIPE_EVENT; - -typedef enum _XGL_WAIT_EVENT -{ - XGL_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the GPU starts processing subsequent commands - XGL_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002, // Wait event before rasterizing subsequent primitives - - XGL_WAIT_EVENT_BEGIN_RANGE = XGL_WAIT_EVENT_TOP_OF_PIPE, - XGL_WAIT_EVENT_END_RANGE = XGL_WAIT_EVENT_BEFORE_RASTERIZATION, - XGL_NUM_WAIT_EVENT = (XGL_WAIT_EVENT_END_RANGE - XGL_WAIT_EVENT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_WAIT_EVENT) -} XGL_WAIT_EVENT; - -typedef enum _XGL_MEMORY_OUTPUT_FLAGS -{ - XGL_MEMORY_OUTPUT_CPU_WRITE_BIT = 0x00000001, // Controls output coherency of CPU writes - XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, // Controls output coherency of generic shader writes - XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, // Controls output coherency of color attachment writes - XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, // Controls output coherency of depth/stencil attachment writes - XGL_MEMORY_OUTPUT_COPY_BIT = 0x00000010, // Controls output coherency of copy operations - XGL_MAX_ENUM(_XGL_MEMORY_OUTPUT_FLAGS) -} XGL_MEMORY_OUTPUT_FLAGS; - -typedef enum _XGL_MEMORY_INPUT_FLAGS -{ - XGL_MEMORY_INPUT_CPU_READ_BIT = 0x00000001, // Controls input coherency of CPU reads - XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, // Controls input coherency of indirect command reads - XGL_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, // Controls input coherency of index fetches - XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, // Controls input coherency of vertex attribute fetches - XGL_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, // Controls input coherency of uniform buffer reads - XGL_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, // Controls input coherency of generic shader reads - XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, // Controls input coherency of color attachment reads - XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, // Controls input coherency of depth/stencil attachment reads - XGL_MEMORY_INPUT_COPY_BIT = 0x00000100, // Controls input coherency of copy operations - XGL_MAX_ENUM(_XGL_MEMORY_INPUT_FLAGS) -} XGL_MEMORY_INPUT_FLAGS; - -typedef enum _XGL_ATTACHMENT_LOAD_OP -{ - XGL_ATTACHMENT_LOAD_OP_LOAD = 0x00000000, - XGL_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001, - XGL_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002, - - XGL_ATTACHMENT_LOAD_OP_BEGIN_RANGE = XGL_ATTACHMENT_LOAD_OP_LOAD, - XGL_ATTACHMENT_LOAD_OP_END_RANGE = XGL_ATTACHMENT_LOAD_OP_DONT_CARE, - XGL_NUM_ATTACHMENT_LOAD_OP = (XGL_ATTACHMENT_LOAD_OP_END_RANGE - XGL_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_ATTACHMENT_LOAD_OP) -} XGL_ATTACHMENT_LOAD_OP; - -typedef enum _XGL_ATTACHMENT_STORE_OP -{ - XGL_ATTACHMENT_STORE_OP_STORE = 0x00000000, - XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001, - XGL_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002, - - XGL_ATTACHMENT_STORE_OP_BEGIN_RANGE = XGL_ATTACHMENT_STORE_OP_STORE, - XGL_ATTACHMENT_STORE_OP_END_RANGE = XGL_ATTACHMENT_STORE_OP_DONT_CARE, - XGL_NUM_ATTACHMENT_STORE_OP = (XGL_ATTACHMENT_STORE_OP_END_RANGE - XGL_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_ATTACHMENT_STORE_OP) -} XGL_ATTACHMENT_STORE_OP; - -typedef enum _XGL_IMAGE_TYPE -{ - XGL_IMAGE_1D = 0x00000000, - XGL_IMAGE_2D = 0x00000001, - XGL_IMAGE_3D = 0x00000002, - - XGL_IMAGE_TYPE_BEGIN_RANGE = XGL_IMAGE_1D, - XGL_IMAGE_TYPE_END_RANGE = XGL_IMAGE_3D, - XGL_NUM_IMAGE_TYPE = (XGL_IMAGE_TYPE_END_RANGE - XGL_IMAGE_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_IMAGE_TYPE) -} XGL_IMAGE_TYPE; - -typedef enum _XGL_IMAGE_TILING -{ - XGL_LINEAR_TILING = 0x00000000, - XGL_OPTIMAL_TILING = 0x00000001, - - XGL_IMAGE_TILING_BEGIN_RANGE = XGL_LINEAR_TILING, - XGL_IMAGE_TILING_END_RANGE = XGL_OPTIMAL_TILING, - XGL_NUM_IMAGE_TILING = (XGL_IMAGE_TILING_END_RANGE - XGL_IMAGE_TILING_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_IMAGE_TILING) -} XGL_IMAGE_TILING; - -typedef enum _XGL_IMAGE_VIEW_TYPE -{ - XGL_IMAGE_VIEW_1D = 0x00000000, - XGL_IMAGE_VIEW_2D = 0x00000001, - XGL_IMAGE_VIEW_3D = 0x00000002, - XGL_IMAGE_VIEW_CUBE = 0x00000003, - - XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE = XGL_IMAGE_VIEW_1D, - XGL_IMAGE_VIEW_TYPE_END_RANGE = XGL_IMAGE_VIEW_CUBE, - XGL_NUM_IMAGE_VIEW_TYPE = (XGL_IMAGE_VIEW_TYPE_END_RANGE - XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_IMAGE_VIEW_TYPE) -} XGL_IMAGE_VIEW_TYPE; - -typedef enum _XGL_IMAGE_ASPECT -{ - XGL_IMAGE_ASPECT_COLOR = 0x00000000, - XGL_IMAGE_ASPECT_DEPTH = 0x00000001, - XGL_IMAGE_ASPECT_STENCIL = 0x00000002, - - XGL_IMAGE_ASPECT_BEGIN_RANGE = XGL_IMAGE_ASPECT_COLOR, - XGL_IMAGE_ASPECT_END_RANGE = XGL_IMAGE_ASPECT_STENCIL, - XGL_NUM_IMAGE_ASPECT = (XGL_IMAGE_ASPECT_END_RANGE - XGL_IMAGE_ASPECT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_IMAGE_ASPECT) -} XGL_IMAGE_ASPECT; - -typedef enum _XGL_CHANNEL_SWIZZLE -{ - XGL_CHANNEL_SWIZZLE_ZERO = 0x00000000, - XGL_CHANNEL_SWIZZLE_ONE = 0x00000001, - XGL_CHANNEL_SWIZZLE_R = 0x00000002, - XGL_CHANNEL_SWIZZLE_G = 0x00000003, - XGL_CHANNEL_SWIZZLE_B = 0x00000004, - XGL_CHANNEL_SWIZZLE_A = 0x00000005, - - XGL_CHANNEL_SWIZZLE_BEGIN_RANGE = XGL_CHANNEL_SWIZZLE_ZERO, - XGL_CHANNEL_SWIZZLE_END_RANGE = XGL_CHANNEL_SWIZZLE_A, - XGL_NUM_CHANNEL_SWIZZLE = (XGL_CHANNEL_SWIZZLE_END_RANGE - XGL_CHANNEL_SWIZZLE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_CHANNEL_SWIZZLE) -} XGL_CHANNEL_SWIZZLE; - -typedef enum _XGL_DESCRIPTOR_TYPE -{ - XGL_DESCRIPTOR_TYPE_SAMPLER = 0x00000000, - XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE = 0x00000001, - XGL_DESCRIPTOR_TYPE_TEXTURE = 0x00000002, - XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER = 0x00000003, - XGL_DESCRIPTOR_TYPE_IMAGE = 0x00000004, - XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER = 0x00000005, - XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006, - XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER = 0x00000007, - XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008, - XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC = 0x00000009, +typedef enum _VK_MEMORY_PRIORITY +{ + VK_MEMORY_PRIORITY_UNUSED = 0x0, + VK_MEMORY_PRIORITY_VERY_LOW = 0x1, + VK_MEMORY_PRIORITY_LOW = 0x2, + VK_MEMORY_PRIORITY_NORMAL = 0x3, + VK_MEMORY_PRIORITY_HIGH = 0x4, + VK_MEMORY_PRIORITY_VERY_HIGH = 0x5, + + VK_MEMORY_PRIORITY_BEGIN_RANGE = VK_MEMORY_PRIORITY_UNUSED, + VK_MEMORY_PRIORITY_END_RANGE = VK_MEMORY_PRIORITY_VERY_HIGH, + VK_NUM_MEMORY_PRIORITY = (VK_MEMORY_PRIORITY_END_RANGE - VK_MEMORY_PRIORITY_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_MEMORY_PRIORITY) +} VK_MEMORY_PRIORITY; + +typedef enum _VK_IMAGE_LAYOUT +{ + VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) + VK_IMAGE_LAYOUT_GENERAL = 0x00000001, // General layout when image can be used for any kind of access + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, // Optimal layout when image is only used for color attachment read/write + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, // Optimal layout when image is only used for depth/stencil attachment read/write + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, // Optimal layout when image is used for read only depth/stencil attachment and shader access + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, // Optimal layout when image is used for read only shader access + VK_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006, // Optimal layout when image is used only for clear operations + VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007, // Optimal layout when image is used only as source of transfer operations + VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008, // Optimal layout when image is used only as destination of transfer operations + + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, + VK_NUM_IMAGE_LAYOUT = (VK_IMAGE_LAYOUT_END_RANGE - VK_IMAGE_LAYOUT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_IMAGE_LAYOUT) +} VK_IMAGE_LAYOUT; + +typedef enum _VK_PIPE_EVENT +{ + VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the GPU starts processing subsequent command + VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete + VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003, // Set event when all pending fragment shader executions are complete, within each fragment location + VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004, // Set event when all pending fragment shader executions are complete + VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005, // Set event when all pending graphics operations are complete + VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006, // Set event when all pending compute operations are complete + VK_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007, // Set event when all pending transfer operations are complete + VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE = 0x00000008, // Set event when all pending GPU work is complete + + VK_PIPE_EVENT_BEGIN_RANGE = VK_PIPE_EVENT_TOP_OF_PIPE, + VK_PIPE_EVENT_END_RANGE = VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE, + VK_NUM_PIPE_EVENT = (VK_PIPE_EVENT_END_RANGE - VK_PIPE_EVENT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_PIPE_EVENT) +} VK_PIPE_EVENT; + +typedef enum _VK_WAIT_EVENT +{ + VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the GPU starts processing subsequent commands + VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002, // Wait event before rasterizing subsequent primitives + + VK_WAIT_EVENT_BEGIN_RANGE = VK_WAIT_EVENT_TOP_OF_PIPE, + VK_WAIT_EVENT_END_RANGE = VK_WAIT_EVENT_BEFORE_RASTERIZATION, + VK_NUM_WAIT_EVENT = (VK_WAIT_EVENT_END_RANGE - VK_WAIT_EVENT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_WAIT_EVENT) +} VK_WAIT_EVENT; + +typedef enum _VK_MEMORY_OUTPUT_FLAGS +{ + VK_MEMORY_OUTPUT_CPU_WRITE_BIT = 0x00000001, // Controls output coherency of CPU writes + VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, // Controls output coherency of generic shader writes + VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, // Controls output coherency of color attachment writes + VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, // Controls output coherency of depth/stencil attachment writes + VK_MEMORY_OUTPUT_COPY_BIT = 0x00000010, // Controls output coherency of copy operations + VK_MAX_ENUM(_VK_MEMORY_OUTPUT_FLAGS) +} VK_MEMORY_OUTPUT_FLAGS; + +typedef enum _VK_MEMORY_INPUT_FLAGS +{ + VK_MEMORY_INPUT_CPU_READ_BIT = 0x00000001, // Controls input coherency of CPU reads + VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, // Controls input coherency of indirect command reads + VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, // Controls input coherency of index fetches + VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, // Controls input coherency of vertex attribute fetches + VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, // Controls input coherency of uniform buffer reads + VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, // Controls input coherency of generic shader reads + VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, // Controls input coherency of color attachment reads + VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, // Controls input coherency of depth/stencil attachment reads + VK_MEMORY_INPUT_COPY_BIT = 0x00000100, // Controls input coherency of copy operations + VK_MAX_ENUM(_VK_MEMORY_INPUT_FLAGS) +} VK_MEMORY_INPUT_FLAGS; + +typedef enum _VK_ATTACHMENT_LOAD_OP +{ + VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000, + VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002, + + VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, + VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_NUM_ATTACHMENT_LOAD_OP = (VK_ATTACHMENT_LOAD_OP_END_RANGE - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_ATTACHMENT_LOAD_OP) +} VK_ATTACHMENT_LOAD_OP; + +typedef enum _VK_ATTACHMENT_STORE_OP +{ + VK_ATTACHMENT_STORE_OP_STORE = 0x00000000, + VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002, + + VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_NUM_ATTACHMENT_STORE_OP = (VK_ATTACHMENT_STORE_OP_END_RANGE - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_ATTACHMENT_STORE_OP) +} VK_ATTACHMENT_STORE_OP; + +typedef enum _VK_IMAGE_TYPE +{ + VK_IMAGE_1D = 0x00000000, + VK_IMAGE_2D = 0x00000001, + VK_IMAGE_3D = 0x00000002, + + VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_1D, + VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_3D, + VK_NUM_IMAGE_TYPE = (VK_IMAGE_TYPE_END_RANGE - VK_IMAGE_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_IMAGE_TYPE) +} VK_IMAGE_TYPE; + +typedef enum _VK_IMAGE_TILING +{ + VK_LINEAR_TILING = 0x00000000, + VK_OPTIMAL_TILING = 0x00000001, + + VK_IMAGE_TILING_BEGIN_RANGE = VK_LINEAR_TILING, + VK_IMAGE_TILING_END_RANGE = VK_OPTIMAL_TILING, + VK_NUM_IMAGE_TILING = (VK_IMAGE_TILING_END_RANGE - VK_IMAGE_TILING_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_IMAGE_TILING) +} VK_IMAGE_TILING; + +typedef enum _VK_IMAGE_VIEW_TYPE +{ + VK_IMAGE_VIEW_1D = 0x00000000, + VK_IMAGE_VIEW_2D = 0x00000001, + VK_IMAGE_VIEW_3D = 0x00000002, + VK_IMAGE_VIEW_CUBE = 0x00000003, + + VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_1D, + VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_CUBE, + VK_NUM_IMAGE_VIEW_TYPE = (VK_IMAGE_VIEW_TYPE_END_RANGE - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_IMAGE_VIEW_TYPE) +} VK_IMAGE_VIEW_TYPE; + +typedef enum _VK_IMAGE_ASPECT +{ + VK_IMAGE_ASPECT_COLOR = 0x00000000, + VK_IMAGE_ASPECT_DEPTH = 0x00000001, + VK_IMAGE_ASPECT_STENCIL = 0x00000002, + + VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, + VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_STENCIL, + VK_NUM_IMAGE_ASPECT = (VK_IMAGE_ASPECT_END_RANGE - VK_IMAGE_ASPECT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_IMAGE_ASPECT) +} VK_IMAGE_ASPECT; + +typedef enum _VK_CHANNEL_SWIZZLE +{ + VK_CHANNEL_SWIZZLE_ZERO = 0x00000000, + VK_CHANNEL_SWIZZLE_ONE = 0x00000001, + VK_CHANNEL_SWIZZLE_R = 0x00000002, + VK_CHANNEL_SWIZZLE_G = 0x00000003, + VK_CHANNEL_SWIZZLE_B = 0x00000004, + VK_CHANNEL_SWIZZLE_A = 0x00000005, + + VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, + VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, + VK_NUM_CHANNEL_SWIZZLE = (VK_CHANNEL_SWIZZLE_END_RANGE - VK_CHANNEL_SWIZZLE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_CHANNEL_SWIZZLE) +} VK_CHANNEL_SWIZZLE; + +typedef enum _VK_DESCRIPTOR_TYPE +{ + VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000, + VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE = 0x00000001, + VK_DESCRIPTOR_TYPE_TEXTURE = 0x00000002, + VK_DESCRIPTOR_TYPE_TEXTURE_BUFFER = 0x00000003, + VK_DESCRIPTOR_TYPE_IMAGE = 0x00000004, + VK_DESCRIPTOR_TYPE_IMAGE_BUFFER = 0x00000005, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006, + VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER = 0x00000007, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008, + VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC = 0x00000009, - XGL_DESCRIPTOR_TYPE_BEGIN_RANGE = XGL_DESCRIPTOR_TYPE_SAMPLER, - XGL_DESCRIPTOR_TYPE_END_RANGE = XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC, - XGL_NUM_DESCRIPTOR_TYPE = (XGL_DESCRIPTOR_TYPE_END_RANGE - XGL_DESCRIPTOR_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_DESCRIPTOR_TYPE) -} XGL_DESCRIPTOR_TYPE; - -typedef enum _XGL_DESCRIPTOR_POOL_USAGE -{ - XGL_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000, - XGL_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001, - - XGL_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = XGL_DESCRIPTOR_POOL_USAGE_ONE_SHOT, - XGL_DESCRIPTOR_POOL_USAGE_END_RANGE = XGL_DESCRIPTOR_POOL_USAGE_DYNAMIC, - XGL_NUM_DESCRIPTOR_POOL_USAGE = (XGL_DESCRIPTOR_POOL_USAGE_END_RANGE - XGL_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_DESCRIPTOR_POOL_USAGE) -} XGL_DESCRIPTOR_POOL_USAGE; - -typedef enum _XGL_DESCRIPTOR_UPDATE_MODE -{ - XGL_DESCRIPTOR_UDPATE_MODE_COPY = 0x00000000, - XGL_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001, - - XGL_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE = XGL_DESCRIPTOR_UDPATE_MODE_COPY, - XGL_DESCRIPTOR_UPDATE_MODE_END_RANGE = XGL_DESCRIPTOR_UPDATE_MODE_FASTEST, - XGL_NUM_DESCRIPTOR_UPDATE_MODE = (XGL_DESCRIPTOR_UPDATE_MODE_END_RANGE - XGL_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_DESCRIPTOR_UPDATE_MODE) -} XGL_DESCRIPTOR_UPDATE_MODE; - -typedef enum _XGL_DESCRIPTOR_SET_USAGE -{ - XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000, - XGL_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001, - - XGL_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT, - XGL_DESCRIPTOR_SET_USAGE_END_RANGE = XGL_DESCRIPTOR_SET_USAGE_STATIC, - XGL_NUM_DESCRIPTOR_SET_USAGE = (XGL_DESCRIPTOR_SET_USAGE_END_RANGE - XGL_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_DESCRIPTOR_SET_USAGE) -} XGL_DESCRIPTOR_SET_USAGE; - -typedef enum _XGL_QUERY_TYPE -{ - XGL_QUERY_OCCLUSION = 0x00000000, - XGL_QUERY_PIPELINE_STATISTICS = 0x00000001, - - XGL_QUERY_TYPE_BEGIN_RANGE = XGL_QUERY_OCCLUSION, - XGL_QUERY_TYPE_END_RANGE = XGL_QUERY_PIPELINE_STATISTICS, - XGL_NUM_QUERY_TYPE = (XGL_QUERY_TYPE_END_RANGE - XGL_QUERY_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_QUERY_TYPE) -} XGL_QUERY_TYPE; - -typedef enum _XGL_TIMESTAMP_TYPE -{ - XGL_TIMESTAMP_TOP = 0x00000000, - XGL_TIMESTAMP_BOTTOM = 0x00000001, - - XGL_TIMESTAMP_TYPE_BEGIN_RANGE = XGL_TIMESTAMP_TOP, - XGL_TIMESTAMP_TYPE_END_RANGE = XGL_TIMESTAMP_BOTTOM, - XGL_NUM_TIMESTAMP_TYPE = (XGL_TIMESTAMP_TYPE_END_RANGE - XGL_TIMESTAMP_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_TIMESTEAMP_TYPE) -} XGL_TIMESTAMP_TYPE; - -typedef enum _XGL_BORDER_COLOR_TYPE -{ - XGL_BORDER_COLOR_OPAQUE_WHITE = 0x00000000, - XGL_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001, - XGL_BORDER_COLOR_OPAQUE_BLACK = 0x00000002, - - XGL_BORDER_COLOR_TYPE_BEGIN_RANGE = XGL_BORDER_COLOR_OPAQUE_WHITE, - XGL_BORDER_COLOR_TYPE_END_RANGE = XGL_BORDER_COLOR_OPAQUE_BLACK, - XGL_NUM_BORDER_COLOR_TYPE = (XGL_BORDER_COLOR_TYPE_END_RANGE - XGL_BORDER_COLOR_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_BORDER_COLOR_TYPE) -} XGL_BORDER_COLOR_TYPE; - -typedef enum _XGL_PIPELINE_BIND_POINT -{ - XGL_PIPELINE_BIND_POINT_COMPUTE = 0x00000000, - XGL_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001, - - XGL_PIPELINE_BIND_POINT_BEGIN_RANGE = XGL_PIPELINE_BIND_POINT_COMPUTE, - XGL_PIPELINE_BIND_POINT_END_RANGE = XGL_PIPELINE_BIND_POINT_GRAPHICS, - XGL_NUM_PIPELINE_BIND_POINT = (XGL_PIPELINE_BIND_POINT_END_RANGE - XGL_PIPELINE_BIND_POINT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_PIPELINE_BIND_POINT) -} XGL_PIPELINE_BIND_POINT; - -typedef enum _XGL_STATE_BIND_POINT -{ - XGL_STATE_BIND_VIEWPORT = 0x00000000, - XGL_STATE_BIND_RASTER = 0x00000001, - XGL_STATE_BIND_COLOR_BLEND = 0x00000002, - XGL_STATE_BIND_DEPTH_STENCIL = 0x00000003, - - XGL_STATE_BIND_POINT_BEGIN_RANGE = XGL_STATE_BIND_VIEWPORT, - XGL_STATE_BIND_POINT_END_RANGE = XGL_STATE_BIND_DEPTH_STENCIL, - XGL_NUM_STATE_BIND_POINT = (XGL_STATE_BIND_POINT_END_RANGE - XGL_STATE_BIND_POINT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_STATE_BIND_POINT) -} XGL_STATE_BIND_POINT; - -typedef enum _XGL_PRIMITIVE_TOPOLOGY -{ - XGL_TOPOLOGY_POINT_LIST = 0x00000000, - XGL_TOPOLOGY_LINE_LIST = 0x00000001, - XGL_TOPOLOGY_LINE_STRIP = 0x00000002, - XGL_TOPOLOGY_TRIANGLE_LIST = 0x00000003, - XGL_TOPOLOGY_TRIANGLE_STRIP = 0x00000004, - XGL_TOPOLOGY_TRIANGLE_FAN = 0x00000005, - XGL_TOPOLOGY_LINE_LIST_ADJ = 0x00000006, - XGL_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007, - XGL_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008, - XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009, - XGL_TOPOLOGY_PATCH = 0x0000000a, - - XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = XGL_TOPOLOGY_POINT_LIST, - XGL_PRIMITIVE_TOPOLOGY_END_RANGE = XGL_TOPOLOGY_PATCH, - XGL_NUM_PRIMITIVE_TOPOLOGY = (XGL_PRIMITIVE_TOPOLOGY_END_RANGE - XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_PRIMITIVE_TOPOLOGY) -} XGL_PRIMITIVE_TOPOLOGY; - -typedef enum _XGL_INDEX_TYPE -{ - XGL_INDEX_8 = 0x00000000, - XGL_INDEX_16 = 0x00000001, - XGL_INDEX_32 = 0x00000002, - - XGL_INDEX_TYPE_BEGIN_RANGE = XGL_INDEX_8, - XGL_INDEX_TYPE_END_RANGE = XGL_INDEX_32, - XGL_NUM_INDEX_TYPE = (XGL_INDEX_TYPE_END_RANGE - XGL_INDEX_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_INDEX_TYPE) -} XGL_INDEX_TYPE; - -typedef enum _XGL_TEX_FILTER -{ - XGL_TEX_FILTER_NEAREST = 0, - XGL_TEX_FILTER_LINEAR = 1, - - XGL_TEX_FILTER_BEGIN_RANGE = XGL_TEX_FILTER_NEAREST, - XGL_TEX_FILTER_END_RANGE = XGL_TEX_FILTER_LINEAR, - XGL_NUM_TEX_FILTER = (XGL_TEX_FILTER_END_RANGE - XGL_TEX_FILTER_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_TEX_FILTER) -} XGL_TEX_FILTER; - -typedef enum _XGL_TEX_MIPMAP_MODE -{ - XGL_TEX_MIPMAP_BASE = 0, // Always choose base level - XGL_TEX_MIPMAP_NEAREST = 1, // Choose nearest mip level - XGL_TEX_MIPMAP_LINEAR = 2, // Linear filter between mip levels - - XGL_TEX_MIPMAP_BEGIN_RANGE = XGL_TEX_MIPMAP_BASE, - XGL_TEX_MIPMAP_END_RANGE = XGL_TEX_MIPMAP_LINEAR, - XGL_NUM_TEX_MIPMAP = (XGL_TEX_MIPMAP_END_RANGE - XGL_TEX_MIPMAP_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_TEX_MIPMAP_MODE) -} XGL_TEX_MIPMAP_MODE; - -typedef enum _XGL_TEX_ADDRESS -{ - XGL_TEX_ADDRESS_WRAP = 0x00000000, - XGL_TEX_ADDRESS_MIRROR = 0x00000001, - XGL_TEX_ADDRESS_CLAMP = 0x00000002, - XGL_TEX_ADDRESS_MIRROR_ONCE = 0x00000003, - XGL_TEX_ADDRESS_CLAMP_BORDER = 0x00000004, - - XGL_TEX_ADDRESS_BEGIN_RANGE = XGL_TEX_ADDRESS_WRAP, - XGL_TEX_ADDRESS_END_RANGE = XGL_TEX_ADDRESS_CLAMP_BORDER, - XGL_NUM_TEX_ADDRESS = (XGL_TEX_ADDRESS_END_RANGE - XGL_TEX_ADDRESS_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_TEX_ADDRESS) -} XGL_TEX_ADDRESS; - -typedef enum _XGL_COMPARE_FUNC -{ - XGL_COMPARE_NEVER = 0x00000000, - XGL_COMPARE_LESS = 0x00000001, - XGL_COMPARE_EQUAL = 0x00000002, - XGL_COMPARE_LESS_EQUAL = 0x00000003, - XGL_COMPARE_GREATER = 0x00000004, - XGL_COMPARE_NOT_EQUAL = 0x00000005, - XGL_COMPARE_GREATER_EQUAL = 0x00000006, - XGL_COMPARE_ALWAYS = 0x00000007, - - XGL_COMPARE_FUNC_BEGIN_RANGE = XGL_COMPARE_NEVER, - XGL_COMPARE_FUNC_END_RANGE = XGL_COMPARE_ALWAYS, - XGL_NUM_COMPARE_FUNC = (XGL_COMPARE_FUNC_END_RANGE - XGL_COMPARE_FUNC_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_COMPARE_FUNC) -} XGL_COMPARE_FUNC; - -typedef enum _XGL_FILL_MODE -{ - XGL_FILL_POINTS = 0x00000000, - XGL_FILL_WIREFRAME = 0x00000001, - XGL_FILL_SOLID = 0x00000002, - - XGL_FILL_MODE_BEGIN_RANGE = XGL_FILL_POINTS, - XGL_FILL_MODE_END_RANGE = XGL_FILL_SOLID, - XGL_NUM_FILL_MODE = (XGL_FILL_MODE_END_RANGE - XGL_FILL_MODE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_FILL_MODE) -} XGL_FILL_MODE; - -typedef enum _XGL_CULL_MODE -{ - XGL_CULL_NONE = 0x00000000, - XGL_CULL_FRONT = 0x00000001, - XGL_CULL_BACK = 0x00000002, - XGL_CULL_FRONT_AND_BACK = 0x00000003, - - XGL_CULL_MODE_BEGIN_RANGE = XGL_CULL_NONE, - XGL_CULL_MODE_END_RANGE = XGL_CULL_FRONT_AND_BACK, - XGL_NUM_CULL_MODE = (XGL_CULL_MODE_END_RANGE - XGL_CULL_MODE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_CULL_MODE) -} XGL_CULL_MODE; - -typedef enum _XGL_FACE_ORIENTATION -{ - XGL_FRONT_FACE_CCW = 0x00000000, - XGL_FRONT_FACE_CW = 0x00000001, - - XGL_FACE_ORIENTATION_BEGIN_RANGE = XGL_FRONT_FACE_CCW, - XGL_FACE_ORIENTATION_END_RANGE = XGL_FRONT_FACE_CW, - XGL_NUM_FACE_ORIENTATION = (XGL_FACE_ORIENTATION_END_RANGE - XGL_FACE_ORIENTATION_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_FACE_ORIENTATION) -} XGL_FACE_ORIENTATION; - -typedef enum _XGL_PROVOKING_VERTEX_CONVENTION -{ - XGL_PROVOKING_VERTEX_FIRST = 0x00000000, - XGL_PROVOKING_VERTEX_LAST = 0x00000001, - - XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST, - XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST, - XGL_NUM_PROVOKING_VERTEX_CONVENTION = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION) -} XGL_PROVOKING_VERTEX_CONVENTION; - -typedef enum _XGL_COORDINATE_ORIGIN -{ - XGL_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000, - XGL_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001, - - XGL_COORDINATE_ORIGIN_BEGIN_RANGE = XGL_COORDINATE_ORIGIN_UPPER_LEFT, - XGL_COORDINATE_ORIGIN_END_RANGE = XGL_COORDINATE_ORIGIN_LOWER_LEFT, - XGL_NUM_COORDINATE_ORIGIN = (XGL_COORDINATE_ORIGIN_END_RANGE - XGL_COORDINATE_ORIGIN_END_RANGE + 1), - XGL_MAX_ENUM(_XGL_COORDINATE_ORIGIN) -} XGL_COORDINATE_ORIGIN; - -typedef enum _XGL_DEPTH_MODE -{ - XGL_DEPTH_MODE_ZERO_TO_ONE = 0x00000000, - XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001, - - XGL_DEPTH_MODE_BEGIN_RANGE = XGL_DEPTH_MODE_ZERO_TO_ONE, - XGL_DEPTH_MODE_END_RANGE = XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE, - XGL_NUM_DEPTH_MODE = (XGL_DEPTH_MODE_END_RANGE - XGL_DEPTH_MODE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_DEPTH_MODE) -} XGL_DEPTH_MODE; - -typedef enum _XGL_BLEND -{ - XGL_BLEND_ZERO = 0x00000000, - XGL_BLEND_ONE = 0x00000001, - XGL_BLEND_SRC_COLOR = 0x00000002, - XGL_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003, - XGL_BLEND_DEST_COLOR = 0x00000004, - XGL_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005, - XGL_BLEND_SRC_ALPHA = 0x00000006, - XGL_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007, - XGL_BLEND_DEST_ALPHA = 0x00000008, - XGL_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009, - XGL_BLEND_CONSTANT_COLOR = 0x0000000a, - XGL_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b, - XGL_BLEND_CONSTANT_ALPHA = 0x0000000c, - XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d, - XGL_BLEND_SRC_ALPHA_SATURATE = 0x0000000e, - XGL_BLEND_SRC1_COLOR = 0x0000000f, - XGL_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010, - XGL_BLEND_SRC1_ALPHA = 0x00000011, - XGL_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012, - - XGL_BLEND_BEGIN_RANGE = XGL_BLEND_ZERO, - XGL_BLEND_END_RANGE = XGL_BLEND_ONE_MINUS_SRC1_ALPHA, - XGL_NUM_BLEND = (XGL_BLEND_END_RANGE - XGL_BLEND_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_BLEND) -} XGL_BLEND; - -typedef enum _XGL_BLEND_FUNC -{ - XGL_BLEND_FUNC_ADD = 0x00000000, - XGL_BLEND_FUNC_SUBTRACT = 0x00000001, - XGL_BLEND_FUNC_REVERSE_SUBTRACT = 0x00000002, - XGL_BLEND_FUNC_MIN = 0x00000003, - XGL_BLEND_FUNC_MAX = 0x00000004, - - XGL_BLEND_FUNC_BEGIN_RANGE = XGL_BLEND_FUNC_ADD, - XGL_BLEND_FUNC_END_RANGE = XGL_BLEND_FUNC_MAX, - XGL_NUM_BLEND_FUNC = (XGL_BLEND_FUNC_END_RANGE - XGL_BLEND_FUNC_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_BLEND_FUNC) -} XGL_BLEND_FUNC; - -typedef enum _XGL_STENCIL_OP -{ - XGL_STENCIL_OP_KEEP = 0x00000000, - XGL_STENCIL_OP_ZERO = 0x00000001, - XGL_STENCIL_OP_REPLACE = 0x00000002, - XGL_STENCIL_OP_INC_CLAMP = 0x00000003, - XGL_STENCIL_OP_DEC_CLAMP = 0x00000004, - XGL_STENCIL_OP_INVERT = 0x00000005, - XGL_STENCIL_OP_INC_WRAP = 0x00000006, - XGL_STENCIL_OP_DEC_WRAP = 0x00000007, - - XGL_STENCIL_OP_BEGIN_RANGE = XGL_STENCIL_OP_KEEP, - XGL_STENCIL_OP_END_RANGE = XGL_STENCIL_OP_DEC_WRAP, - XGL_NUM_STENCIL_OP = (XGL_STENCIL_OP_END_RANGE - XGL_STENCIL_OP_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_STENCIL_OP) -} XGL_STENCIL_OP; - -typedef enum _XGL_LOGIC_OP -{ - XGL_LOGIC_OP_COPY = 0x00000000, - XGL_LOGIC_OP_CLEAR = 0x00000001, - XGL_LOGIC_OP_AND = 0x00000002, - XGL_LOGIC_OP_AND_REVERSE = 0x00000003, - XGL_LOGIC_OP_AND_INVERTED = 0x00000004, - XGL_LOGIC_OP_NOOP = 0x00000005, - XGL_LOGIC_OP_XOR = 0x00000006, - XGL_LOGIC_OP_OR = 0x00000007, - XGL_LOGIC_OP_NOR = 0x00000008, - XGL_LOGIC_OP_EQUIV = 0x00000009, - XGL_LOGIC_OP_INVERT = 0x0000000a, - XGL_LOGIC_OP_OR_REVERSE = 0x0000000b, - XGL_LOGIC_OP_COPY_INVERTED = 0x0000000c, - XGL_LOGIC_OP_OR_INVERTED = 0x0000000d, - XGL_LOGIC_OP_NAND = 0x0000000e, - XGL_LOGIC_OP_SET = 0x0000000f, - - XGL_LOGIC_OP_BEGIN_RANGE = XGL_LOGIC_OP_COPY, - XGL_LOGIC_OP_END_RANGE = XGL_LOGIC_OP_SET, - XGL_NUM_LOGIC_OP = (XGL_LOGIC_OP_END_RANGE - XGL_LOGIC_OP_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_LOGIC_OP) -} XGL_LOGIC_OP; - -typedef enum _XGL_SYSTEM_ALLOC_TYPE -{ - XGL_SYSTEM_ALLOC_API_OBJECT = 0x00000000, - XGL_SYSTEM_ALLOC_INTERNAL = 0x00000001, - XGL_SYSTEM_ALLOC_INTERNAL_TEMP = 0x00000002, - XGL_SYSTEM_ALLOC_INTERNAL_SHADER = 0x00000003, - XGL_SYSTEM_ALLOC_DEBUG = 0x00000004, - - XGL_SYSTEM_ALLOC_BEGIN_RANGE = XGL_SYSTEM_ALLOC_API_OBJECT, - XGL_SYSTEM_ALLOC_END_RANGE = XGL_SYSTEM_ALLOC_DEBUG, - XGL_NUM_SYSTEM_ALLOC_TYPE = (XGL_SYSTEM_ALLOC_END_RANGE - XGL_SYSTEM_ALLOC_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_SYSTEM_ALLOC_TYPE) -} XGL_SYSTEM_ALLOC_TYPE; - -typedef enum _XGL_PHYSICAL_GPU_TYPE -{ - XGL_GPU_TYPE_OTHER = 0x00000000, - XGL_GPU_TYPE_INTEGRATED = 0x00000001, - XGL_GPU_TYPE_DISCRETE = 0x00000002, - XGL_GPU_TYPE_VIRTUAL = 0x00000003, - - XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE = XGL_GPU_TYPE_OTHER, - XGL_PHYSICAL_GPU_TYPE_END_RANGE = XGL_GPU_TYPE_VIRTUAL, - XGL_NUM_PHYSICAL_GPU_TYPE = (XGL_PHYSICAL_GPU_TYPE_END_RANGE - XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_TYPE) -} XGL_PHYSICAL_GPU_TYPE; - -typedef enum _XGL_PHYSICAL_GPU_INFO_TYPE -{ - // Info type for xglGetGpuInfo() - XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES = 0x00000000, - XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE = 0x00000001, - XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES = 0x00000002, - XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES = 0x00000003, - - XGL_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE = XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, - XGL_INFO_TYPE_PHYSICAL_GPU_END_RANGE = XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, - XGL_NUM_INFO_TYPE_PHYSICAL_GPU = (XGL_INFO_TYPE_PHYSICAL_GPU_END_RANGE - XGL_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_INFO_TYPE) -} XGL_PHYSICAL_GPU_INFO_TYPE; - -typedef enum _XGL_FORMAT_INFO_TYPE -{ - // Info type for xglGetFormatInfo() - XGL_INFO_TYPE_FORMAT_PROPERTIES = 0x00000000, - - XGL_INFO_TYPE_FORMAT_BEGIN_RANGE = XGL_INFO_TYPE_FORMAT_PROPERTIES, - XGL_INFO_TYPE_FORMAT_END_RANGE = XGL_INFO_TYPE_FORMAT_PROPERTIES, - XGL_NUM_INFO_TYPE_FORMAT = (XGL_INFO_TYPE_FORMAT_END_RANGE - XGL_INFO_TYPE_FORMAT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_FORMAT_INFO_TYPE) -} XGL_FORMAT_INFO_TYPE; - -typedef enum _XGL_SUBRESOURCE_INFO_TYPE -{ - // Info type for xglGetImageSubresourceInfo() - XGL_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000, - - XGL_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE = XGL_INFO_TYPE_SUBRESOURCE_LAYOUT, - XGL_INFO_TYPE_SUBRESOURCE_END_RANGE = XGL_INFO_TYPE_SUBRESOURCE_LAYOUT, - XGL_NUM_INFO_TYPE_SUBRESOURCE = (XGL_INFO_TYPE_SUBRESOURCE_END_RANGE - XGL_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_SUBRESOURCE_INFO_TYPE) -} XGL_SUBRESOURCE_INFO_TYPE; - -typedef enum _XGL_OBJECT_INFO_TYPE -{ - // Info type for xglGetObjectInfo() - XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000, - XGL_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001, - XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS = 0x00000002, - XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS = 0x00000003, - - XGL_INFO_TYPE_BEGIN_RANGE = XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT, - XGL_INFO_TYPE_END_RANGE = XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, - XGL_NUM_INFO_TYPE = (XGL_INFO_TYPE_END_RANGE - XGL_INFO_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_OBJECT_INFO_TYPE) -} XGL_OBJECT_INFO_TYPE; - -typedef enum _XGL_VALIDATION_LEVEL -{ - XGL_VALIDATION_LEVEL_0 = 0x00000000, - XGL_VALIDATION_LEVEL_1 = 0x00000001, - XGL_VALIDATION_LEVEL_2 = 0x00000002, - XGL_VALIDATION_LEVEL_3 = 0x00000003, - XGL_VALIDATION_LEVEL_4 = 0x00000004, - - XGL_VALIDATION_LEVEL_BEGIN_RANGE = XGL_VALIDATION_LEVEL_0, - XGL_VALIDATION_LEVEL_END_RANGE = XGL_VALIDATION_LEVEL_4, - XGL_NUM_VALIDATION_LEVEL = (XGL_VALIDATION_LEVEL_END_RANGE - XGL_VALIDATION_LEVEL_BEGIN_RANGE + 1), - - XGL_MAX_ENUM(_XGL_VALIDATION_LEVEL) -} XGL_VALIDATION_LEVEL; + VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC, + VK_NUM_DESCRIPTOR_TYPE = (VK_DESCRIPTOR_TYPE_END_RANGE - VK_DESCRIPTOR_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_DESCRIPTOR_TYPE) +} VK_DESCRIPTOR_TYPE; + +typedef enum _VK_DESCRIPTOR_POOL_USAGE +{ + VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000, + VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001, + + VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, + VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, + VK_NUM_DESCRIPTOR_POOL_USAGE = (VK_DESCRIPTOR_POOL_USAGE_END_RANGE - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_DESCRIPTOR_POOL_USAGE) +} VK_DESCRIPTOR_POOL_USAGE; + +typedef enum _VK_DESCRIPTOR_UPDATE_MODE +{ + VK_DESCRIPTOR_UDPATE_MODE_COPY = 0x00000000, + VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001, + + VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE = VK_DESCRIPTOR_UDPATE_MODE_COPY, + VK_DESCRIPTOR_UPDATE_MODE_END_RANGE = VK_DESCRIPTOR_UPDATE_MODE_FASTEST, + VK_NUM_DESCRIPTOR_UPDATE_MODE = (VK_DESCRIPTOR_UPDATE_MODE_END_RANGE - VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_DESCRIPTOR_UPDATE_MODE) +} VK_DESCRIPTOR_UPDATE_MODE; + +typedef enum _VK_DESCRIPTOR_SET_USAGE +{ + VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000, + VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001, + + VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, + VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, + VK_NUM_DESCRIPTOR_SET_USAGE = (VK_DESCRIPTOR_SET_USAGE_END_RANGE - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_DESCRIPTOR_SET_USAGE) +} VK_DESCRIPTOR_SET_USAGE; + +typedef enum _VK_QUERY_TYPE +{ + VK_QUERY_OCCLUSION = 0x00000000, + VK_QUERY_PIPELINE_STATISTICS = 0x00000001, + + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_PIPELINE_STATISTICS, + VK_NUM_QUERY_TYPE = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_QUERY_TYPE) +} VK_QUERY_TYPE; + +typedef enum _VK_TIMESTAMP_TYPE +{ + VK_TIMESTAMP_TOP = 0x00000000, + VK_TIMESTAMP_BOTTOM = 0x00000001, + + VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TOP, + VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_BOTTOM, + VK_NUM_TIMESTAMP_TYPE = (VK_TIMESTAMP_TYPE_END_RANGE - VK_TIMESTAMP_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_TIMESTEAMP_TYPE) +} VK_TIMESTAMP_TYPE; + +typedef enum _VK_BORDER_COLOR_TYPE +{ + VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000, + VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001, + VK_BORDER_COLOR_OPAQUE_BLACK = 0x00000002, + + VK_BORDER_COLOR_TYPE_BEGIN_RANGE = VK_BORDER_COLOR_OPAQUE_WHITE, + VK_BORDER_COLOR_TYPE_END_RANGE = VK_BORDER_COLOR_OPAQUE_BLACK, + VK_NUM_BORDER_COLOR_TYPE = (VK_BORDER_COLOR_TYPE_END_RANGE - VK_BORDER_COLOR_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_BORDER_COLOR_TYPE) +} VK_BORDER_COLOR_TYPE; + +typedef enum _VK_PIPELINE_BIND_POINT +{ + VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000, + VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001, + + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_NUM_PIPELINE_BIND_POINT = (VK_PIPELINE_BIND_POINT_END_RANGE - VK_PIPELINE_BIND_POINT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_PIPELINE_BIND_POINT) +} VK_PIPELINE_BIND_POINT; + +typedef enum _VK_STATE_BIND_POINT +{ + VK_STATE_BIND_VIEWPORT = 0x00000000, + VK_STATE_BIND_RASTER = 0x00000001, + VK_STATE_BIND_COLOR_BLEND = 0x00000002, + VK_STATE_BIND_DEPTH_STENCIL = 0x00000003, + + VK_STATE_BIND_POINT_BEGIN_RANGE = VK_STATE_BIND_VIEWPORT, + VK_STATE_BIND_POINT_END_RANGE = VK_STATE_BIND_DEPTH_STENCIL, + VK_NUM_STATE_BIND_POINT = (VK_STATE_BIND_POINT_END_RANGE - VK_STATE_BIND_POINT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_STATE_BIND_POINT) +} VK_STATE_BIND_POINT; + +typedef enum _VK_PRIMITIVE_TOPOLOGY +{ + VK_TOPOLOGY_POINT_LIST = 0x00000000, + VK_TOPOLOGY_LINE_LIST = 0x00000001, + VK_TOPOLOGY_LINE_STRIP = 0x00000002, + VK_TOPOLOGY_TRIANGLE_LIST = 0x00000003, + VK_TOPOLOGY_TRIANGLE_STRIP = 0x00000004, + VK_TOPOLOGY_TRIANGLE_FAN = 0x00000005, + VK_TOPOLOGY_LINE_LIST_ADJ = 0x00000006, + VK_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007, + VK_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008, + VK_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009, + VK_TOPOLOGY_PATCH = 0x0000000a, + + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_TOPOLOGY_PATCH, + VK_NUM_PRIMITIVE_TOPOLOGY = (VK_PRIMITIVE_TOPOLOGY_END_RANGE - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_PRIMITIVE_TOPOLOGY) +} VK_PRIMITIVE_TOPOLOGY; + +typedef enum _VK_INDEX_TYPE +{ + VK_INDEX_8 = 0x00000000, + VK_INDEX_16 = 0x00000001, + VK_INDEX_32 = 0x00000002, + + VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_8, + VK_INDEX_TYPE_END_RANGE = VK_INDEX_32, + VK_NUM_INDEX_TYPE = (VK_INDEX_TYPE_END_RANGE - VK_INDEX_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_INDEX_TYPE) +} VK_INDEX_TYPE; + +typedef enum _VK_TEX_FILTER +{ + VK_TEX_FILTER_NEAREST = 0, + VK_TEX_FILTER_LINEAR = 1, + + VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, + VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, + VK_NUM_TEX_FILTER = (VK_TEX_FILTER_END_RANGE - VK_TEX_FILTER_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_TEX_FILTER) +} VK_TEX_FILTER; + +typedef enum _VK_TEX_MIPMAP_MODE +{ + VK_TEX_MIPMAP_BASE = 0, // Always choose base level + VK_TEX_MIPMAP_NEAREST = 1, // Choose nearest mip level + VK_TEX_MIPMAP_LINEAR = 2, // Linear filter between mip levels + + VK_TEX_MIPMAP_BEGIN_RANGE = VK_TEX_MIPMAP_BASE, + VK_TEX_MIPMAP_END_RANGE = VK_TEX_MIPMAP_LINEAR, + VK_NUM_TEX_MIPMAP = (VK_TEX_MIPMAP_END_RANGE - VK_TEX_MIPMAP_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_TEX_MIPMAP_MODE) +} VK_TEX_MIPMAP_MODE; + +typedef enum _VK_TEX_ADDRESS +{ + VK_TEX_ADDRESS_WRAP = 0x00000000, + VK_TEX_ADDRESS_MIRROR = 0x00000001, + VK_TEX_ADDRESS_CLAMP = 0x00000002, + VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003, + VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004, + + VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, + VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, + VK_NUM_TEX_ADDRESS = (VK_TEX_ADDRESS_END_RANGE - VK_TEX_ADDRESS_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_TEX_ADDRESS) +} VK_TEX_ADDRESS; + +typedef enum _VK_COMPARE_FUNC +{ + VK_COMPARE_NEVER = 0x00000000, + VK_COMPARE_LESS = 0x00000001, + VK_COMPARE_EQUAL = 0x00000002, + VK_COMPARE_LESS_EQUAL = 0x00000003, + VK_COMPARE_GREATER = 0x00000004, + VK_COMPARE_NOT_EQUAL = 0x00000005, + VK_COMPARE_GREATER_EQUAL = 0x00000006, + VK_COMPARE_ALWAYS = 0x00000007, + + VK_COMPARE_FUNC_BEGIN_RANGE = VK_COMPARE_NEVER, + VK_COMPARE_FUNC_END_RANGE = VK_COMPARE_ALWAYS, + VK_NUM_COMPARE_FUNC = (VK_COMPARE_FUNC_END_RANGE - VK_COMPARE_FUNC_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_COMPARE_FUNC) +} VK_COMPARE_FUNC; + +typedef enum _VK_FILL_MODE +{ + VK_FILL_POINTS = 0x00000000, + VK_FILL_WIREFRAME = 0x00000001, + VK_FILL_SOLID = 0x00000002, + + VK_FILL_MODE_BEGIN_RANGE = VK_FILL_POINTS, + VK_FILL_MODE_END_RANGE = VK_FILL_SOLID, + VK_NUM_FILL_MODE = (VK_FILL_MODE_END_RANGE - VK_FILL_MODE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_FILL_MODE) +} VK_FILL_MODE; + +typedef enum _VK_CULL_MODE +{ + VK_CULL_NONE = 0x00000000, + VK_CULL_FRONT = 0x00000001, + VK_CULL_BACK = 0x00000002, + VK_CULL_FRONT_AND_BACK = 0x00000003, + + VK_CULL_MODE_BEGIN_RANGE = VK_CULL_NONE, + VK_CULL_MODE_END_RANGE = VK_CULL_FRONT_AND_BACK, + VK_NUM_CULL_MODE = (VK_CULL_MODE_END_RANGE - VK_CULL_MODE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_CULL_MODE) +} VK_CULL_MODE; + +typedef enum _VK_FACE_ORIENTATION +{ + VK_FRONT_FACE_CCW = 0x00000000, + VK_FRONT_FACE_CW = 0x00000001, + + VK_FACE_ORIENTATION_BEGIN_RANGE = VK_FRONT_FACE_CCW, + VK_FACE_ORIENTATION_END_RANGE = VK_FRONT_FACE_CW, + VK_NUM_FACE_ORIENTATION = (VK_FACE_ORIENTATION_END_RANGE - VK_FACE_ORIENTATION_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_FACE_ORIENTATION) +} VK_FACE_ORIENTATION; + +typedef enum _VK_PROVOKING_VERTEX_CONVENTION +{ + VK_PROVOKING_VERTEX_FIRST = 0x00000000, + VK_PROVOKING_VERTEX_LAST = 0x00000001, + + VK_PROVOKING_VERTEX_BEGIN_RANGE = VK_PROVOKING_VERTEX_FIRST, + VK_PROVOKING_VERTEX_END_RANGE = VK_PROVOKING_VERTEX_LAST, + VK_NUM_PROVOKING_VERTEX_CONVENTION = (VK_PROVOKING_VERTEX_END_RANGE - VK_PROVOKING_VERTEX_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_PROVOKING_VERTEX_CONVENTION) +} VK_PROVOKING_VERTEX_CONVENTION; + +typedef enum _VK_COORDINATE_ORIGIN +{ + VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000, + VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001, + + VK_COORDINATE_ORIGIN_BEGIN_RANGE = VK_COORDINATE_ORIGIN_UPPER_LEFT, + VK_COORDINATE_ORIGIN_END_RANGE = VK_COORDINATE_ORIGIN_LOWER_LEFT, + VK_NUM_COORDINATE_ORIGIN = (VK_COORDINATE_ORIGIN_END_RANGE - VK_COORDINATE_ORIGIN_END_RANGE + 1), + VK_MAX_ENUM(_VK_COORDINATE_ORIGIN) +} VK_COORDINATE_ORIGIN; + +typedef enum _VK_DEPTH_MODE +{ + VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000, + VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001, + + VK_DEPTH_MODE_BEGIN_RANGE = VK_DEPTH_MODE_ZERO_TO_ONE, + VK_DEPTH_MODE_END_RANGE = VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE, + VK_NUM_DEPTH_MODE = (VK_DEPTH_MODE_END_RANGE - VK_DEPTH_MODE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_DEPTH_MODE) +} VK_DEPTH_MODE; + +typedef enum _VK_BLEND +{ + VK_BLEND_ZERO = 0x00000000, + VK_BLEND_ONE = 0x00000001, + VK_BLEND_SRC_COLOR = 0x00000002, + VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003, + VK_BLEND_DEST_COLOR = 0x00000004, + VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005, + VK_BLEND_SRC_ALPHA = 0x00000006, + VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007, + VK_BLEND_DEST_ALPHA = 0x00000008, + VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009, + VK_BLEND_CONSTANT_COLOR = 0x0000000a, + VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b, + VK_BLEND_CONSTANT_ALPHA = 0x0000000c, + VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d, + VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e, + VK_BLEND_SRC1_COLOR = 0x0000000f, + VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010, + VK_BLEND_SRC1_ALPHA = 0x00000011, + VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012, + + VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, + VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, + VK_NUM_BLEND = (VK_BLEND_END_RANGE - VK_BLEND_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_BLEND) +} VK_BLEND; + +typedef enum _VK_BLEND_FUNC +{ + VK_BLEND_FUNC_ADD = 0x00000000, + VK_BLEND_FUNC_SUBTRACT = 0x00000001, + VK_BLEND_FUNC_REVERSE_SUBTRACT = 0x00000002, + VK_BLEND_FUNC_MIN = 0x00000003, + VK_BLEND_FUNC_MAX = 0x00000004, + + VK_BLEND_FUNC_BEGIN_RANGE = VK_BLEND_FUNC_ADD, + VK_BLEND_FUNC_END_RANGE = VK_BLEND_FUNC_MAX, + VK_NUM_BLEND_FUNC = (VK_BLEND_FUNC_END_RANGE - VK_BLEND_FUNC_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_BLEND_FUNC) +} VK_BLEND_FUNC; + +typedef enum _VK_STENCIL_OP +{ + VK_STENCIL_OP_KEEP = 0x00000000, + VK_STENCIL_OP_ZERO = 0x00000001, + VK_STENCIL_OP_REPLACE = 0x00000002, + VK_STENCIL_OP_INC_CLAMP = 0x00000003, + VK_STENCIL_OP_DEC_CLAMP = 0x00000004, + VK_STENCIL_OP_INVERT = 0x00000005, + VK_STENCIL_OP_INC_WRAP = 0x00000006, + VK_STENCIL_OP_DEC_WRAP = 0x00000007, + + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, + VK_NUM_STENCIL_OP = (VK_STENCIL_OP_END_RANGE - VK_STENCIL_OP_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_STENCIL_OP) +} VK_STENCIL_OP; + +typedef enum _VK_LOGIC_OP +{ + VK_LOGIC_OP_COPY = 0x00000000, + VK_LOGIC_OP_CLEAR = 0x00000001, + VK_LOGIC_OP_AND = 0x00000002, + VK_LOGIC_OP_AND_REVERSE = 0x00000003, + VK_LOGIC_OP_AND_INVERTED = 0x00000004, + VK_LOGIC_OP_NOOP = 0x00000005, + VK_LOGIC_OP_XOR = 0x00000006, + VK_LOGIC_OP_OR = 0x00000007, + VK_LOGIC_OP_NOR = 0x00000008, + VK_LOGIC_OP_EQUIV = 0x00000009, + VK_LOGIC_OP_INVERT = 0x0000000a, + VK_LOGIC_OP_OR_REVERSE = 0x0000000b, + VK_LOGIC_OP_COPY_INVERTED = 0x0000000c, + VK_LOGIC_OP_OR_INVERTED = 0x0000000d, + VK_LOGIC_OP_NAND = 0x0000000e, + VK_LOGIC_OP_SET = 0x0000000f, + + VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_COPY, + VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, + VK_NUM_LOGIC_OP = (VK_LOGIC_OP_END_RANGE - VK_LOGIC_OP_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_LOGIC_OP) +} VK_LOGIC_OP; + +typedef enum _VK_SYSTEM_ALLOC_TYPE +{ + VK_SYSTEM_ALLOC_API_OBJECT = 0x00000000, + VK_SYSTEM_ALLOC_INTERNAL = 0x00000001, + VK_SYSTEM_ALLOC_INTERNAL_TEMP = 0x00000002, + VK_SYSTEM_ALLOC_INTERNAL_SHADER = 0x00000003, + VK_SYSTEM_ALLOC_DEBUG = 0x00000004, + + VK_SYSTEM_ALLOC_BEGIN_RANGE = VK_SYSTEM_ALLOC_API_OBJECT, + VK_SYSTEM_ALLOC_END_RANGE = VK_SYSTEM_ALLOC_DEBUG, + VK_NUM_SYSTEM_ALLOC_TYPE = (VK_SYSTEM_ALLOC_END_RANGE - VK_SYSTEM_ALLOC_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_SYSTEM_ALLOC_TYPE) +} VK_SYSTEM_ALLOC_TYPE; + +typedef enum _VK_PHYSICAL_GPU_TYPE +{ + VK_GPU_TYPE_OTHER = 0x00000000, + VK_GPU_TYPE_INTEGRATED = 0x00000001, + VK_GPU_TYPE_DISCRETE = 0x00000002, + VK_GPU_TYPE_VIRTUAL = 0x00000003, + + VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE = VK_GPU_TYPE_OTHER, + VK_PHYSICAL_GPU_TYPE_END_RANGE = VK_GPU_TYPE_VIRTUAL, + VK_NUM_PHYSICAL_GPU_TYPE = (VK_PHYSICAL_GPU_TYPE_END_RANGE - VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_PHYSICAL_GPU_TYPE) +} VK_PHYSICAL_GPU_TYPE; + +typedef enum _VK_PHYSICAL_GPU_INFO_TYPE +{ + // Info type for vkGetGpuInfo() + VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES = 0x00000000, + VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE = 0x00000001, + VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES = 0x00000002, + VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES = 0x00000003, + + VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, + VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, + VK_NUM_INFO_TYPE_PHYSICAL_GPU = (VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE - VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_PHYSICAL_GPU_INFO_TYPE) +} VK_PHYSICAL_GPU_INFO_TYPE; + +typedef enum _VK_FORMAT_INFO_TYPE +{ + // Info type for vkGetFormatInfo() + VK_INFO_TYPE_FORMAT_PROPERTIES = 0x00000000, + + VK_INFO_TYPE_FORMAT_BEGIN_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES, + VK_INFO_TYPE_FORMAT_END_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES, + VK_NUM_INFO_TYPE_FORMAT = (VK_INFO_TYPE_FORMAT_END_RANGE - VK_INFO_TYPE_FORMAT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_FORMAT_INFO_TYPE) +} VK_FORMAT_INFO_TYPE; + +typedef enum _VK_SUBRESOURCE_INFO_TYPE +{ + // Info type for vkGetImageSubresourceInfo() + VK_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000, + + VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT, + VK_INFO_TYPE_SUBRESOURCE_END_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT, + VK_NUM_INFO_TYPE_SUBRESOURCE = (VK_INFO_TYPE_SUBRESOURCE_END_RANGE - VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_SUBRESOURCE_INFO_TYPE) +} VK_SUBRESOURCE_INFO_TYPE; + +typedef enum _VK_OBJECT_INFO_TYPE +{ + // Info type for vkGetObjectInfo() + VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000, + VK_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001, + VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS = 0x00000002, + VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS = 0x00000003, + + VK_INFO_TYPE_BEGIN_RANGE = VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, + VK_INFO_TYPE_END_RANGE = VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, + VK_NUM_INFO_TYPE = (VK_INFO_TYPE_END_RANGE - VK_INFO_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_OBJECT_INFO_TYPE) +} VK_OBJECT_INFO_TYPE; + +typedef enum _VK_VALIDATION_LEVEL +{ + VK_VALIDATION_LEVEL_0 = 0x00000000, + VK_VALIDATION_LEVEL_1 = 0x00000001, + VK_VALIDATION_LEVEL_2 = 0x00000002, + VK_VALIDATION_LEVEL_3 = 0x00000003, + VK_VALIDATION_LEVEL_4 = 0x00000004, + + VK_VALIDATION_LEVEL_BEGIN_RANGE = VK_VALIDATION_LEVEL_0, + VK_VALIDATION_LEVEL_END_RANGE = VK_VALIDATION_LEVEL_4, + VK_NUM_VALIDATION_LEVEL = (VK_VALIDATION_LEVEL_END_RANGE - VK_VALIDATION_LEVEL_BEGIN_RANGE + 1), + + VK_MAX_ENUM(_VK_VALIDATION_LEVEL) +} VK_VALIDATION_LEVEL; // ------------------------------------------------------------------------------------------------ // Error and return codes -typedef enum _XGL_RESULT +typedef enum _VK_RESULT { // Return codes for successful operation execution (>= 0) - XGL_SUCCESS = 0x0000000, - XGL_UNSUPPORTED = 0x0000001, - XGL_NOT_READY = 0x0000002, - XGL_TIMEOUT = 0x0000003, - XGL_EVENT_SET = 0x0000004, - XGL_EVENT_RESET = 0x0000005, + VK_SUCCESS = 0x0000000, + VK_UNSUPPORTED = 0x0000001, + VK_NOT_READY = 0x0000002, + VK_TIMEOUT = 0x0000003, + VK_EVENT_SET = 0x0000004, + VK_EVENT_RESET = 0x0000005, // Error codes (negative values) - XGL_ERROR_UNKNOWN = -(0x00000001), - XGL_ERROR_UNAVAILABLE = -(0x00000002), - XGL_ERROR_INITIALIZATION_FAILED = -(0x00000003), - XGL_ERROR_OUT_OF_MEMORY = -(0x00000004), - XGL_ERROR_OUT_OF_GPU_MEMORY = -(0x00000005), - XGL_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006), - XGL_ERROR_DEVICE_LOST = -(0x00000007), - XGL_ERROR_INVALID_POINTER = -(0x00000008), - XGL_ERROR_INVALID_VALUE = -(0x00000009), - XGL_ERROR_INVALID_HANDLE = -(0x0000000A), - XGL_ERROR_INVALID_ORDINAL = -(0x0000000B), - XGL_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C), - XGL_ERROR_INVALID_EXTENSION = -(0x0000000D), - XGL_ERROR_INVALID_FLAGS = -(0x0000000E), - XGL_ERROR_INVALID_ALIGNMENT = -(0x0000000F), - XGL_ERROR_INVALID_FORMAT = -(0x00000010), - XGL_ERROR_INVALID_IMAGE = -(0x00000011), - XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012), - XGL_ERROR_INVALID_QUEUE_TYPE = -(0x00000013), - XGL_ERROR_INVALID_OBJECT_TYPE = -(0x00000014), - XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015), - XGL_ERROR_BAD_SHADER_CODE = -(0x00000016), - XGL_ERROR_BAD_PIPELINE_DATA = -(0x00000017), - XGL_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018), - XGL_ERROR_NOT_MAPPABLE = -(0x00000019), - XGL_ERROR_MEMORY_MAP_FAILED = -(0x0000001A), - XGL_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B), - XGL_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C), - XGL_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D), - XGL_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E), - XGL_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F), - XGL_ERROR_MEMORY_NOT_BOUND = -(0x00000020), - XGL_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021), - XGL_ERROR_NOT_SHAREABLE = -(0x00000022), - XGL_MAX_ENUM(_XGL_RESULT_CODE) -} XGL_RESULT; + VK_ERROR_UNKNOWN = -(0x00000001), + VK_ERROR_UNAVAILABLE = -(0x00000002), + VK_ERROR_INITIALIZATION_FAILED = -(0x00000003), + VK_ERROR_OUT_OF_MEMORY = -(0x00000004), + VK_ERROR_OUT_OF_GPU_MEMORY = -(0x00000005), + VK_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006), + VK_ERROR_DEVICE_LOST = -(0x00000007), + VK_ERROR_INVALID_POINTER = -(0x00000008), + VK_ERROR_INVALID_VALUE = -(0x00000009), + VK_ERROR_INVALID_HANDLE = -(0x0000000A), + VK_ERROR_INVALID_ORDINAL = -(0x0000000B), + VK_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C), + VK_ERROR_INVALID_EXTENSION = -(0x0000000D), + VK_ERROR_INVALID_FLAGS = -(0x0000000E), + VK_ERROR_INVALID_ALIGNMENT = -(0x0000000F), + VK_ERROR_INVALID_FORMAT = -(0x00000010), + VK_ERROR_INVALID_IMAGE = -(0x00000011), + VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012), + VK_ERROR_INVALID_QUEUE_TYPE = -(0x00000013), + VK_ERROR_INVALID_OBJECT_TYPE = -(0x00000014), + VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015), + VK_ERROR_BAD_SHADER_CODE = -(0x00000016), + VK_ERROR_BAD_PIPELINE_DATA = -(0x00000017), + VK_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018), + VK_ERROR_NOT_MAPPABLE = -(0x00000019), + VK_ERROR_MEMORY_MAP_FAILED = -(0x0000001A), + VK_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B), + VK_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C), + VK_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D), + VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E), + VK_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F), + VK_ERROR_MEMORY_NOT_BOUND = -(0x00000020), + VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021), + VK_ERROR_NOT_SHAREABLE = -(0x00000022), + VK_MAX_ENUM(_VK_RESULT_CODE) +} VK_RESULT; // ------------------------------------------------------------------------------------------------ -// XGL format definitions - -typedef enum _XGL_VERTEX_INPUT_STEP_RATE -{ - XGL_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0, - XGL_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1, - XGL_VERTEX_INPUT_STEP_RATE_DRAW = 0x2, //Optional - - XGL_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = XGL_VERTEX_INPUT_STEP_RATE_VERTEX, - XGL_VERTEX_INPUT_STEP_RATE_END_RANGE = XGL_VERTEX_INPUT_STEP_RATE_DRAW, - XGL_NUM_VERTEX_INPUT_STEP_RATE = (XGL_VERTEX_INPUT_STEP_RATE_END_RANGE - XGL_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_VERTEX_INPUT_STEP_RATE) -} XGL_VERTEX_INPUT_STEP_RATE; - -typedef enum _XGL_FORMAT -{ - XGL_FMT_UNDEFINED = 0x00000000, - XGL_FMT_R4G4_UNORM = 0x00000001, - XGL_FMT_R4G4_USCALED = 0x00000002, - XGL_FMT_R4G4B4A4_UNORM = 0x00000003, - XGL_FMT_R4G4B4A4_USCALED = 0x00000004, - XGL_FMT_R5G6B5_UNORM = 0x00000005, - XGL_FMT_R5G6B5_USCALED = 0x00000006, - XGL_FMT_R5G5B5A1_UNORM = 0x00000007, - XGL_FMT_R5G5B5A1_USCALED = 0x00000008, - XGL_FMT_R8_UNORM = 0x00000009, - XGL_FMT_R8_SNORM = 0x0000000A, - XGL_FMT_R8_USCALED = 0x0000000B, - XGL_FMT_R8_SSCALED = 0x0000000C, - XGL_FMT_R8_UINT = 0x0000000D, - XGL_FMT_R8_SINT = 0x0000000E, - XGL_FMT_R8_SRGB = 0x0000000F, - XGL_FMT_R8G8_UNORM = 0x00000010, - XGL_FMT_R8G8_SNORM = 0x00000011, - XGL_FMT_R8G8_USCALED = 0x00000012, - XGL_FMT_R8G8_SSCALED = 0x00000013, - XGL_FMT_R8G8_UINT = 0x00000014, - XGL_FMT_R8G8_SINT = 0x00000015, - XGL_FMT_R8G8_SRGB = 0x00000016, - XGL_FMT_R8G8B8_UNORM = 0x00000017, - XGL_FMT_R8G8B8_SNORM = 0x00000018, - XGL_FMT_R8G8B8_USCALED = 0x00000019, - XGL_FMT_R8G8B8_SSCALED = 0x0000001A, - XGL_FMT_R8G8B8_UINT = 0x0000001B, - XGL_FMT_R8G8B8_SINT = 0x0000001C, - XGL_FMT_R8G8B8_SRGB = 0x0000001D, - XGL_FMT_R8G8B8A8_UNORM = 0x0000001E, - XGL_FMT_R8G8B8A8_SNORM = 0x0000001F, - XGL_FMT_R8G8B8A8_USCALED = 0x00000020, - XGL_FMT_R8G8B8A8_SSCALED = 0x00000021, - XGL_FMT_R8G8B8A8_UINT = 0x00000022, - XGL_FMT_R8G8B8A8_SINT = 0x00000023, - XGL_FMT_R8G8B8A8_SRGB = 0x00000024, - XGL_FMT_R10G10B10A2_UNORM = 0x00000025, - XGL_FMT_R10G10B10A2_SNORM = 0x00000026, - XGL_FMT_R10G10B10A2_USCALED = 0x00000027, - XGL_FMT_R10G10B10A2_SSCALED = 0x00000028, - XGL_FMT_R10G10B10A2_UINT = 0x00000029, - XGL_FMT_R10G10B10A2_SINT = 0x0000002A, - XGL_FMT_R16_UNORM = 0x0000002B, - XGL_FMT_R16_SNORM = 0x0000002C, - XGL_FMT_R16_USCALED = 0x0000002D, - XGL_FMT_R16_SSCALED = 0x0000002E, - XGL_FMT_R16_UINT = 0x0000002F, - XGL_FMT_R16_SINT = 0x00000030, - XGL_FMT_R16_SFLOAT = 0x00000031, - XGL_FMT_R16G16_UNORM = 0x00000032, - XGL_FMT_R16G16_SNORM = 0x00000033, - XGL_FMT_R16G16_USCALED = 0x00000034, - XGL_FMT_R16G16_SSCALED = 0x00000035, - XGL_FMT_R16G16_UINT = 0x00000036, - XGL_FMT_R16G16_SINT = 0x00000037, - XGL_FMT_R16G16_SFLOAT = 0x00000038, - XGL_FMT_R16G16B16_UNORM = 0x00000039, - XGL_FMT_R16G16B16_SNORM = 0x0000003A, - XGL_FMT_R16G16B16_USCALED = 0x0000003B, - XGL_FMT_R16G16B16_SSCALED = 0x0000003C, - XGL_FMT_R16G16B16_UINT = 0x0000003D, - XGL_FMT_R16G16B16_SINT = 0x0000003E, - XGL_FMT_R16G16B16_SFLOAT = 0x0000003F, - XGL_FMT_R16G16B16A16_UNORM = 0x00000040, - XGL_FMT_R16G16B16A16_SNORM = 0x00000041, - XGL_FMT_R16G16B16A16_USCALED = 0x00000042, - XGL_FMT_R16G16B16A16_SSCALED = 0x00000043, - XGL_FMT_R16G16B16A16_UINT = 0x00000044, - XGL_FMT_R16G16B16A16_SINT = 0x00000045, - XGL_FMT_R16G16B16A16_SFLOAT = 0x00000046, - XGL_FMT_R32_UINT = 0x00000047, - XGL_FMT_R32_SINT = 0x00000048, - XGL_FMT_R32_SFLOAT = 0x00000049, - XGL_FMT_R32G32_UINT = 0x0000004A, - XGL_FMT_R32G32_SINT = 0x0000004B, - XGL_FMT_R32G32_SFLOAT = 0x0000004C, - XGL_FMT_R32G32B32_UINT = 0x0000004D, - XGL_FMT_R32G32B32_SINT = 0x0000004E, - XGL_FMT_R32G32B32_SFLOAT = 0x0000004F, - XGL_FMT_R32G32B32A32_UINT = 0x00000050, - XGL_FMT_R32G32B32A32_SINT = 0x00000051, - XGL_FMT_R32G32B32A32_SFLOAT = 0x00000052, - XGL_FMT_R64_SFLOAT = 0x00000053, - XGL_FMT_R64G64_SFLOAT = 0x00000054, - XGL_FMT_R64G64B64_SFLOAT = 0x00000055, - XGL_FMT_R64G64B64A64_SFLOAT = 0x00000056, - XGL_FMT_R11G11B10_UFLOAT = 0x00000057, - XGL_FMT_R9G9B9E5_UFLOAT = 0x00000058, - XGL_FMT_D16_UNORM = 0x00000059, - XGL_FMT_D24_UNORM = 0x0000005A, - XGL_FMT_D32_SFLOAT = 0x0000005B, - XGL_FMT_S8_UINT = 0x0000005C, - XGL_FMT_D16_UNORM_S8_UINT = 0x0000005D, - XGL_FMT_D24_UNORM_S8_UINT = 0x0000005E, - XGL_FMT_D32_SFLOAT_S8_UINT = 0x0000005F, - XGL_FMT_BC1_RGB_UNORM = 0x00000060, - XGL_FMT_BC1_RGB_SRGB = 0x00000061, - XGL_FMT_BC1_RGBA_UNORM = 0x00000062, - XGL_FMT_BC1_RGBA_SRGB = 0x00000063, - XGL_FMT_BC2_UNORM = 0x00000064, - XGL_FMT_BC2_SRGB = 0x00000065, - XGL_FMT_BC3_UNORM = 0x00000066, - XGL_FMT_BC3_SRGB = 0x00000067, - XGL_FMT_BC4_UNORM = 0x00000068, - XGL_FMT_BC4_SNORM = 0x00000069, - XGL_FMT_BC5_UNORM = 0x0000006A, - XGL_FMT_BC5_SNORM = 0x0000006B, - XGL_FMT_BC6H_UFLOAT = 0x0000006C, - XGL_FMT_BC6H_SFLOAT = 0x0000006D, - XGL_FMT_BC7_UNORM = 0x0000006E, - XGL_FMT_BC7_SRGB = 0x0000006F, - XGL_FMT_ETC2_R8G8B8_UNORM = 0x00000070, - XGL_FMT_ETC2_R8G8B8_SRGB = 0x00000071, - XGL_FMT_ETC2_R8G8B8A1_UNORM = 0x00000072, - XGL_FMT_ETC2_R8G8B8A1_SRGB = 0x00000073, - XGL_FMT_ETC2_R8G8B8A8_UNORM = 0x00000074, - XGL_FMT_ETC2_R8G8B8A8_SRGB = 0x00000075, - XGL_FMT_EAC_R11_UNORM = 0x00000076, - XGL_FMT_EAC_R11_SNORM = 0x00000077, - XGL_FMT_EAC_R11G11_UNORM = 0x00000078, - XGL_FMT_EAC_R11G11_SNORM = 0x00000079, - XGL_FMT_ASTC_4x4_UNORM = 0x0000007A, - XGL_FMT_ASTC_4x4_SRGB = 0x0000007B, - XGL_FMT_ASTC_5x4_UNORM = 0x0000007C, - XGL_FMT_ASTC_5x4_SRGB = 0x0000007D, - XGL_FMT_ASTC_5x5_UNORM = 0x0000007E, - XGL_FMT_ASTC_5x5_SRGB = 0x0000007F, - XGL_FMT_ASTC_6x5_UNORM = 0x00000080, - XGL_FMT_ASTC_6x5_SRGB = 0x00000081, - XGL_FMT_ASTC_6x6_UNORM = 0x00000082, - XGL_FMT_ASTC_6x6_SRGB = 0x00000083, - XGL_FMT_ASTC_8x5_UNORM = 0x00000084, - XGL_FMT_ASTC_8x5_SRGB = 0x00000085, - XGL_FMT_ASTC_8x6_UNORM = 0x00000086, - XGL_FMT_ASTC_8x6_SRGB = 0x00000087, - XGL_FMT_ASTC_8x8_UNORM = 0x00000088, - XGL_FMT_ASTC_8x8_SRGB = 0x00000089, - XGL_FMT_ASTC_10x5_UNORM = 0x0000008A, - XGL_FMT_ASTC_10x5_SRGB = 0x0000008B, - XGL_FMT_ASTC_10x6_UNORM = 0x0000008C, - XGL_FMT_ASTC_10x6_SRGB = 0x0000008D, - XGL_FMT_ASTC_10x8_UNORM = 0x0000008E, - XGL_FMT_ASTC_10x8_SRGB = 0x0000008F, - XGL_FMT_ASTC_10x10_UNORM = 0x00000090, - XGL_FMT_ASTC_10x10_SRGB = 0x00000091, - XGL_FMT_ASTC_12x10_UNORM = 0x00000092, - XGL_FMT_ASTC_12x10_SRGB = 0x00000093, - XGL_FMT_ASTC_12x12_UNORM = 0x00000094, - XGL_FMT_ASTC_12x12_SRGB = 0x00000095, - XGL_FMT_B4G4R4A4_UNORM = 0x00000096, - XGL_FMT_B5G5R5A1_UNORM = 0x00000097, - XGL_FMT_B5G6R5_UNORM = 0x00000098, - XGL_FMT_B5G6R5_USCALED = 0x00000099, - XGL_FMT_B8G8R8_UNORM = 0x0000009A, - XGL_FMT_B8G8R8_SNORM = 0x0000009B, - XGL_FMT_B8G8R8_USCALED = 0x0000009C, - XGL_FMT_B8G8R8_SSCALED = 0x0000009D, - XGL_FMT_B8G8R8_UINT = 0x0000009E, - XGL_FMT_B8G8R8_SINT = 0x0000009F, - XGL_FMT_B8G8R8_SRGB = 0x000000A0, - XGL_FMT_B8G8R8A8_UNORM = 0x000000A1, - XGL_FMT_B8G8R8A8_SNORM = 0x000000A2, - XGL_FMT_B8G8R8A8_USCALED = 0x000000A3, - XGL_FMT_B8G8R8A8_SSCALED = 0x000000A4, - XGL_FMT_B8G8R8A8_UINT = 0x000000A5, - XGL_FMT_B8G8R8A8_SINT = 0x000000A6, - XGL_FMT_B8G8R8A8_SRGB = 0x000000A7, - XGL_FMT_B10G10R10A2_UNORM = 0x000000A8, - XGL_FMT_B10G10R10A2_SNORM = 0x000000A9, - XGL_FMT_B10G10R10A2_USCALED = 0x000000AA, - XGL_FMT_B10G10R10A2_SSCALED = 0x000000AB, - XGL_FMT_B10G10R10A2_UINT = 0x000000AC, - XGL_FMT_B10G10R10A2_SINT = 0x000000AD, - - XGL_FMT_BEGIN_RANGE = XGL_FMT_UNDEFINED, - XGL_FMT_END_RANGE = XGL_FMT_B10G10R10A2_SINT, - XGL_NUM_FMT = (XGL_FMT_END_RANGE - XGL_FMT_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_FORMAT) -} XGL_FORMAT; +// VK format definitions + +typedef enum _VK_VERTEX_INPUT_STEP_RATE +{ + VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0, + VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1, + VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2, //Optional + + VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, + VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_DRAW, + VK_NUM_VERTEX_INPUT_STEP_RATE = (VK_VERTEX_INPUT_STEP_RATE_END_RANGE - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_VERTEX_INPUT_STEP_RATE) +} VK_VERTEX_INPUT_STEP_RATE; + +typedef enum _VK_FORMAT +{ + VK_FMT_UNDEFINED = 0x00000000, + VK_FMT_R4G4_UNORM = 0x00000001, + VK_FMT_R4G4_USCALED = 0x00000002, + VK_FMT_R4G4B4A4_UNORM = 0x00000003, + VK_FMT_R4G4B4A4_USCALED = 0x00000004, + VK_FMT_R5G6B5_UNORM = 0x00000005, + VK_FMT_R5G6B5_USCALED = 0x00000006, + VK_FMT_R5G5B5A1_UNORM = 0x00000007, + VK_FMT_R5G5B5A1_USCALED = 0x00000008, + VK_FMT_R8_UNORM = 0x00000009, + VK_FMT_R8_SNORM = 0x0000000A, + VK_FMT_R8_USCALED = 0x0000000B, + VK_FMT_R8_SSCALED = 0x0000000C, + VK_FMT_R8_UINT = 0x0000000D, + VK_FMT_R8_SINT = 0x0000000E, + VK_FMT_R8_SRGB = 0x0000000F, + VK_FMT_R8G8_UNORM = 0x00000010, + VK_FMT_R8G8_SNORM = 0x00000011, + VK_FMT_R8G8_USCALED = 0x00000012, + VK_FMT_R8G8_SSCALED = 0x00000013, + VK_FMT_R8G8_UINT = 0x00000014, + VK_FMT_R8G8_SINT = 0x00000015, + VK_FMT_R8G8_SRGB = 0x00000016, + VK_FMT_R8G8B8_UNORM = 0x00000017, + VK_FMT_R8G8B8_SNORM = 0x00000018, + VK_FMT_R8G8B8_USCALED = 0x00000019, + VK_FMT_R8G8B8_SSCALED = 0x0000001A, + VK_FMT_R8G8B8_UINT = 0x0000001B, + VK_FMT_R8G8B8_SINT = 0x0000001C, + VK_FMT_R8G8B8_SRGB = 0x0000001D, + VK_FMT_R8G8B8A8_UNORM = 0x0000001E, + VK_FMT_R8G8B8A8_SNORM = 0x0000001F, + VK_FMT_R8G8B8A8_USCALED = 0x00000020, + VK_FMT_R8G8B8A8_SSCALED = 0x00000021, + VK_FMT_R8G8B8A8_UINT = 0x00000022, + VK_FMT_R8G8B8A8_SINT = 0x00000023, + VK_FMT_R8G8B8A8_SRGB = 0x00000024, + VK_FMT_R10G10B10A2_UNORM = 0x00000025, + VK_FMT_R10G10B10A2_SNORM = 0x00000026, + VK_FMT_R10G10B10A2_USCALED = 0x00000027, + VK_FMT_R10G10B10A2_SSCALED = 0x00000028, + VK_FMT_R10G10B10A2_UINT = 0x00000029, + VK_FMT_R10G10B10A2_SINT = 0x0000002A, + VK_FMT_R16_UNORM = 0x0000002B, + VK_FMT_R16_SNORM = 0x0000002C, + VK_FMT_R16_USCALED = 0x0000002D, + VK_FMT_R16_SSCALED = 0x0000002E, + VK_FMT_R16_UINT = 0x0000002F, + VK_FMT_R16_SINT = 0x00000030, + VK_FMT_R16_SFLOAT = 0x00000031, + VK_FMT_R16G16_UNORM = 0x00000032, + VK_FMT_R16G16_SNORM = 0x00000033, + VK_FMT_R16G16_USCALED = 0x00000034, + VK_FMT_R16G16_SSCALED = 0x00000035, + VK_FMT_R16G16_UINT = 0x00000036, + VK_FMT_R16G16_SINT = 0x00000037, + VK_FMT_R16G16_SFLOAT = 0x00000038, + VK_FMT_R16G16B16_UNORM = 0x00000039, + VK_FMT_R16G16B16_SNORM = 0x0000003A, + VK_FMT_R16G16B16_USCALED = 0x0000003B, + VK_FMT_R16G16B16_SSCALED = 0x0000003C, + VK_FMT_R16G16B16_UINT = 0x0000003D, + VK_FMT_R16G16B16_SINT = 0x0000003E, + VK_FMT_R16G16B16_SFLOAT = 0x0000003F, + VK_FMT_R16G16B16A16_UNORM = 0x00000040, + VK_FMT_R16G16B16A16_SNORM = 0x00000041, + VK_FMT_R16G16B16A16_USCALED = 0x00000042, + VK_FMT_R16G16B16A16_SSCALED = 0x00000043, + VK_FMT_R16G16B16A16_UINT = 0x00000044, + VK_FMT_R16G16B16A16_SINT = 0x00000045, + VK_FMT_R16G16B16A16_SFLOAT = 0x00000046, + VK_FMT_R32_UINT = 0x00000047, + VK_FMT_R32_SINT = 0x00000048, + VK_FMT_R32_SFLOAT = 0x00000049, + VK_FMT_R32G32_UINT = 0x0000004A, + VK_FMT_R32G32_SINT = 0x0000004B, + VK_FMT_R32G32_SFLOAT = 0x0000004C, + VK_FMT_R32G32B32_UINT = 0x0000004D, + VK_FMT_R32G32B32_SINT = 0x0000004E, + VK_FMT_R32G32B32_SFLOAT = 0x0000004F, + VK_FMT_R32G32B32A32_UINT = 0x00000050, + VK_FMT_R32G32B32A32_SINT = 0x00000051, + VK_FMT_R32G32B32A32_SFLOAT = 0x00000052, + VK_FMT_R64_SFLOAT = 0x00000053, + VK_FMT_R64G64_SFLOAT = 0x00000054, + VK_FMT_R64G64B64_SFLOAT = 0x00000055, + VK_FMT_R64G64B64A64_SFLOAT = 0x00000056, + VK_FMT_R11G11B10_UFLOAT = 0x00000057, + VK_FMT_R9G9B9E5_UFLOAT = 0x00000058, + VK_FMT_D16_UNORM = 0x00000059, + VK_FMT_D24_UNORM = 0x0000005A, + VK_FMT_D32_SFLOAT = 0x0000005B, + VK_FMT_S8_UINT = 0x0000005C, + VK_FMT_D16_UNORM_S8_UINT = 0x0000005D, + VK_FMT_D24_UNORM_S8_UINT = 0x0000005E, + VK_FMT_D32_SFLOAT_S8_UINT = 0x0000005F, + VK_FMT_BC1_RGB_UNORM = 0x00000060, + VK_FMT_BC1_RGB_SRGB = 0x00000061, + VK_FMT_BC1_RGBA_UNORM = 0x00000062, + VK_FMT_BC1_RGBA_SRGB = 0x00000063, + VK_FMT_BC2_UNORM = 0x00000064, + VK_FMT_BC2_SRGB = 0x00000065, + VK_FMT_BC3_UNORM = 0x00000066, + VK_FMT_BC3_SRGB = 0x00000067, + VK_FMT_BC4_UNORM = 0x00000068, + VK_FMT_BC4_SNORM = 0x00000069, + VK_FMT_BC5_UNORM = 0x0000006A, + VK_FMT_BC5_SNORM = 0x0000006B, + VK_FMT_BC6H_UFLOAT = 0x0000006C, + VK_FMT_BC6H_SFLOAT = 0x0000006D, + VK_FMT_BC7_UNORM = 0x0000006E, + VK_FMT_BC7_SRGB = 0x0000006F, + VK_FMT_ETC2_R8G8B8_UNORM = 0x00000070, + VK_FMT_ETC2_R8G8B8_SRGB = 0x00000071, + VK_FMT_ETC2_R8G8B8A1_UNORM = 0x00000072, + VK_FMT_ETC2_R8G8B8A1_SRGB = 0x00000073, + VK_FMT_ETC2_R8G8B8A8_UNORM = 0x00000074, + VK_FMT_ETC2_R8G8B8A8_SRGB = 0x00000075, + VK_FMT_EAC_R11_UNORM = 0x00000076, + VK_FMT_EAC_R11_SNORM = 0x00000077, + VK_FMT_EAC_R11G11_UNORM = 0x00000078, + VK_FMT_EAC_R11G11_SNORM = 0x00000079, + VK_FMT_ASTC_4x4_UNORM = 0x0000007A, + VK_FMT_ASTC_4x4_SRGB = 0x0000007B, + VK_FMT_ASTC_5x4_UNORM = 0x0000007C, + VK_FMT_ASTC_5x4_SRGB = 0x0000007D, + VK_FMT_ASTC_5x5_UNORM = 0x0000007E, + VK_FMT_ASTC_5x5_SRGB = 0x0000007F, + VK_FMT_ASTC_6x5_UNORM = 0x00000080, + VK_FMT_ASTC_6x5_SRGB = 0x00000081, + VK_FMT_ASTC_6x6_UNORM = 0x00000082, + VK_FMT_ASTC_6x6_SRGB = 0x00000083, + VK_FMT_ASTC_8x5_UNORM = 0x00000084, + VK_FMT_ASTC_8x5_SRGB = 0x00000085, + VK_FMT_ASTC_8x6_UNORM = 0x00000086, + VK_FMT_ASTC_8x6_SRGB = 0x00000087, + VK_FMT_ASTC_8x8_UNORM = 0x00000088, + VK_FMT_ASTC_8x8_SRGB = 0x00000089, + VK_FMT_ASTC_10x5_UNORM = 0x0000008A, + VK_FMT_ASTC_10x5_SRGB = 0x0000008B, + VK_FMT_ASTC_10x6_UNORM = 0x0000008C, + VK_FMT_ASTC_10x6_SRGB = 0x0000008D, + VK_FMT_ASTC_10x8_UNORM = 0x0000008E, + VK_FMT_ASTC_10x8_SRGB = 0x0000008F, + VK_FMT_ASTC_10x10_UNORM = 0x00000090, + VK_FMT_ASTC_10x10_SRGB = 0x00000091, + VK_FMT_ASTC_12x10_UNORM = 0x00000092, + VK_FMT_ASTC_12x10_SRGB = 0x00000093, + VK_FMT_ASTC_12x12_UNORM = 0x00000094, + VK_FMT_ASTC_12x12_SRGB = 0x00000095, + VK_FMT_B4G4R4A4_UNORM = 0x00000096, + VK_FMT_B5G5R5A1_UNORM = 0x00000097, + VK_FMT_B5G6R5_UNORM = 0x00000098, + VK_FMT_B5G6R5_USCALED = 0x00000099, + VK_FMT_B8G8R8_UNORM = 0x0000009A, + VK_FMT_B8G8R8_SNORM = 0x0000009B, + VK_FMT_B8G8R8_USCALED = 0x0000009C, + VK_FMT_B8G8R8_SSCALED = 0x0000009D, + VK_FMT_B8G8R8_UINT = 0x0000009E, + VK_FMT_B8G8R8_SINT = 0x0000009F, + VK_FMT_B8G8R8_SRGB = 0x000000A0, + VK_FMT_B8G8R8A8_UNORM = 0x000000A1, + VK_FMT_B8G8R8A8_SNORM = 0x000000A2, + VK_FMT_B8G8R8A8_USCALED = 0x000000A3, + VK_FMT_B8G8R8A8_SSCALED = 0x000000A4, + VK_FMT_B8G8R8A8_UINT = 0x000000A5, + VK_FMT_B8G8R8A8_SINT = 0x000000A6, + VK_FMT_B8G8R8A8_SRGB = 0x000000A7, + VK_FMT_B10G10R10A2_UNORM = 0x000000A8, + VK_FMT_B10G10R10A2_SNORM = 0x000000A9, + VK_FMT_B10G10R10A2_USCALED = 0x000000AA, + VK_FMT_B10G10R10A2_SSCALED = 0x000000AB, + VK_FMT_B10G10R10A2_UINT = 0x000000AC, + VK_FMT_B10G10R10A2_SINT = 0x000000AD, + + VK_FMT_BEGIN_RANGE = VK_FMT_UNDEFINED, + VK_FMT_END_RANGE = VK_FMT_B10G10R10A2_SINT, + VK_NUM_FMT = (VK_FMT_END_RANGE - VK_FMT_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_FORMAT) +} VK_FORMAT; // Shader stage enumerant -typedef enum _XGL_PIPELINE_SHADER_STAGE -{ - XGL_SHADER_STAGE_VERTEX = 0, - XGL_SHADER_STAGE_TESS_CONTROL = 1, - XGL_SHADER_STAGE_TESS_EVALUATION = 2, - XGL_SHADER_STAGE_GEOMETRY = 3, - XGL_SHADER_STAGE_FRAGMENT = 4, - XGL_SHADER_STAGE_COMPUTE = 5, - - XGL_SHADER_STAGE_BEGIN_RANGE = XGL_SHADER_STAGE_VERTEX, - XGL_SHADER_STAGE_END_RANGE = XGL_SHADER_STAGE_COMPUTE, - XGL_NUM_SHADER_STAGE = (XGL_SHADER_STAGE_END_RANGE - XGL_SHADER_STAGE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_PIPELINE_SHADER_STAGE) -} XGL_PIPELINE_SHADER_STAGE; - -typedef enum _XGL_SHADER_STAGE_FLAGS -{ - XGL_SHADER_STAGE_FLAGS_VERTEX_BIT = 0x00000001, - XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT = 0x00000002, - XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT = 0x00000004, - XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT = 0x00000008, - XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT = 0x00000010, - XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT = 0x00000020, - - XGL_SHADER_STAGE_FLAGS_ALL = 0x7FFFFFFF, - XGL_MAX_ENUM(_XGL_SHADER_STAGE_FLAGS) -} XGL_SHADER_STAGE_FLAGS; +typedef enum _VK_PIPELINE_SHADER_STAGE +{ + VK_SHADER_STAGE_VERTEX = 0, + VK_SHADER_STAGE_TESS_CONTROL = 1, + VK_SHADER_STAGE_TESS_EVALUATION = 2, + VK_SHADER_STAGE_GEOMETRY = 3, + VK_SHADER_STAGE_FRAGMENT = 4, + VK_SHADER_STAGE_COMPUTE = 5, + + VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, + VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, + VK_NUM_SHADER_STAGE = (VK_SHADER_STAGE_END_RANGE - VK_SHADER_STAGE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_PIPELINE_SHADER_STAGE) +} VK_PIPELINE_SHADER_STAGE; + +typedef enum _VK_SHADER_STAGE_FLAGS +{ + VK_SHADER_STAGE_FLAGS_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_FLAGS_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FLAGS_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_FLAGS_COMPUTE_BIT = 0x00000020, + + VK_SHADER_STAGE_FLAGS_ALL = 0x7FFFFFFF, + VK_MAX_ENUM(_VK_SHADER_STAGE_FLAGS) +} VK_SHADER_STAGE_FLAGS; // Structure type enumerant -typedef enum _XGL_STRUCTURE_TYPE -{ - XGL_STRUCTURE_TYPE_APPLICATION_INFO = 0, - XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, - XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, - XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4, - XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5, - XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 6, - XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7, - XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO = 8, - XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9, - XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10, - XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11, - XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12, - XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13, - XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14, - XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 15, - XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 16, - XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 17, - XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 18, - XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 19, - XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20, - XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21, - XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22, - XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23, - XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24, - XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25, - XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26, - XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27, - XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 28, - XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 29, - XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 30, - XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 31, - XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 32, - XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 33, - XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 34, - XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 35, - XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 36, - XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 37, - XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 38, - XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 39, - XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 40, - XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 41, - XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 42, - XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO = 43, - XGL_STRUCTURE_TYPE_PIPELINE_BARRIER = 44, - XGL_STRUCTURE_TYPE_MEMORY_BARRIER = 45, - XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 46, - XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 47, - XGL_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 48, - XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS = 49, - XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 50, - XGL_STRUCTURE_TYPE_UPDATE_IMAGES = 51, - XGL_STRUCTURE_TYPE_UPDATE_BUFFERS = 52, - XGL_STRUCTURE_TYPE_UPDATE_AS_COPY = 53, - XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO = 54, - XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO = 55, - XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 56, - XGL_STRUCTURE_TYPE_BEGIN_RANGE = XGL_STRUCTURE_TYPE_APPLICATION_INFO, - XGL_STRUCTURE_TYPE_END_RANGE = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - XGL_NUM_STRUCTURE_TYPE = (XGL_STRUCTURE_TYPE_END_RANGE - XGL_STRUCTURE_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE) -} XGL_STRUCTURE_TYPE; +typedef enum _VK_STRUCTURE_TYPE +{ + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, + VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4, + VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5, + VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 6, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7, + VK_STRUCTURE_TYPE_EVENT_WAIT_INFO = 8, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 34, + VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 35, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 36, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 40, + VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 41, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 42, + VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 43, + VK_STRUCTURE_TYPE_PIPELINE_BARRIER = 44, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 47, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 49, + VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 50, + VK_STRUCTURE_TYPE_UPDATE_IMAGES = 51, + VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 52, + VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 53, + VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO = 54, + VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO = 55, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 56, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + VK_NUM_STRUCTURE_TYPE = (VK_STRUCTURE_TYPE_END_RANGE - VK_STRUCTURE_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_STRUCTURE_TYPE) +} VK_STRUCTURE_TYPE; // ------------------------------------------------------------------------------------------------ // Flags // Device creation flags -typedef enum _XGL_DEVICE_CREATE_FLAGS +typedef enum _VK_DEVICE_CREATE_FLAGS { - XGL_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, - XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002, - XGL_MAX_ENUM(_XGL_DEVICE_CREATE_FLAGS) -} XGL_DEVICE_CREATE_FLAGS; + VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, + VK_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002, + VK_MAX_ENUM(_VK_DEVICE_CREATE_FLAGS) +} VK_DEVICE_CREATE_FLAGS; // Queue capabilities -typedef enum _XGL_QUEUE_FLAGS -{ - XGL_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations - XGL_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations - XGL_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations - XGL_QUEUE_EXTENDED_BIT = 0x40000000, // Extended queue - XGL_MAX_ENUM(_XGL_QUEUE_FLAGS) -} XGL_QUEUE_FLAGS; - -// memory properties passed into xglAllocMemory(). -typedef enum _XGL_MEMORY_PROPERTY_FLAGS -{ - XGL_MEMORY_PROPERTY_GPU_ONLY = 0x00000000, // If not set, then allocate memory on device (GPU) - XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT = 0x00000001, - XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT = 0x00000002, - XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT = 0x00000004, - XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT = 0x00000008, - XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL = 0x00000010, // all else being equal, prefer CPU access - XGL_MEMORY_PROPERTY_SHAREABLE_BIT = 0x00000020, - XGL_MAX_ENUM(_XGL_MEMORY_PROPERTY_FLAGS) -} XGL_MEMORY_PROPERTY_FLAGS; - -typedef enum _XGL_MEMORY_TYPE -{ - XGL_MEMORY_TYPE_OTHER = 0x00000000, // device memory that is not any of the others - XGL_MEMORY_TYPE_BUFFER = 0x00000001, // memory for buffers and associated information - XGL_MEMORY_TYPE_IMAGE = 0x00000002, // memory for images and associated information - - XGL_MEMORY_TYPE_BEGIN_RANGE = XGL_MEMORY_TYPE_OTHER, - XGL_MEMORY_TYPE_END_RANGE = XGL_MEMORY_TYPE_IMAGE, - XGL_NUM_MEMORY_TYPE = (XGL_MEMORY_TYPE_END_RANGE - XGL_MEMORY_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_MEMORY_TYPE) -} XGL_MEMORY_TYPE; +typedef enum _VK_QUEUE_FLAGS +{ + VK_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations + VK_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations + VK_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations + VK_QUEUE_EXTENDED_BIT = 0x40000000, // Extended queue + VK_MAX_ENUM(_VK_QUEUE_FLAGS) +} VK_QUEUE_FLAGS; + +// memory properties passed into vkAllocMemory(). +typedef enum _VK_MEMORY_PROPERTY_FLAGS +{ + VK_MEMORY_PROPERTY_GPU_ONLY = 0x00000000, // If not set, then allocate memory on device (GPU) + VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT = 0x00000001, + VK_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT = 0x00000002, + VK_MEMORY_PROPERTY_CPU_UNCACHED_BIT = 0x00000004, + VK_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_PREFER_CPU_LOCAL = 0x00000010, // all else being equal, prefer CPU access + VK_MEMORY_PROPERTY_SHAREABLE_BIT = 0x00000020, + VK_MAX_ENUM(_VK_MEMORY_PROPERTY_FLAGS) +} VK_MEMORY_PROPERTY_FLAGS; + +typedef enum _VK_MEMORY_TYPE +{ + VK_MEMORY_TYPE_OTHER = 0x00000000, // device memory that is not any of the others + VK_MEMORY_TYPE_BUFFER = 0x00000001, // memory for buffers and associated information + VK_MEMORY_TYPE_IMAGE = 0x00000002, // memory for images and associated information + + VK_MEMORY_TYPE_BEGIN_RANGE = VK_MEMORY_TYPE_OTHER, + VK_MEMORY_TYPE_END_RANGE = VK_MEMORY_TYPE_IMAGE, + VK_NUM_MEMORY_TYPE = (VK_MEMORY_TYPE_END_RANGE - VK_MEMORY_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_MEMORY_TYPE) +} VK_MEMORY_TYPE; // Buffer and buffer allocation usage flags -typedef enum _XGL_BUFFER_USAGE_FLAGS -{ - XGL_BUFFER_USAGE_GENERAL = 0x00000000, // no special usage - XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // Shader read (e.g. TBO, image buffer, UBO, SSBO) - XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002, // Shader write (e.g. image buffer, SSBO) - XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004, // Shader atomic operations (e.g. image buffer, SSBO) - XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000008, // used as a source for copies - XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000010, // used as a destination for copies - XGL_BUFFER_USAGE_UNIFORM_READ_BIT = 0x00000020, // Uniform read (UBO) - XGL_BUFFER_USAGE_INDEX_FETCH_BIT = 0x00000040, // Fixed function index fetch (index buffer) - XGL_BUFFER_USAGE_VERTEX_FETCH_BIT = 0x00000080, // Fixed function vertex fetch (VBO) - XGL_BUFFER_USAGE_SHADER_STORAGE_BIT = 0x00000100, // Shader storage buffer (SSBO) - XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT = 0x00000200, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) - XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT = 0x00000400, // texture buffer (TBO) - XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT = 0x00000800, // image buffer (load/store) - XGL_MAX_ENUM(_XGL_BUFFER_USAGE_FLAGS) -} XGL_BUFFER_USAGE_FLAGS; +typedef enum _VK_BUFFER_USAGE_FLAGS +{ + VK_BUFFER_USAGE_GENERAL = 0x00000000, // no special usage + VK_BUFFER_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // Shader read (e.g. TBO, image buffer, UBO, SSBO) + VK_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002, // Shader write (e.g. image buffer, SSBO) + VK_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004, // Shader atomic operations (e.g. image buffer, SSBO) + VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000008, // used as a source for copies + VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000010, // used as a destination for copies + VK_BUFFER_USAGE_UNIFORM_READ_BIT = 0x00000020, // Uniform read (UBO) + VK_BUFFER_USAGE_INDEX_FETCH_BIT = 0x00000040, // Fixed function index fetch (index buffer) + VK_BUFFER_USAGE_VERTEX_FETCH_BIT = 0x00000080, // Fixed function vertex fetch (VBO) + VK_BUFFER_USAGE_SHADER_STORAGE_BIT = 0x00000100, // Shader storage buffer (SSBO) + VK_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT = 0x00000200, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) + VK_BUFFER_USAGE_TEXTURE_BUFFER_BIT = 0x00000400, // texture buffer (TBO) + VK_BUFFER_USAGE_IMAGE_BUFFER_BIT = 0x00000800, // image buffer (load/store) + VK_MAX_ENUM(_VK_BUFFER_USAGE_FLAGS) +} VK_BUFFER_USAGE_FLAGS; // Buffer flags -typedef enum _XGL_BUFFER_CREATE_FLAGS +typedef enum _VK_BUFFER_CREATE_FLAGS { - XGL_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001, - XGL_BUFFER_CREATE_SPARSE_BIT = 0x00000002, - XGL_MAX_ENUM(_XGL_BUFFER_CREATE_FLAGS) -} XGL_BUFFER_CREATE_FLAGS; + VK_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_BIT = 0x00000002, + VK_MAX_ENUM(_VK_BUFFER_CREATE_FLAGS) +} VK_BUFFER_CREATE_FLAGS; -typedef enum _XGL_BUFFER_VIEW_TYPE +typedef enum _VK_BUFFER_VIEW_TYPE { - XGL_BUFFER_VIEW_RAW = 0x00000000, // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers) - XGL_BUFFER_VIEW_TYPED = 0x00000001, // Typed buffer, format and channels are used (TBO, image buffer) + VK_BUFFER_VIEW_RAW = 0x00000000, // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers) + VK_BUFFER_VIEW_TYPED = 0x00000001, // Typed buffer, format and channels are used (TBO, image buffer) - XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE = XGL_BUFFER_VIEW_RAW, - XGL_BUFFER_VIEW_TYPE_END_RANGE = XGL_BUFFER_VIEW_TYPED, - XGL_NUM_BUFFER_VIEW_TYPE = (XGL_BUFFER_VIEW_TYPE_END_RANGE - XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_BUFFER_VIEW_TYPE) -} XGL_BUFFER_VIEW_TYPE; + VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_RAW, + VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPED, + VK_NUM_BUFFER_VIEW_TYPE = (VK_BUFFER_VIEW_TYPE_END_RANGE - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_BUFFER_VIEW_TYPE) +} VK_BUFFER_VIEW_TYPE; // Images memory allocations can be used for resources of a given format class. -typedef enum _XGL_IMAGE_FORMAT_CLASS -{ - XGL_IMAGE_FORMAT_CLASS_128_BITS = 1, // color formats - XGL_IMAGE_FORMAT_CLASS_96_BITS = 2, - XGL_IMAGE_FORMAT_CLASS_64_BITS = 3, - XGL_IMAGE_FORMAT_CLASS_48_BITS = 4, - XGL_IMAGE_FORMAT_CLASS_32_BITS = 5, - XGL_IMAGE_FORMAT_CLASS_24_BITS = 6, - XGL_IMAGE_FORMAT_CLASS_16_BITS = 7, - XGL_IMAGE_FORMAT_CLASS_8_BITS = 8, - XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK = 9, // 128-bit block compressed formats - XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK = 10, // 64-bit block compressed formats - XGL_IMAGE_FORMAT_CLASS_D32 = 11, // D32_SFLOAT - XGL_IMAGE_FORMAT_CLASS_D24 = 12, // D24_UNORM - XGL_IMAGE_FORMAT_CLASS_D16 = 13, // D16_UNORM - XGL_IMAGE_FORMAT_CLASS_S8 = 14, // S8_UINT - XGL_IMAGE_FORMAT_CLASS_D32S8 = 15, // D32_SFLOAT_S8_UINT - XGL_IMAGE_FORMAT_CLASS_D24S8 = 16, // D24_UNORM_S8_UINT - XGL_IMAGE_FORMAT_CLASS_D16S8 = 17, // D16_UNORM_S8_UINT - XGL_IMAGE_FORMAT_CLASS_LINEAR = 18, // used for pitch-linear (transparent) textures - - XGL_IMAGE_FORMAT_CLASS_BEGIN_RANGE = XGL_IMAGE_FORMAT_CLASS_128_BITS, - XGL_IMAGE_FORMAT_CLASS_END_RANGE = XGL_IMAGE_FORMAT_CLASS_LINEAR, - XGL_NUM_IMAGE_FORMAT_CLASS = (XGL_IMAGE_FORMAT_CLASS_END_RANGE - XGL_IMAGE_FORMAT_CLASS_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_IMAGE_FORMAT_CLASS) -} XGL_IMAGE_FORMAT_CLASS; +typedef enum _VK_IMAGE_FORMAT_CLASS +{ + VK_IMAGE_FORMAT_CLASS_128_BITS = 1, // color formats + VK_IMAGE_FORMAT_CLASS_96_BITS = 2, + VK_IMAGE_FORMAT_CLASS_64_BITS = 3, + VK_IMAGE_FORMAT_CLASS_48_BITS = 4, + VK_IMAGE_FORMAT_CLASS_32_BITS = 5, + VK_IMAGE_FORMAT_CLASS_24_BITS = 6, + VK_IMAGE_FORMAT_CLASS_16_BITS = 7, + VK_IMAGE_FORMAT_CLASS_8_BITS = 8, + VK_IMAGE_FORMAT_CLASS_128_BIT_BLOCK = 9, // 128-bit block compressed formats + VK_IMAGE_FORMAT_CLASS_64_BIT_BLOCK = 10, // 64-bit block compressed formats + VK_IMAGE_FORMAT_CLASS_D32 = 11, // D32_SFLOAT + VK_IMAGE_FORMAT_CLASS_D24 = 12, // D24_UNORM + VK_IMAGE_FORMAT_CLASS_D16 = 13, // D16_UNORM + VK_IMAGE_FORMAT_CLASS_S8 = 14, // S8_UINT + VK_IMAGE_FORMAT_CLASS_D32S8 = 15, // D32_SFLOAT_S8_UINT + VK_IMAGE_FORMAT_CLASS_D24S8 = 16, // D24_UNORM_S8_UINT + VK_IMAGE_FORMAT_CLASS_D16S8 = 17, // D16_UNORM_S8_UINT + VK_IMAGE_FORMAT_CLASS_LINEAR = 18, // used for pitch-linear (transparent) textures + + VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE = VK_IMAGE_FORMAT_CLASS_128_BITS, + VK_IMAGE_FORMAT_CLASS_END_RANGE = VK_IMAGE_FORMAT_CLASS_LINEAR, + VK_NUM_IMAGE_FORMAT_CLASS = (VK_IMAGE_FORMAT_CLASS_END_RANGE - VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE + 1), + VK_MAX_ENUM(_VK_IMAGE_FORMAT_CLASS) +} VK_IMAGE_FORMAT_CLASS; // Image and image allocation usage flags -typedef enum _XGL_IMAGE_USAGE_FLAGS -{ - XGL_IMAGE_USAGE_GENERAL = 0x00000000, // no special usage - XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // shader read (e.g. texture, image) - XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002, // shader write (e.g. image) - XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004, // shader atomic operations (e.g. image) - XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000008, // used as a source for copies - XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000010, // used as a destination for copies - XGL_IMAGE_USAGE_TEXTURE_BIT = 0x00000020, // opaque texture (2d, 3d, etc.) - XGL_IMAGE_USAGE_IMAGE_BIT = 0x00000040, // opaque image (2d, 3d, etc.) - XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000080, // framebuffer color attachment - XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000100, // framebuffer depth/stencil - XGL_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000200, // image data not needed outside of rendering. - XGL_MAX_ENUM(_XGL_IMAGE_USAGE_FLAGS) -} XGL_IMAGE_USAGE_FLAGS; +typedef enum _VK_IMAGE_USAGE_FLAGS +{ + VK_IMAGE_USAGE_GENERAL = 0x00000000, // no special usage + VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // shader read (e.g. texture, image) + VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002, // shader write (e.g. image) + VK_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004, // shader atomic operations (e.g. image) + VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000008, // used as a source for copies + VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000010, // used as a destination for copies + VK_IMAGE_USAGE_TEXTURE_BIT = 0x00000020, // opaque texture (2d, 3d, etc.) + VK_IMAGE_USAGE_IMAGE_BIT = 0x00000040, // opaque image (2d, 3d, etc.) + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000080, // framebuffer color attachment + VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000100, // framebuffer depth/stencil + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000200, // image data not needed outside of rendering. + VK_MAX_ENUM(_VK_IMAGE_USAGE_FLAGS) +} VK_IMAGE_USAGE_FLAGS; // Image flags -typedef enum _XGL_IMAGE_CREATE_FLAGS +typedef enum _VK_IMAGE_CREATE_FLAGS { - XGL_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001, - XGL_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002, - XGL_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004, - XGL_IMAGE_CREATE_SPARSE_BIT = 0x00000008, - XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, // Allows image views to have different format than the base image - XGL_MAX_ENUM(_XGL_IMAGE_CREATE_FLAGS) -} XGL_IMAGE_CREATE_FLAGS; + VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001, + VK_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002, + VK_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004, + VK_IMAGE_CREATE_SPARSE_BIT = 0x00000008, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, // Allows image views to have different format than the base image + VK_MAX_ENUM(_VK_IMAGE_CREATE_FLAGS) +} VK_IMAGE_CREATE_FLAGS; // Depth-stencil view creation flags -typedef enum _XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS +typedef enum _VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS { - XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, - XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, - XGL_MAX_ENUM(_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS) -} XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS; + VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, + VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, + VK_MAX_ENUM(_VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS) +} VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS; // Pipeline creation flags -typedef enum _XGL_PIPELINE_CREATE_FLAGS +typedef enum _VK_PIPELINE_CREATE_FLAGS { - XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - XGL_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - XGL_MAX_ENUM(_XGL_PIPELINE_CREATE_FLAGS) -} XGL_PIPELINE_CREATE_FLAGS; + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_MAX_ENUM(_VK_PIPELINE_CREATE_FLAGS) +} VK_PIPELINE_CREATE_FLAGS; // Fence creation flags -typedef enum _XGL_FENCE_CREATE_FLAGS +typedef enum _VK_FENCE_CREATE_FLAGS { - XGL_FENCE_CREATE_SIGNALED_BIT = 0x00000001, - XGL_MAX_ENUM(_XGL_FENCE_CREATE_FLAGS) -} XGL_FENCE_CREATE_FLAGS; + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_MAX_ENUM(_VK_FENCE_CREATE_FLAGS) +} VK_FENCE_CREATE_FLAGS; // Semaphore creation flags -typedef enum _XGL_SEMAPHORE_CREATE_FLAGS +typedef enum _VK_SEMAPHORE_CREATE_FLAGS { - XGL_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001, - XGL_MAX_ENUM(_XGL_SEMAPHORE_CREATE_FLAGS) -} XGL_SEMAPHORE_CREATE_FLAGS; + VK_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001, + VK_MAX_ENUM(_VK_SEMAPHORE_CREATE_FLAGS) +} VK_SEMAPHORE_CREATE_FLAGS; // Format capability flags -typedef enum _XGL_FORMAT_FEATURE_FLAGS -{ - XGL_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001, - XGL_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002, - XGL_FORMAT_IMAGE_COPY_BIT = 0x00000004, - XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT = 0x00000008, - XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT = 0x00000010, - XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000020, - XGL_FORMAT_DEPTH_ATTACHMENT_BIT = 0x00000040, - XGL_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080, - XGL_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100, - XGL_FORMAT_CONVERSION_BIT = 0x00000200, - XGL_MAX_ENUM(_XGL_FORMAT_FEATURE_FLAGS) -} XGL_FORMAT_FEATURE_FLAGS; +typedef enum _VK_FORMAT_FEATURE_FLAGS +{ + VK_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001, + VK_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002, + VK_FORMAT_IMAGE_COPY_BIT = 0x00000004, + VK_FORMAT_MEMORY_SHADER_ACCESS_BIT = 0x00000008, + VK_FORMAT_COLOR_ATTACHMENT_WRITE_BIT = 0x00000010, + VK_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000020, + VK_FORMAT_DEPTH_ATTACHMENT_BIT = 0x00000040, + VK_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100, + VK_FORMAT_CONVERSION_BIT = 0x00000200, + VK_MAX_ENUM(_VK_FORMAT_FEATURE_FLAGS) +} VK_FORMAT_FEATURE_FLAGS; // Query flags -typedef enum _XGL_QUERY_CONTROL_FLAGS +typedef enum _VK_QUERY_CONTROL_FLAGS { - XGL_QUERY_IMPRECISE_DATA_BIT = 0x00000001, - XGL_MAX_ENUM(_XGL_QUERY_CONTROL_FLAGS) -} XGL_QUERY_CONTROL_FLAGS; + VK_QUERY_IMPRECISE_DATA_BIT = 0x00000001, + VK_MAX_ENUM(_VK_QUERY_CONTROL_FLAGS) +} VK_QUERY_CONTROL_FLAGS; // GPU compatibility flags -typedef enum _XGL_GPU_COMPATIBILITY_FLAGS -{ - XGL_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001, - XGL_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002, - XGL_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004, - XGL_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008, - XGL_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010, - XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020, - XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040, - XGL_MAX_ENUM(_XGL_GPU_COMPATIBILITY_FLAGS) -} XGL_GPU_COMPATIBILITY_FLAGS; +typedef enum _VK_GPU_COMPATIBILITY_FLAGS +{ + VK_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001, + VK_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002, + VK_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004, + VK_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008, + VK_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010, + VK_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020, + VK_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040, + VK_MAX_ENUM(_VK_GPU_COMPATIBILITY_FLAGS) +} VK_GPU_COMPATIBILITY_FLAGS; // Command buffer building flags -typedef enum _XGL_CMD_BUFFER_BUILD_FLAGS +typedef enum _VK_CMD_BUFFER_BUILD_FLAGS { - XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001, - XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, - XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, - XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, - XGL_MAX_ENUM(_XGL_CMD_BUFFER_BUILD_FLAGS) -} XGL_CMD_BUFFER_BUILD_FLAGS; + VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001, + VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, + VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, + VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, + VK_MAX_ENUM(_VK_CMD_BUFFER_BUILD_FLAGS) +} VK_CMD_BUFFER_BUILD_FLAGS; // ------------------------------------------------------------------------------------------------ -// XGL structures +// VK structures -typedef struct _XGL_OFFSET2D +typedef struct _VK_OFFSET2D { int32_t x; int32_t y; -} XGL_OFFSET2D; +} VK_OFFSET2D; -typedef struct _XGL_OFFSET3D +typedef struct _VK_OFFSET3D { int32_t x; int32_t y; int32_t z; -} XGL_OFFSET3D; +} VK_OFFSET3D; -typedef struct _XGL_EXTENT2D +typedef struct _VK_EXTENT2D { int32_t width; int32_t height; -} XGL_EXTENT2D; +} VK_EXTENT2D; -typedef struct _XGL_EXTENT3D +typedef struct _VK_EXTENT3D { int32_t width; int32_t height; int32_t depth; -} XGL_EXTENT3D; +} VK_EXTENT3D; -typedef struct _XGL_VIEWPORT +typedef struct _VK_VIEWPORT { float originX; float originY; @@ -1318,31 +1318,31 @@ typedef struct _XGL_VIEWPORT float height; float minDepth; float maxDepth; -} XGL_VIEWPORT; +} VK_VIEWPORT; -typedef struct _XGL_RECT +typedef struct _VK_RECT { - XGL_OFFSET2D offset; - XGL_EXTENT2D extent; -} XGL_RECT; + VK_OFFSET2D offset; + VK_EXTENT2D extent; +} VK_RECT; -typedef struct _XGL_CHANNEL_MAPPING +typedef struct _VK_CHANNEL_MAPPING { - XGL_CHANNEL_SWIZZLE r; - XGL_CHANNEL_SWIZZLE g; - XGL_CHANNEL_SWIZZLE b; - XGL_CHANNEL_SWIZZLE a; -} XGL_CHANNEL_MAPPING; + VK_CHANNEL_SWIZZLE r; + VK_CHANNEL_SWIZZLE g; + VK_CHANNEL_SWIZZLE b; + VK_CHANNEL_SWIZZLE a; +} VK_CHANNEL_MAPPING; -typedef struct _XGL_PHYSICAL_GPU_PROPERTIES +typedef struct _VK_PHYSICAL_GPU_PROPERTIES { uint32_t apiVersion; uint32_t driverVersion; uint32_t vendorId; uint32_t deviceId; - XGL_PHYSICAL_GPU_TYPE gpuType; - char gpuName[XGL_MAX_PHYSICAL_GPU_NAME]; - XGL_GPU_SIZE maxInlineMemoryUpdateSize; + VK_PHYSICAL_GPU_TYPE gpuType; + char gpuName[VK_MAX_PHYSICAL_GPU_NAME]; + VK_GPU_SIZE maxInlineMemoryUpdateSize; uint32_t maxBoundDescriptorSets; uint32_t maxThreadGroupSize; uint64_t timestampFrequency; @@ -1350,731 +1350,731 @@ typedef struct _XGL_PHYSICAL_GPU_PROPERTIES uint32_t maxDescriptorSets; // at least 2? uint32_t maxViewports; // at least 16? uint32_t maxColorAttachments; // at least 8? -} XGL_PHYSICAL_GPU_PROPERTIES; +} VK_PHYSICAL_GPU_PROPERTIES; -typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE +typedef struct _VK_PHYSICAL_GPU_PERFORMANCE { float maxGpuClock; float aluPerClock; float texPerClock; float primsPerClock; float pixelsPerClock; -} XGL_PHYSICAL_GPU_PERFORMANCE; +} VK_PHYSICAL_GPU_PERFORMANCE; -typedef struct _XGL_GPU_COMPATIBILITY_INFO +typedef struct _VK_GPU_COMPATIBILITY_INFO { - XGL_FLAGS compatibilityFlags; // XGL_GPU_COMPATIBILITY_FLAGS -} XGL_GPU_COMPATIBILITY_INFO; + VK_FLAGS compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS +} VK_GPU_COMPATIBILITY_INFO; -typedef struct _XGL_APPLICATION_INFO +typedef struct _VK_APPLICATION_INFO { - XGL_STRUCTURE_TYPE sType; // Type of structure. Should be XGL_STRUCTURE_TYPE_APPLICATION_INFO + VK_STRUCTURE_TYPE sType; // Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO const void* pNext; // Next structure in chain const char* pAppName; uint32_t appVersion; const char* pEngineName; uint32_t engineVersion; uint32_t apiVersion; -} XGL_APPLICATION_INFO; +} VK_APPLICATION_INFO; -typedef void* (XGLAPI *XGL_ALLOC_FUNCTION)( +typedef void* (VKAPI *VK_ALLOC_FUNCTION)( void* pUserData, size_t size, size_t alignment, - XGL_SYSTEM_ALLOC_TYPE allocType); + VK_SYSTEM_ALLOC_TYPE allocType); -typedef void (XGLAPI *XGL_FREE_FUNCTION)( +typedef void (VKAPI *VK_FREE_FUNCTION)( void* pUserData, void* pMem); -typedef struct _XGL_ALLOC_CALLBACKS +typedef struct _VK_ALLOC_CALLBACKS { void* pUserData; - XGL_ALLOC_FUNCTION pfnAlloc; - XGL_FREE_FUNCTION pfnFree; -} XGL_ALLOC_CALLBACKS; + VK_ALLOC_FUNCTION pfnAlloc; + VK_FREE_FUNCTION pfnFree; +} VK_ALLOC_CALLBACKS; -typedef struct _XGL_DEVICE_QUEUE_CREATE_INFO +typedef struct _VK_DEVICE_QUEUE_CREATE_INFO { uint32_t queueNodeIndex; uint32_t queueCount; -} XGL_DEVICE_QUEUE_CREATE_INFO; +} VK_DEVICE_QUEUE_CREATE_INFO; -typedef struct _XGL_DEVICE_CREATE_INFO +typedef struct _VK_DEVICE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t queueRecordCount; - const XGL_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues; + const VK_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues; uint32_t extensionCount; const char*const* ppEnabledExtensionNames; - XGL_VALIDATION_LEVEL maxValidationLevel; - XGL_FLAGS flags; // XGL_DEVICE_CREATE_FLAGS -} XGL_DEVICE_CREATE_INFO; + VK_VALIDATION_LEVEL maxValidationLevel; + VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS +} VK_DEVICE_CREATE_INFO; -typedef struct _XGL_INSTANCE_CREATE_INFO +typedef struct _VK_INSTANCE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO const void* pNext; // Pointer to next structure - const XGL_APPLICATION_INFO* pAppInfo; - const XGL_ALLOC_CALLBACKS* pAllocCb; + const VK_APPLICATION_INFO* pAppInfo; + const VK_ALLOC_CALLBACKS* pAllocCb; uint32_t extensionCount; const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled -} XGL_INSTANCE_CREATE_INFO; +} VK_INSTANCE_CREATE_INFO; -// can be added to XGL_DEVICE_CREATE_INFO or XGL_INSTANCE_CREATE_INFO via pNext -typedef struct _XGL_LAYER_CREATE_INFO +// can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext +typedef struct _VK_LAYER_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t layerCount; - const char *const* ppActiveLayerNames; // layer name from the layer's xglEnumerateLayers()) -} XGL_LAYER_CREATE_INFO; + const char *const* ppActiveLayerNames; // layer name from the layer's vkEnumerateLayers()) +} VK_LAYER_CREATE_INFO; -typedef struct _XGL_PHYSICAL_GPU_QUEUE_PROPERTIES +typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES { - XGL_FLAGS queueFlags; // XGL_QUEUE_FLAGS + VK_FLAGS queueFlags; // VK_QUEUE_FLAGS uint32_t queueCount; uint32_t maxAtomicCounters; bool32_t supportsTimestamps; uint32_t maxMemReferences; // Tells how many memory references can be active for the given queue -} XGL_PHYSICAL_GPU_QUEUE_PROPERTIES; +} VK_PHYSICAL_GPU_QUEUE_PROPERTIES; -typedef struct _XGL_PHYSICAL_GPU_MEMORY_PROPERTIES +typedef struct _VK_PHYSICAL_GPU_MEMORY_PROPERTIES { bool32_t supportsMigration; bool32_t supportsPinning; -} XGL_PHYSICAL_GPU_MEMORY_PROPERTIES; +} VK_PHYSICAL_GPU_MEMORY_PROPERTIES; -typedef struct _XGL_MEMORY_ALLOC_INFO +typedef struct _VK_MEMORY_ALLOC_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO const void* pNext; // Pointer to next structure - XGL_GPU_SIZE allocationSize; // Size of memory allocation - XGL_FLAGS memProps; // XGL_MEMORY_PROPERTY_FLAGS - XGL_MEMORY_TYPE memType; - XGL_MEMORY_PRIORITY memPriority; -} XGL_MEMORY_ALLOC_INFO; + VK_GPU_SIZE allocationSize; // Size of memory allocation + VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS + VK_MEMORY_TYPE memType; + VK_MEMORY_PRIORITY memPriority; +} VK_MEMORY_ALLOC_INFO; -// This structure is included in the XGL_MEMORY_ALLOC_INFO chain +// This structure is included in the VK_MEMORY_ALLOC_INFO chain // for memory regions allocated for buffer usage. -typedef struct _XGL_MEMORY_ALLOC_BUFFER_INFO +typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO const void* pNext; // Pointer to next structure - XGL_FLAGS usage; // XGL_BUFFER_USAGE_FLAGS -} XGL_MEMORY_ALLOC_BUFFER_INFO; + VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS +} VK_MEMORY_ALLOC_BUFFER_INFO; -// This structure is included in the XGL_MEMORY_ALLOC_INFO chain +// This structure is included in the VK_MEMORY_ALLOC_INFO chain // for memory regions allocated for image usage. -typedef struct _XGL_MEMORY_ALLOC_IMAGE_INFO +typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO const void* pNext; // Pointer to next structure - XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS - XGL_IMAGE_FORMAT_CLASS formatClass; + VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS + VK_IMAGE_FORMAT_CLASS formatClass; uint32_t samples; -} XGL_MEMORY_ALLOC_IMAGE_INFO; +} VK_MEMORY_ALLOC_IMAGE_INFO; -typedef struct _XGL_MEMORY_OPEN_INFO +typedef struct _VK_MEMORY_OPEN_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO const void* pNext; // Pointer to next structure - XGL_GPU_MEMORY sharedMem; -} XGL_MEMORY_OPEN_INFO; + VK_GPU_MEMORY sharedMem; +} VK_MEMORY_OPEN_INFO; -typedef struct _XGL_PEER_MEMORY_OPEN_INFO +typedef struct _VK_PEER_MEMORY_OPEN_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO const void* pNext; // Pointer to next structure - XGL_GPU_MEMORY originalMem; -} XGL_PEER_MEMORY_OPEN_INFO; + VK_GPU_MEMORY originalMem; +} VK_PEER_MEMORY_OPEN_INFO; -typedef struct _XGL_MEMORY_REQUIREMENTS +typedef struct _VK_MEMORY_REQUIREMENTS { - XGL_GPU_SIZE size; // Specified in bytes - XGL_GPU_SIZE alignment; // Specified in bytes - XGL_GPU_SIZE granularity; // Granularity on which xglBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) - XGL_FLAGS memProps; // XGL_MEMORY_PROPERTY_FLAGS - XGL_MEMORY_TYPE memType; -} XGL_MEMORY_REQUIREMENTS; + VK_GPU_SIZE size; // Specified in bytes + VK_GPU_SIZE alignment; // Specified in bytes + VK_GPU_SIZE granularity; // Granularity on which vkBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) + VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS + VK_MEMORY_TYPE memType; +} VK_MEMORY_REQUIREMENTS; -typedef struct _XGL_BUFFER_MEMORY_REQUIREMENTS +typedef struct _VK_BUFFER_MEMORY_REQUIREMENTS { - XGL_FLAGS usage; // XGL_BUFFER_USAGE_FLAGS -} XGL_BUFFER_MEMORY_REQUIREMENTS; + VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS +} VK_BUFFER_MEMORY_REQUIREMENTS; -typedef struct _XGL_IMAGE_MEMORY_REQUIREMENTS +typedef struct _VK_IMAGE_MEMORY_REQUIREMENTS { - XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS - XGL_IMAGE_FORMAT_CLASS formatClass; + VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS + VK_IMAGE_FORMAT_CLASS formatClass; uint32_t samples; -} XGL_IMAGE_MEMORY_REQUIREMENTS; +} VK_IMAGE_MEMORY_REQUIREMENTS; -typedef struct _XGL_FORMAT_PROPERTIES +typedef struct _VK_FORMAT_PROPERTIES { - XGL_FLAGS linearTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS - XGL_FLAGS optimalTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS -} XGL_FORMAT_PROPERTIES; + VK_FLAGS linearTilingFeatures; // VK_FORMAT_FEATURE_FLAGS + VK_FLAGS optimalTilingFeatures; // VK_FORMAT_FEATURE_FLAGS +} VK_FORMAT_PROPERTIES; -typedef struct _XGL_BUFFER_VIEW_ATTACH_INFO +typedef struct _VK_BUFFER_VIEW_ATTACH_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO const void* pNext; // Pointer to next structure - XGL_BUFFER_VIEW view; -} XGL_BUFFER_VIEW_ATTACH_INFO; + VK_BUFFER_VIEW view; +} VK_BUFFER_VIEW_ATTACH_INFO; -typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO +typedef struct _VK_IMAGE_VIEW_ATTACH_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO const void* pNext; // Pointer to next structure - XGL_IMAGE_VIEW view; - XGL_IMAGE_LAYOUT layout; -} XGL_IMAGE_VIEW_ATTACH_INFO; + VK_IMAGE_VIEW view; + VK_IMAGE_LAYOUT layout; +} VK_IMAGE_VIEW_ATTACH_INFO; -typedef struct _XGL_UPDATE_SAMPLERS +typedef struct _VK_UPDATE_SAMPLERS { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLERS const void* pNext; // Pointer to next structure uint32_t binding; // Binding of the sampler (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const XGL_SAMPLER* pSamplers; -} XGL_UPDATE_SAMPLERS; + const VK_SAMPLER* pSamplers; +} VK_UPDATE_SAMPLERS; -typedef struct _XGL_SAMPLER_IMAGE_VIEW_INFO +typedef struct _VK_SAMPLER_IMAGE_VIEW_INFO { - XGL_SAMPLER sampler; - const XGL_IMAGE_VIEW_ATTACH_INFO* pImageView; -} XGL_SAMPLER_IMAGE_VIEW_INFO; + VK_SAMPLER sampler; + const VK_IMAGE_VIEW_ATTACH_INFO* pImageView; +} VK_SAMPLER_IMAGE_VIEW_INFO; -typedef struct _XGL_UPDATE_SAMPLER_TEXTURES +typedef struct _VK_UPDATE_SAMPLER_TEXTURES { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES const void* pNext; // Pointer to next structure uint32_t binding; // Binding of the combined texture sampler (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const XGL_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews; -} XGL_UPDATE_SAMPLER_TEXTURES; + const VK_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews; +} VK_UPDATE_SAMPLER_TEXTURES; -typedef struct _XGL_UPDATE_IMAGES +typedef struct _VK_UPDATE_IMAGES { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_UPDATE_IMAGES + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES const void* pNext; // Pointer to next structure - XGL_DESCRIPTOR_TYPE descriptorType; + VK_DESCRIPTOR_TYPE descriptorType; uint32_t binding; // Binding of the image (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews; -} XGL_UPDATE_IMAGES; + const VK_IMAGE_VIEW_ATTACH_INFO* pImageViews; +} VK_UPDATE_IMAGES; -typedef struct _XGL_UPDATE_BUFFERS +typedef struct _VK_UPDATE_BUFFERS { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_UPDATE_BUFFERS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS const void* pNext; // Pointer to next structure - XGL_DESCRIPTOR_TYPE descriptorType; + VK_DESCRIPTOR_TYPE descriptorType; uint32_t binding; // Binding of the buffer (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews; -} XGL_UPDATE_BUFFERS; + const VK_BUFFER_VIEW_ATTACH_INFO* pBufferViews; +} VK_UPDATE_BUFFERS; -typedef struct _XGL_UPDATE_AS_COPY +typedef struct _VK_UPDATE_AS_COPY { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_UPDATE_AS_COPY + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY const void* pNext; // Pointer to next structure - XGL_DESCRIPTOR_TYPE descriptorType; - XGL_DESCRIPTOR_SET descriptorSet; + VK_DESCRIPTOR_TYPE descriptorType; + VK_DESCRIPTOR_SET descriptorSet; uint32_t binding; uint32_t arrayElement; uint32_t count; -} XGL_UPDATE_AS_COPY; +} VK_UPDATE_AS_COPY; -typedef struct _XGL_BUFFER_CREATE_INFO +typedef struct _VK_BUFFER_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO const void* pNext; // Pointer to next structure. - XGL_GPU_SIZE size; // Specified in bytes - XGL_FLAGS usage; // XGL_BUFFER_USAGE_FLAGS - XGL_FLAGS flags; // XGL_BUFFER_CREATE_FLAGS -} XGL_BUFFER_CREATE_INFO; + VK_GPU_SIZE size; // Specified in bytes + VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS + VK_FLAGS flags; // VK_BUFFER_CREATE_FLAGS +} VK_BUFFER_CREATE_INFO; -typedef struct _XGL_BUFFER_VIEW_CREATE_INFO +typedef struct _VK_BUFFER_VIEW_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure. - XGL_BUFFER buffer; - XGL_BUFFER_VIEW_TYPE viewType; - XGL_FORMAT format; // Optionally specifies format of elements - XGL_GPU_SIZE offset; // Specified in bytes - XGL_GPU_SIZE range; // View size specified in bytes -} XGL_BUFFER_VIEW_CREATE_INFO; + VK_BUFFER buffer; + VK_BUFFER_VIEW_TYPE viewType; + VK_FORMAT format; // Optionally specifies format of elements + VK_GPU_SIZE offset; // Specified in bytes + VK_GPU_SIZE range; // View size specified in bytes +} VK_BUFFER_VIEW_CREATE_INFO; -typedef struct _XGL_IMAGE_SUBRESOURCE +typedef struct _VK_IMAGE_SUBRESOURCE { - XGL_IMAGE_ASPECT aspect; + VK_IMAGE_ASPECT aspect; uint32_t mipLevel; uint32_t arraySlice; -} XGL_IMAGE_SUBRESOURCE; +} VK_IMAGE_SUBRESOURCE; -typedef struct _XGL_IMAGE_SUBRESOURCE_RANGE +typedef struct _VK_IMAGE_SUBRESOURCE_RANGE { - XGL_IMAGE_ASPECT aspect; + VK_IMAGE_ASPECT aspect; uint32_t baseMipLevel; uint32_t mipLevels; uint32_t baseArraySlice; uint32_t arraySize; -} XGL_IMAGE_SUBRESOURCE_RANGE; +} VK_IMAGE_SUBRESOURCE_RANGE; -typedef struct _XGL_EVENT_WAIT_INFO +typedef struct _VK_EVENT_WAIT_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_WAIT_INFO const void* pNext; // Pointer to next structure. uint32_t eventCount; // Number of events to wait on - const XGL_EVENT* pEvents; // Array of event objects to wait on + const VK_EVENT* pEvents; // Array of event objects to wait on - XGL_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen + VK_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen uint32_t memBarrierCount; // Number of memory barriers - const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either XGL_MEMORY_BARRIER, XGL_BUFFER_MEMORY_BARRIER, or XGL_IMAGE_MEMORY_BARRIER) -} XGL_EVENT_WAIT_INFO; + const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) +} VK_EVENT_WAIT_INFO; -typedef struct _XGL_PIPELINE_BARRIER +typedef struct _VK_PIPELINE_BARRIER { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_BARRIER + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_BARRIER const void* pNext; // Pointer to next structure. uint32_t eventCount; // Number of events to wait on - const XGL_PIPE_EVENT* pEvents; // Array of pipeline events to wait on + const VK_PIPE_EVENT* pEvents; // Array of pipeline events to wait on - XGL_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen + VK_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen uint32_t memBarrierCount; // Number of memory barriers - const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either XGL_MEMORY_BARRIER, XGL_BUFFER_MEMORY_BARRIER, or XGL_IMAGE_MEMORY_BARRIER) -} XGL_PIPELINE_BARRIER; + const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) +} VK_PIPELINE_BARRIER; -typedef struct _XGL_MEMORY_BARRIER +typedef struct _VK_MEMORY_BARRIER { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_BARRIER + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - XGL_FLAGS outputMask; // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS) - XGL_FLAGS inputMask; // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS) -} XGL_MEMORY_BARRIER; + VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS) + VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS) +} VK_MEMORY_BARRIER; -typedef struct _XGL_BUFFER_MEMORY_BARRIER +typedef struct _VK_BUFFER_MEMORY_BARRIER { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - XGL_FLAGS outputMask; // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS) - XGL_FLAGS inputMask; // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS) + VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS) + VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS) - XGL_BUFFER buffer; // Buffer to sync + VK_BUFFER buffer; // Buffer to sync - XGL_GPU_SIZE offset; // Offset within the buffer to sync - XGL_GPU_SIZE size; // Amount of bytes to sync -} XGL_BUFFER_MEMORY_BARRIER; + VK_GPU_SIZE offset; // Offset within the buffer to sync + VK_GPU_SIZE size; // Amount of bytes to sync +} VK_BUFFER_MEMORY_BARRIER; -typedef struct _XGL_IMAGE_MEMORY_BARRIER +typedef struct _VK_IMAGE_MEMORY_BARRIER { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - XGL_FLAGS outputMask; // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS) - XGL_FLAGS inputMask; // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS) + VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS) + VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS) - XGL_IMAGE_LAYOUT oldLayout; // Current layout of the image - XGL_IMAGE_LAYOUT newLayout; // New layout to transition the image to + VK_IMAGE_LAYOUT oldLayout; // Current layout of the image + VK_IMAGE_LAYOUT newLayout; // New layout to transition the image to - XGL_IMAGE image; // Image to sync + VK_IMAGE image; // Image to sync - XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync -} XGL_IMAGE_MEMORY_BARRIER; + VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync +} VK_IMAGE_MEMORY_BARRIER; -typedef struct _XGL_IMAGE_CREATE_INFO +typedef struct _VK_IMAGE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO const void* pNext; // Pointer to next structure. - XGL_IMAGE_TYPE imageType; - XGL_FORMAT format; - XGL_EXTENT3D extent; + VK_IMAGE_TYPE imageType; + VK_FORMAT format; + VK_EXTENT3D extent; uint32_t mipLevels; uint32_t arraySize; uint32_t samples; - XGL_IMAGE_TILING tiling; - XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS - XGL_FLAGS flags; // XGL_IMAGE_CREATE_FLAGS -} XGL_IMAGE_CREATE_INFO; + VK_IMAGE_TILING tiling; + VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS + VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS +} VK_IMAGE_CREATE_INFO; -typedef struct _XGL_PEER_IMAGE_OPEN_INFO +typedef struct _VK_PEER_IMAGE_OPEN_INFO { - XGL_IMAGE originalImage; -} XGL_PEER_IMAGE_OPEN_INFO; + VK_IMAGE originalImage; +} VK_PEER_IMAGE_OPEN_INFO; -typedef struct _XGL_SUBRESOURCE_LAYOUT +typedef struct _VK_SUBRESOURCE_LAYOUT { - XGL_GPU_SIZE offset; // Specified in bytes - XGL_GPU_SIZE size; // Specified in bytes - XGL_GPU_SIZE rowPitch; // Specified in bytes - XGL_GPU_SIZE depthPitch; // Specified in bytes -} XGL_SUBRESOURCE_LAYOUT; + VK_GPU_SIZE offset; // Specified in bytes + VK_GPU_SIZE size; // Specified in bytes + VK_GPU_SIZE rowPitch; // Specified in bytes + VK_GPU_SIZE depthPitch; // Specified in bytes +} VK_SUBRESOURCE_LAYOUT; -typedef struct _XGL_IMAGE_VIEW_CREATE_INFO +typedef struct _VK_IMAGE_VIEW_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_IMAGE image; - XGL_IMAGE_VIEW_TYPE viewType; - XGL_FORMAT format; - XGL_CHANNEL_MAPPING channels; - XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange; + VK_IMAGE image; + VK_IMAGE_VIEW_TYPE viewType; + VK_FORMAT format; + VK_CHANNEL_MAPPING channels; + VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; float minLod; -} XGL_IMAGE_VIEW_CREATE_INFO; +} VK_IMAGE_VIEW_CREATE_INFO; -typedef struct _XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO +typedef struct _VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_IMAGE image; - XGL_FORMAT format; + VK_IMAGE image; + VK_FORMAT format; uint32_t mipLevel; uint32_t baseArraySlice; uint32_t arraySize; - XGL_IMAGE msaaResolveImage; - XGL_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; -} XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO; + VK_IMAGE msaaResolveImage; + VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; +} VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO; -typedef struct _XGL_DEPTH_STENCIL_VIEW_CREATE_INFO +typedef struct _VK_DEPTH_STENCIL_VIEW_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_IMAGE image; + VK_IMAGE image; uint32_t mipLevel; uint32_t baseArraySlice; uint32_t arraySize; - XGL_IMAGE msaaResolveImage; - XGL_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; - XGL_FLAGS flags; // XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS -} XGL_DEPTH_STENCIL_VIEW_CREATE_INFO; + VK_IMAGE msaaResolveImage; + VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; + VK_FLAGS flags; // VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS +} VK_DEPTH_STENCIL_VIEW_CREATE_INFO; -typedef struct _XGL_COLOR_ATTACHMENT_BIND_INFO +typedef struct _VK_COLOR_ATTACHMENT_BIND_INFO { - XGL_COLOR_ATTACHMENT_VIEW view; - XGL_IMAGE_LAYOUT layout; -} XGL_COLOR_ATTACHMENT_BIND_INFO; + VK_COLOR_ATTACHMENT_VIEW view; + VK_IMAGE_LAYOUT layout; +} VK_COLOR_ATTACHMENT_BIND_INFO; -typedef struct _XGL_DEPTH_STENCIL_BIND_INFO +typedef struct _VK_DEPTH_STENCIL_BIND_INFO { - XGL_DEPTH_STENCIL_VIEW view; - XGL_IMAGE_LAYOUT layout; -} XGL_DEPTH_STENCIL_BIND_INFO; + VK_DEPTH_STENCIL_VIEW view; + VK_IMAGE_LAYOUT layout; +} VK_DEPTH_STENCIL_BIND_INFO; -typedef struct _XGL_BUFFER_COPY +typedef struct _VK_BUFFER_COPY { - XGL_GPU_SIZE srcOffset; // Specified in bytes - XGL_GPU_SIZE destOffset; // Specified in bytes - XGL_GPU_SIZE copySize; // Specified in bytes -} XGL_BUFFER_COPY; + VK_GPU_SIZE srcOffset; // Specified in bytes + VK_GPU_SIZE destOffset; // Specified in bytes + VK_GPU_SIZE copySize; // Specified in bytes +} VK_BUFFER_COPY; -typedef struct _XGL_IMAGE_MEMORY_BIND_INFO +typedef struct _VK_IMAGE_MEMORY_BIND_INFO { - XGL_IMAGE_SUBRESOURCE subresource; - XGL_OFFSET3D offset; - XGL_EXTENT3D extent; -} XGL_IMAGE_MEMORY_BIND_INFO; + VK_IMAGE_SUBRESOURCE subresource; + VK_OFFSET3D offset; + VK_EXTENT3D extent; +} VK_IMAGE_MEMORY_BIND_INFO; -typedef struct _XGL_IMAGE_COPY +typedef struct _VK_IMAGE_COPY { - XGL_IMAGE_SUBRESOURCE srcSubresource; - XGL_OFFSET3D srcOffset; - XGL_IMAGE_SUBRESOURCE destSubresource; - XGL_OFFSET3D destOffset; - XGL_EXTENT3D extent; -} XGL_IMAGE_COPY; + VK_IMAGE_SUBRESOURCE srcSubresource; + VK_OFFSET3D srcOffset; + VK_IMAGE_SUBRESOURCE destSubresource; + VK_OFFSET3D destOffset; + VK_EXTENT3D extent; +} VK_IMAGE_COPY; -typedef struct _XGL_IMAGE_BLIT +typedef struct _VK_IMAGE_BLIT { - XGL_IMAGE_SUBRESOURCE srcSubresource; - XGL_OFFSET3D srcOffset; - XGL_EXTENT3D srcExtent; - XGL_IMAGE_SUBRESOURCE destSubresource; - XGL_OFFSET3D destOffset; - XGL_EXTENT3D destExtent; -} XGL_IMAGE_BLIT; + VK_IMAGE_SUBRESOURCE srcSubresource; + VK_OFFSET3D srcOffset; + VK_EXTENT3D srcExtent; + VK_IMAGE_SUBRESOURCE destSubresource; + VK_OFFSET3D destOffset; + VK_EXTENT3D destExtent; +} VK_IMAGE_BLIT; -typedef struct _XGL_BUFFER_IMAGE_COPY +typedef struct _VK_BUFFER_IMAGE_COPY { - XGL_GPU_SIZE bufferOffset; // Specified in bytes - XGL_IMAGE_SUBRESOURCE imageSubresource; - XGL_OFFSET3D imageOffset; - XGL_EXTENT3D imageExtent; -} XGL_BUFFER_IMAGE_COPY; + VK_GPU_SIZE bufferOffset; // Specified in bytes + VK_IMAGE_SUBRESOURCE imageSubresource; + VK_OFFSET3D imageOffset; + VK_EXTENT3D imageExtent; +} VK_BUFFER_IMAGE_COPY; -typedef struct _XGL_IMAGE_RESOLVE +typedef struct _VK_IMAGE_RESOLVE { - XGL_IMAGE_SUBRESOURCE srcSubresource; - XGL_OFFSET2D srcOffset; - XGL_IMAGE_SUBRESOURCE destSubresource; - XGL_OFFSET2D destOffset; - XGL_EXTENT2D extent; -} XGL_IMAGE_RESOLVE; + VK_IMAGE_SUBRESOURCE srcSubresource; + VK_OFFSET2D srcOffset; + VK_IMAGE_SUBRESOURCE destSubresource; + VK_OFFSET2D destOffset; + VK_EXTENT2D extent; +} VK_IMAGE_RESOLVE; -typedef struct _XGL_SHADER_CREATE_INFO +typedef struct _VK_SHADER_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO const void* pNext; // Pointer to next structure size_t codeSize; // Specified in bytes const void* pCode; - XGL_FLAGS flags; // Reserved -} XGL_SHADER_CREATE_INFO; + VK_FLAGS flags; // Reserved +} VK_SHADER_CREATE_INFO; -typedef struct _XGL_DESCRIPTOR_SET_LAYOUT_BINDING +typedef struct _VK_DESCRIPTOR_SET_LAYOUT_BINDING { - XGL_DESCRIPTOR_TYPE descriptorType; + VK_DESCRIPTOR_TYPE descriptorType; uint32_t count; - XGL_FLAGS stageFlags; // XGL_SHADER_STAGE_FLAGS - const XGL_SAMPLER* pImmutableSamplers; -} XGL_DESCRIPTOR_SET_LAYOUT_BINDING; + VK_FLAGS stageFlags; // VK_SHADER_STAGE_FLAGS + const VK_SAMPLER* pImmutableSamplers; +} VK_DESCRIPTOR_SET_LAYOUT_BINDING; -typedef struct _XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO +typedef struct _VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t count; // Number of bindings in the descriptor set layout - const XGL_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings -} XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + const VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings +} VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; -typedef struct _XGL_DESCRIPTOR_TYPE_COUNT +typedef struct _VK_DESCRIPTOR_TYPE_COUNT { - XGL_DESCRIPTOR_TYPE type; + VK_DESCRIPTOR_TYPE type; uint32_t count; -} XGL_DESCRIPTOR_TYPE_COUNT; +} VK_DESCRIPTOR_TYPE_COUNT; -typedef struct _XGL_DESCRIPTOR_POOL_CREATE_INFO +typedef struct _VK_DESCRIPTOR_POOL_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t count; - const XGL_DESCRIPTOR_TYPE_COUNT* pTypeCount; -} XGL_DESCRIPTOR_POOL_CREATE_INFO; + const VK_DESCRIPTOR_TYPE_COUNT* pTypeCount; +} VK_DESCRIPTOR_POOL_CREATE_INFO; -typedef struct _XGL_LINK_CONST_BUFFER +typedef struct _VK_LINK_CONST_BUFFER { uint32_t bufferId; size_t bufferSize; const void* pBufferData; -} XGL_LINK_CONST_BUFFER; +} VK_LINK_CONST_BUFFER; -typedef struct _XGL_SPECIALIZATION_MAP_ENTRY +typedef struct _VK_SPECIALIZATION_MAP_ENTRY { uint32_t constantId; // The SpecConstant ID specified in the BIL uint32_t offset; // Offset of the value in the data block -} XGL_SPECIALIZATION_MAP_ENTRY; +} VK_SPECIALIZATION_MAP_ENTRY; -typedef struct _XGL_SPECIALIZATION_INFO +typedef struct _VK_SPECIALIZATION_INFO { uint32_t mapEntryCount; - const XGL_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries + const VK_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries const void* pData; -} XGL_SPECIALIZATION_INFO; +} VK_SPECIALIZATION_INFO; -typedef struct _XGL_PIPELINE_SHADER +typedef struct _VK_PIPELINE_SHADER { - XGL_PIPELINE_SHADER_STAGE stage; - XGL_SHADER shader; + VK_PIPELINE_SHADER_STAGE stage; + VK_SHADER shader; uint32_t linkConstBufferCount; - const XGL_LINK_CONST_BUFFER* pLinkConstBufferInfo; - const XGL_SPECIALIZATION_INFO* pSpecializationInfo; -} XGL_PIPELINE_SHADER; + const VK_LINK_CONST_BUFFER* pLinkConstBufferInfo; + const VK_SPECIALIZATION_INFO* pSpecializationInfo; +} VK_PIPELINE_SHADER; -typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO +typedef struct _VK_COMPUTE_PIPELINE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_PIPELINE_SHADER cs; - XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS - XGL_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; // For local size fields zero is treated an invalid value + VK_PIPELINE_SHADER cs; + VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS + VK_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; // For local size fields zero is treated an invalid value uint32_t localSizeX; uint32_t localSizeY; uint32_t localSizeZ; -} XGL_COMPUTE_PIPELINE_CREATE_INFO; +} VK_COMPUTE_PIPELINE_CREATE_INFO; -typedef struct _XGL_VERTEX_INPUT_BINDING_DESCRIPTION +typedef struct _VK_VERTEX_INPUT_BINDING_DESCRIPTION { uint32_t binding; // Vertex buffer binding id uint32_t strideInBytes; // Distance between vertices in bytes (0 = no advancement) - XGL_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented -} XGL_VERTEX_INPUT_BINDING_DESCRIPTION; + VK_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented +} VK_VERTEX_INPUT_BINDING_DESCRIPTION; -typedef struct _XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION +typedef struct _VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION { uint32_t location; // location of the shader vertex attrib uint32_t binding; // Vertex buffer binding id - XGL_FORMAT format; // format of source data + VK_FORMAT format; // format of source data uint32_t offsetInBytes; // Offset of first element in bytes from base of vertex -} XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION; +} VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION; -typedef struct _XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO +typedef struct _VK_PIPELINE_VERTEX_INPUT_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t bindingCount; // number of bindings - const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; + const VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; uint32_t attributeCount; // number of attributes - const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; -} XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO; + const VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; +} VK_PIPELINE_VERTEX_INPUT_CREATE_INFO; -typedef struct _XGL_PIPELINE_IA_STATE_CREATE_INFO +typedef struct _VK_PIPELINE_IA_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_PRIMITIVE_TOPOLOGY topology; + VK_PRIMITIVE_TOPOLOGY topology; bool32_t disableVertexReuse; // optional bool32_t primitiveRestartEnable; uint32_t primitiveRestartIndex; // optional (GL45) -} XGL_PIPELINE_IA_STATE_CREATE_INFO; +} VK_PIPELINE_IA_STATE_CREATE_INFO; -typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO +typedef struct _VK_PIPELINE_TESS_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t patchControlPoints; -} XGL_PIPELINE_TESS_STATE_CREATE_INFO; +} VK_PIPELINE_TESS_STATE_CREATE_INFO; -typedef struct _XGL_PIPELINE_VP_STATE_CREATE_INFO +typedef struct _VK_PIPELINE_VP_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t numViewports; - XGL_COORDINATE_ORIGIN clipOrigin; // optional (GL45) - XGL_DEPTH_MODE depthMode; // optional (GL45) -} XGL_PIPELINE_VP_STATE_CREATE_INFO; + VK_COORDINATE_ORIGIN clipOrigin; // optional (GL45) + VK_DEPTH_MODE depthMode; // optional (GL45) +} VK_PIPELINE_VP_STATE_CREATE_INFO; -typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO +typedef struct _VK_PIPELINE_RS_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure bool32_t depthClipEnable; bool32_t rasterizerDiscardEnable; bool32_t programPointSize; // optional (GL45) - XGL_COORDINATE_ORIGIN pointOrigin; // optional (GL45) - XGL_PROVOKING_VERTEX_CONVENTION provokingVertex; // optional (GL45) - XGL_FILL_MODE fillMode; // optional (GL45) - XGL_CULL_MODE cullMode; - XGL_FACE_ORIENTATION frontFace; -} XGL_PIPELINE_RS_STATE_CREATE_INFO; + VK_COORDINATE_ORIGIN pointOrigin; // optional (GL45) + VK_PROVOKING_VERTEX_CONVENTION provokingVertex; // optional (GL45) + VK_FILL_MODE fillMode; // optional (GL45) + VK_CULL_MODE cullMode; + VK_FACE_ORIENTATION frontFace; +} VK_PIPELINE_RS_STATE_CREATE_INFO; -typedef struct _XGL_PIPELINE_MS_STATE_CREATE_INFO +typedef struct _VK_PIPELINE_MS_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t samples; bool32_t multisampleEnable; // optional (GL45) bool32_t sampleShadingEnable; // optional (GL45) float minSampleShading; // optional (GL45) - XGL_SAMPLE_MASK sampleMask; -} XGL_PIPELINE_MS_STATE_CREATE_INFO; + VK_SAMPLE_MASK sampleMask; +} VK_PIPELINE_MS_STATE_CREATE_INFO; -typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE +typedef struct _VK_PIPELINE_CB_ATTACHMENT_STATE { bool32_t blendEnable; - XGL_FORMAT format; - XGL_BLEND srcBlendColor; - XGL_BLEND destBlendColor; - XGL_BLEND_FUNC blendFuncColor; - XGL_BLEND srcBlendAlpha; - XGL_BLEND destBlendAlpha; - XGL_BLEND_FUNC blendFuncAlpha; + VK_FORMAT format; + VK_BLEND srcBlendColor; + VK_BLEND destBlendColor; + VK_BLEND_FUNC blendFuncColor; + VK_BLEND srcBlendAlpha; + VK_BLEND destBlendAlpha; + VK_BLEND_FUNC blendFuncAlpha; uint8_t channelWriteMask; -} XGL_PIPELINE_CB_ATTACHMENT_STATE; +} VK_PIPELINE_CB_ATTACHMENT_STATE; -typedef struct _XGL_PIPELINE_CB_STATE_CREATE_INFO +typedef struct _VK_PIPELINE_CB_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO const void* pNext; // Pointer to next structure bool32_t alphaToCoverageEnable; bool32_t logicOpEnable; - XGL_LOGIC_OP logicOp; + VK_LOGIC_OP logicOp; uint32_t attachmentCount; // # of pAttachments - const XGL_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; -} XGL_PIPELINE_CB_STATE_CREATE_INFO; + const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; +} VK_PIPELINE_CB_STATE_CREATE_INFO; -typedef struct _XGL_STENCIL_OP_STATE +typedef struct _VK_STENCIL_OP_STATE { - XGL_STENCIL_OP stencilFailOp; - XGL_STENCIL_OP stencilPassOp; - XGL_STENCIL_OP stencilDepthFailOp; - XGL_COMPARE_FUNC stencilFunc; -} XGL_STENCIL_OP_STATE; + VK_STENCIL_OP stencilFailOp; + VK_STENCIL_OP stencilPassOp; + VK_STENCIL_OP stencilDepthFailOp; + VK_COMPARE_FUNC stencilFunc; +} VK_STENCIL_OP_STATE; -typedef struct _XGL_PIPELINE_DS_STATE_CREATE_INFO +typedef struct _VK_PIPELINE_DS_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_FORMAT format; + VK_FORMAT format; bool32_t depthTestEnable; bool32_t depthWriteEnable; - XGL_COMPARE_FUNC depthFunc; + VK_COMPARE_FUNC depthFunc; bool32_t depthBoundsEnable; // optional (depth_bounds_test) bool32_t stencilTestEnable; - XGL_STENCIL_OP_STATE front; - XGL_STENCIL_OP_STATE back; -} XGL_PIPELINE_DS_STATE_CREATE_INFO; + VK_STENCIL_OP_STATE front; + VK_STENCIL_OP_STATE back; +} VK_PIPELINE_DS_STATE_CREATE_INFO; -typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO +typedef struct _VK_PIPELINE_SHADER_STAGE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_PIPELINE_SHADER shader; -} XGL_PIPELINE_SHADER_STAGE_CREATE_INFO; + VK_PIPELINE_SHADER shader; +} VK_PIPELINE_SHADER_STAGE_CREATE_INFO; -typedef struct _XGL_GRAPHICS_PIPELINE_CREATE_INFO +typedef struct _VK_GRAPHICS_PIPELINE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS - XGL_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain; -} XGL_GRAPHICS_PIPELINE_CREATE_INFO; + VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS + VK_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain; +} VK_GRAPHICS_PIPELINE_CREATE_INFO; -typedef struct _XGL_SAMPLER_CREATE_INFO +typedef struct _VK_SAMPLER_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_TEX_FILTER magFilter; // Filter mode for magnification - XGL_TEX_FILTER minFilter; // Filter mode for minifiation - XGL_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode - XGL_TEX_ADDRESS addressU; - XGL_TEX_ADDRESS addressV; - XGL_TEX_ADDRESS addressW; + VK_TEX_FILTER magFilter; // Filter mode for magnification + VK_TEX_FILTER minFilter; // Filter mode for minifiation + VK_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode + VK_TEX_ADDRESS addressU; + VK_TEX_ADDRESS addressV; + VK_TEX_ADDRESS addressW; float mipLodBias; uint32_t maxAnisotropy; - XGL_COMPARE_FUNC compareFunc; + VK_COMPARE_FUNC compareFunc; float minLod; float maxLod; - XGL_BORDER_COLOR_TYPE borderColorType; -} XGL_SAMPLER_CREATE_INFO; + VK_BORDER_COLOR_TYPE borderColorType; +} VK_SAMPLER_CREATE_INFO; -typedef struct _XGL_DYNAMIC_VP_STATE_CREATE_INFO +typedef struct _VK_DYNAMIC_VP_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t viewportAndScissorCount; // number of entries in pViewports and pScissors - const XGL_VIEWPORT* pViewports; - const XGL_RECT* pScissors; -} XGL_DYNAMIC_VP_STATE_CREATE_INFO; + const VK_VIEWPORT* pViewports; + const VK_RECT* pScissors; +} VK_DYNAMIC_VP_STATE_CREATE_INFO; -typedef struct _XGL_DYNAMIC_RS_STATE_CREATE_INFO +typedef struct _VK_DYNAMIC_RS_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure float depthBias; float depthBiasClamp; @@ -2082,18 +2082,18 @@ typedef struct _XGL_DYNAMIC_RS_STATE_CREATE_INFO float pointSize; // optional (GL45) - Size of points float pointFadeThreshold; // optional (GL45) - Size of point fade threshold float lineWidth; // optional (GL45) - Width of lines -} XGL_DYNAMIC_RS_STATE_CREATE_INFO; +} VK_DYNAMIC_RS_STATE_CREATE_INFO; -typedef struct _XGL_DYNAMIC_CB_STATE_CREATE_INFO +typedef struct _VK_DYNAMIC_CB_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO const void* pNext; // Pointer to next structure float blendConst[4]; -} XGL_DYNAMIC_CB_STATE_CREATE_INFO; +} VK_DYNAMIC_CB_STATE_CREATE_INFO; -typedef struct _XGL_DYNAMIC_DS_STATE_CREATE_INFO +typedef struct _VK_DYNAMIC_DS_STATE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure float minDepth; // optional (depth_bounds_test) float maxDepth; // optional (depth_bounds_test) @@ -2101,106 +2101,106 @@ typedef struct _XGL_DYNAMIC_DS_STATE_CREATE_INFO uint32_t stencilWriteMask; uint32_t stencilFrontRef; uint32_t stencilBackRef; -} XGL_DYNAMIC_DS_STATE_CREATE_INFO; +} VK_DYNAMIC_DS_STATE_CREATE_INFO; -typedef struct _XGL_CMD_BUFFER_CREATE_INFO +typedef struct _VK_CMD_BUFFER_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t queueNodeIndex; - XGL_FLAGS flags; -} XGL_CMD_BUFFER_CREATE_INFO; + VK_FLAGS flags; +} VK_CMD_BUFFER_CREATE_INFO; -typedef struct _XGL_CMD_BUFFER_BEGIN_INFO +typedef struct _VK_CMD_BUFFER_BEGIN_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO const void* pNext; // Pointer to next structure - XGL_FLAGS flags; // XGL_CMD_BUFFER_BUILD_FLAGS -} XGL_CMD_BUFFER_BEGIN_INFO; + VK_FLAGS flags; // VK_CMD_BUFFER_BUILD_FLAGS +} VK_CMD_BUFFER_BEGIN_INFO; -typedef struct _XGL_RENDER_PASS_BEGIN +typedef struct _VK_RENDER_PASS_BEGIN { - XGL_RENDER_PASS renderPass; - XGL_FRAMEBUFFER framebuffer; -} XGL_RENDER_PASS_BEGIN; + VK_RENDER_PASS renderPass; + VK_FRAMEBUFFER framebuffer; +} VK_RENDER_PASS_BEGIN; -typedef struct _XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO +typedef struct _VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO const void* pNext; // Pointer to next structure - XGL_RENDER_PASS_BEGIN renderPassContinue; // Only needed when a render pass is split across two command buffers -} XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO; + VK_RENDER_PASS_BEGIN renderPassContinue; // Only needed when a render pass is split across two command buffers +} VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO; // Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared. -typedef union _XGL_CLEAR_COLOR_VALUE +typedef union _VK_CLEAR_COLOR_VALUE { float floatColor[4]; uint32_t rawColor[4]; -} XGL_CLEAR_COLOR_VALUE; +} VK_CLEAR_COLOR_VALUE; -typedef struct _XGL_CLEAR_COLOR +typedef struct _VK_CLEAR_COLOR { - XGL_CLEAR_COLOR_VALUE color; + VK_CLEAR_COLOR_VALUE color; bool32_t useRawValue; -} XGL_CLEAR_COLOR; +} VK_CLEAR_COLOR; -typedef struct _XGL_RENDER_PASS_CREATE_INFO +typedef struct _VK_RENDER_PASS_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_RECT renderArea; + VK_RECT renderArea; uint32_t colorAttachmentCount; - XGL_EXTENT2D extent; + VK_EXTENT2D extent; uint32_t sampleCount; uint32_t layers; - const XGL_FORMAT* pColorFormats; - const XGL_IMAGE_LAYOUT* pColorLayouts; - const XGL_ATTACHMENT_LOAD_OP* pColorLoadOps; - const XGL_ATTACHMENT_STORE_OP* pColorStoreOps; - const XGL_CLEAR_COLOR* pColorLoadClearValues; - XGL_FORMAT depthStencilFormat; - XGL_IMAGE_LAYOUT depthStencilLayout; - XGL_ATTACHMENT_LOAD_OP depthLoadOp; + const VK_FORMAT* pColorFormats; + const VK_IMAGE_LAYOUT* pColorLayouts; + const VK_ATTACHMENT_LOAD_OP* pColorLoadOps; + const VK_ATTACHMENT_STORE_OP* pColorStoreOps; + const VK_CLEAR_COLOR* pColorLoadClearValues; + VK_FORMAT depthStencilFormat; + VK_IMAGE_LAYOUT depthStencilLayout; + VK_ATTACHMENT_LOAD_OP depthLoadOp; float depthLoadClearValue; - XGL_ATTACHMENT_STORE_OP depthStoreOp; - XGL_ATTACHMENT_LOAD_OP stencilLoadOp; + VK_ATTACHMENT_STORE_OP depthStoreOp; + VK_ATTACHMENT_LOAD_OP stencilLoadOp; uint32_t stencilLoadClearValue; - XGL_ATTACHMENT_STORE_OP stencilStoreOp; -} XGL_RENDER_PASS_CREATE_INFO; + VK_ATTACHMENT_STORE_OP stencilStoreOp; +} VK_RENDER_PASS_CREATE_INFO; -typedef struct _XGL_EVENT_CREATE_INFO +typedef struct _VK_EVENT_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_FLAGS flags; // Reserved -} XGL_EVENT_CREATE_INFO; + VK_FLAGS flags; // Reserved +} VK_EVENT_CREATE_INFO; -typedef struct _XGL_FENCE_CREATE_INFO +typedef struct _VK_FENCE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_FENCE_CREATE_FLAGS flags; // XGL_FENCE_CREATE_FLAGS -} XGL_FENCE_CREATE_INFO; + VK_FENCE_CREATE_FLAGS flags; // VK_FENCE_CREATE_FLAGS +} VK_FENCE_CREATE_INFO; -typedef struct _XGL_SEMAPHORE_CREATE_INFO +typedef struct _VK_SEMAPHORE_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t initialCount; - XGL_FLAGS flags; // XGL_SEMAPHORE_CREATE_FLAGS -} XGL_SEMAPHORE_CREATE_INFO; + VK_FLAGS flags; // VK_SEMAPHORE_CREATE_FLAGS +} VK_SEMAPHORE_CREATE_INFO; -typedef struct _XGL_SEMAPHORE_OPEN_INFO +typedef struct _VK_SEMAPHORE_OPEN_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO const void* pNext; // Pointer to next structure - XGL_SEMAPHORE sharedSemaphore; -} XGL_SEMAPHORE_OPEN_INFO; + VK_SEMAPHORE sharedSemaphore; +} VK_SEMAPHORE_OPEN_INFO; -typedef struct _XGL_PIPELINE_STATISTICS_DATA +typedef struct _VK_PIPELINE_STATISTICS_DATA { uint64_t fsInvocations; // Fragment shader invocations uint64_t cPrimitives; // Clipper primitives @@ -2213,219 +2213,219 @@ typedef struct _XGL_PIPELINE_STATISTICS_DATA uint64_t tcsInvocations; // Tessellation control shader invocations uint64_t tesInvocations; // Tessellation evaluation shader invocations uint64_t csInvocations; // Compute shader invocations -} XGL_PIPELINE_STATISTICS_DATA; +} VK_PIPELINE_STATISTICS_DATA; -typedef struct _XGL_QUERY_POOL_CREATE_INFO +typedef struct _VK_QUERY_POOL_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_QUERY_TYPE queryType; + VK_QUERY_TYPE queryType; uint32_t slots; -} XGL_QUERY_POOL_CREATE_INFO; +} VK_QUERY_POOL_CREATE_INFO; -typedef struct _XGL_FRAMEBUFFER_CREATE_INFO +typedef struct _VK_FRAMEBUFFER_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t colorAttachmentCount; - const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments; - const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment; + const VK_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments; + const VK_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment; uint32_t sampleCount; uint32_t width; uint32_t height; uint32_t layers; -} XGL_FRAMEBUFFER_CREATE_INFO; +} VK_FRAMEBUFFER_CREATE_INFO; -typedef struct _XGL_DRAW_INDIRECT_CMD +typedef struct _VK_DRAW_INDIRECT_CMD { uint32_t vertexCount; uint32_t instanceCount; uint32_t firstVertex; uint32_t firstInstance; -} XGL_DRAW_INDIRECT_CMD; +} VK_DRAW_INDIRECT_CMD; -typedef struct _XGL_DRAW_INDEXED_INDIRECT_CMD +typedef struct _VK_DRAW_INDEXED_INDIRECT_CMD { uint32_t indexCount; uint32_t instanceCount; uint32_t firstIndex; int32_t vertexOffset; uint32_t firstInstance; -} XGL_DRAW_INDEXED_INDIRECT_CMD; +} VK_DRAW_INDEXED_INDIRECT_CMD; -typedef struct _XGL_DISPATCH_INDIRECT_CMD +typedef struct _VK_DISPATCH_INDIRECT_CMD { uint32_t x; uint32_t y; uint32_t z; -} XGL_DISPATCH_INDIRECT_CMD; +} VK_DISPATCH_INDIRECT_CMD; // ------------------------------------------------------------------------------------------------ // API functions -typedef XGL_RESULT (XGLAPI *xglCreateInstanceType)(const XGL_INSTANCE_CREATE_INFO* pCreateInfo, XGL_INSTANCE* pInstance); -typedef XGL_RESULT (XGLAPI *xglDestroyInstanceType)(XGL_INSTANCE instance); -typedef XGL_RESULT (XGLAPI *xglEnumerateGpusType)(XGL_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, XGL_PHYSICAL_GPU* pGpus); -typedef XGL_RESULT (XGLAPI *xglGetGpuInfoType)(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef void * (XGLAPI *xglGetProcAddrType)(XGL_PHYSICAL_GPU gpu, const char * pName); -typedef XGL_RESULT (XGLAPI *xglCreateDeviceType)(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice); -typedef XGL_RESULT (XGLAPI *xglDestroyDeviceType)(XGL_DEVICE device); -typedef XGL_RESULT (XGLAPI *xglGetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const char* pExtName); -typedef XGL_RESULT (XGLAPI *xglEnumerateLayersType)(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved); -typedef XGL_RESULT (XGLAPI *xglGetDeviceQueueType)(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue); -typedef XGL_RESULT (XGLAPI *xglQueueSubmitType)(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence); -typedef XGL_RESULT (XGLAPI *xglQueueAddMemReferenceType)(XGL_QUEUE queue, XGL_GPU_MEMORY mem); -typedef XGL_RESULT (XGLAPI *xglQueueRemoveMemReferenceType)(XGL_QUEUE queue, XGL_GPU_MEMORY mem); -typedef XGL_RESULT (XGLAPI *xglQueueWaitIdleType)(XGL_QUEUE queue); -typedef XGL_RESULT (XGLAPI *xglDeviceWaitIdleType)(XGL_DEVICE device); -typedef XGL_RESULT (XGLAPI *xglAllocMemoryType)(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem); -typedef XGL_RESULT (XGLAPI *xglFreeMemoryType)(XGL_GPU_MEMORY mem); -typedef XGL_RESULT (XGLAPI *xglSetMemoryPriorityType)(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority); -typedef XGL_RESULT (XGLAPI *xglMapMemoryType)(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData); -typedef XGL_RESULT (XGLAPI *xglUnmapMemoryType)(XGL_GPU_MEMORY mem); -typedef XGL_RESULT (XGLAPI *xglPinSystemMemoryType)(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem); -typedef XGL_RESULT (XGLAPI *xglGetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo); -typedef XGL_RESULT (XGLAPI *xglOpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem); -typedef XGL_RESULT (XGLAPI *xglOpenSharedSemaphoreType)(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore); -typedef XGL_RESULT (XGLAPI *xglOpenPeerMemoryType)(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem); -typedef XGL_RESULT (XGLAPI *xglOpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem); -typedef XGL_RESULT (XGLAPI *xglDestroyObjectType)(XGL_OBJECT object); -typedef XGL_RESULT (XGLAPI *xglGetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset); -typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_SIZE rangeOffset,XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset); -typedef XGL_RESULT (XGLAPI *xglBindImageMemoryRangeType)(XGL_IMAGE image, uint32_t allocationIdx, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset); -typedef XGL_RESULT (XGLAPI *xglCreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence); -typedef XGL_RESULT (XGLAPI *xglResetFencesType)(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences); -typedef XGL_RESULT (XGLAPI *xglGetFenceStatusType)(XGL_FENCE fence); -typedef XGL_RESULT (XGLAPI *xglWaitForFencesType)(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout); -typedef XGL_RESULT (XGLAPI *xglCreateSemaphoreType)(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore); -typedef XGL_RESULT (XGLAPI *xglQueueSignalSemaphoreType)(XGL_QUEUE queue, XGL_SEMAPHORE semaphore); -typedef XGL_RESULT (XGLAPI *xglQueueWaitSemaphoreType)(XGL_QUEUE queue, XGL_SEMAPHORE semaphore); -typedef XGL_RESULT (XGLAPI *xglCreateEventType)(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent); -typedef XGL_RESULT (XGLAPI *xglGetEventStatusType)(XGL_EVENT event); -typedef XGL_RESULT (XGLAPI *xglSetEventType)(XGL_EVENT event); -typedef XGL_RESULT (XGLAPI *xglResetEventType)(XGL_EVENT event); -typedef XGL_RESULT (XGLAPI *xglCreateQueryPoolType)(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool); -typedef XGL_RESULT (XGLAPI *xglGetQueryPoolResultsType)(XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData); -typedef XGL_RESULT (XGLAPI *xglGetFormatInfoType)(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef XGL_RESULT (XGLAPI *xglCreateBufferType)(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer); -typedef XGL_RESULT (XGLAPI *xglCreateBufferViewType)(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView); -typedef XGL_RESULT (XGLAPI *xglCreateImageType)(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage); -typedef XGL_RESULT (XGLAPI *xglGetImageSubresourceInfoType)(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef XGL_RESULT (XGLAPI *xglCreateImageViewType)(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView); -typedef XGL_RESULT (XGLAPI *xglCreateColorAttachmentViewType)(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView); -typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilViewType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView); -typedef XGL_RESULT (XGLAPI *xglCreateShaderType)(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader); -typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline); -typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineDerivativeType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline); -typedef XGL_RESULT (XGLAPI *xglCreateComputePipelineType)(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline); -typedef XGL_RESULT (XGLAPI *xglStorePipelineType)(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData); -typedef XGL_RESULT (XGLAPI *xglLoadPipelineType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline); -typedef XGL_RESULT (XGLAPI *xglLoadPipelineDerivativeType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline); -typedef XGL_RESULT (XGLAPI *xglCreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler); -typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetLayoutType)(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout); -typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetLayoutChainType)(XGL_DEVICE device, uint32_t setLayoutArrayCount, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); -typedef XGL_RESULT (XGLAPI *xglBeginDescriptorPoolUpdateType)(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode); -typedef XGL_RESULT (XGLAPI *xglEndDescriptorPoolUpdateType)(XGL_DEVICE device, XGL_CMD_BUFFER cmd); -typedef XGL_RESULT (XGLAPI *xglCreateDescriptorPoolType)(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool); -typedef XGL_RESULT (XGLAPI *xglResetDescriptorPoolType)(XGL_DESCRIPTOR_POOL descriptorPool); -typedef XGL_RESULT (XGLAPI *xglAllocDescriptorSetsType)(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount); -typedef void (XGLAPI *xglClearDescriptorSetsType)(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets); -typedef void (XGLAPI *xglUpdateDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray); -typedef XGL_RESULT (XGLAPI *xglCreateDynamicViewportStateType)(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState); -typedef XGL_RESULT (XGLAPI *xglCreateDynamicRasterStateType)(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState); -typedef XGL_RESULT (XGLAPI *xglCreateDynamicColorBlendStateType)(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState); -typedef XGL_RESULT (XGLAPI *xglCreateDynamicDepthStencilStateType)(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState); -typedef XGL_RESULT (XGLAPI *xglCreateCommandBufferType)(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer); -typedef XGL_RESULT (XGLAPI *xglBeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo); -typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer); -typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer); -typedef void (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline); -typedef void (XGLAPI *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state); -typedef void (XGLAPI *xglCmdBindDescriptorSetsType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData); -typedef void (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType); -typedef void (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding); -typedef void (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); -typedef void (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); -typedef void (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride); -typedef void (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride); -typedef void (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -typedef void (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset); -typedef void (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions); -typedef void (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions); -typedef void (XGLAPI *xglCmdBlitImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions); -typedef void (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions); -typedef void (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions); -typedef void (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout); -typedef void (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData); -typedef void (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data); -typedef void (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges); -typedef void (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges); -typedef void (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects); -typedef void (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent); -typedef void (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent); -typedef void (XGLAPI *xglCmdWaitEventsType)(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo); -typedef void (XGLAPI *xglCmdPipelineBarrierType)(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier); -typedef void (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags); -typedef void (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot); -typedef void (XGLAPI *xglCmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount); -typedef void (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset); -typedef void (XGLAPI *xglCmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); -typedef void (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset); -typedef void (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset); -typedef XGL_RESULT (XGLAPI *xglCreateFramebufferType)(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer); -typedef XGL_RESULT (XGLAPI *xglCreateRenderPassType)(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass); -typedef void (XGLAPI *xglCmdBeginRenderPassType)(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN* pRenderPassBegin); -typedef void (XGLAPI *xglCmdEndRenderPassType)(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass); - -#ifdef XGL_PROTOTYPES +typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance); +typedef VK_RESULT (VKAPI *vkDestroyInstanceType)(VK_INSTANCE instance); +typedef VK_RESULT (VKAPI *vkEnumerateGpusType)(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus); +typedef VK_RESULT (VKAPI *vkGetGpuInfoType)(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData); +typedef void * (VKAPI *vkGetProcAddrType)(VK_PHYSICAL_GPU gpu, const char * pName); +typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice); +typedef VK_RESULT (VKAPI *vkDestroyDeviceType)(VK_DEVICE device); +typedef VK_RESULT (VKAPI *vkGetExtensionSupportType)(VK_PHYSICAL_GPU gpu, const char* pExtName); +typedef VK_RESULT (VKAPI *vkEnumerateLayersType)(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved); +typedef VK_RESULT (VKAPI *vkGetDeviceQueueType)(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue); +typedef VK_RESULT (VKAPI *vkQueueSubmitType)(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence); +typedef VK_RESULT (VKAPI *vkQueueAddMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem); +typedef VK_RESULT (VKAPI *vkQueueRemoveMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem); +typedef VK_RESULT (VKAPI *vkQueueWaitIdleType)(VK_QUEUE queue); +typedef VK_RESULT (VKAPI *vkDeviceWaitIdleType)(VK_DEVICE device); +typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem); +typedef VK_RESULT (VKAPI *vkFreeMemoryType)(VK_GPU_MEMORY mem); +typedef VK_RESULT (VKAPI *vkSetMemoryPriorityType)(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority); +typedef VK_RESULT (VKAPI *vkMapMemoryType)(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData); +typedef VK_RESULT (VKAPI *vkUnmapMemoryType)(VK_GPU_MEMORY mem); +typedef VK_RESULT (VKAPI *vkPinSystemMemoryType)(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem); +typedef VK_RESULT (VKAPI *vkGetMultiGpuCompatibilityType)(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo); +typedef VK_RESULT (VKAPI *vkOpenSharedMemoryType)(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem); +typedef VK_RESULT (VKAPI *vkOpenSharedSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore); +typedef VK_RESULT (VKAPI *vkOpenPeerMemoryType)(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem); +typedef VK_RESULT (VKAPI *vkOpenPeerImageType)(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem); +typedef VK_RESULT (VKAPI *vkDestroyObjectType)(VK_OBJECT object); +typedef VK_RESULT (VKAPI *vkGetObjectInfoType)(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData); +typedef VK_RESULT (VKAPI *vkBindObjectMemoryType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset); +typedef VK_RESULT (VKAPI *vkBindObjectMemoryRangeType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset,VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset); +typedef VK_RESULT (VKAPI *vkBindImageMemoryRangeType)(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset); +typedef VK_RESULT (VKAPI *vkCreateFenceType)(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence); +typedef VK_RESULT (VKAPI *vkResetFencesType)(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences); +typedef VK_RESULT (VKAPI *vkGetFenceStatusType)(VK_FENCE fence); +typedef VK_RESULT (VKAPI *vkWaitForFencesType)(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout); +typedef VK_RESULT (VKAPI *vkCreateSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore); +typedef VK_RESULT (VKAPI *vkQueueSignalSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore); +typedef VK_RESULT (VKAPI *vkQueueWaitSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore); +typedef VK_RESULT (VKAPI *vkCreateEventType)(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent); +typedef VK_RESULT (VKAPI *vkGetEventStatusType)(VK_EVENT event); +typedef VK_RESULT (VKAPI *vkSetEventType)(VK_EVENT event); +typedef VK_RESULT (VKAPI *vkResetEventType)(VK_EVENT event); +typedef VK_RESULT (VKAPI *vkCreateQueryPoolType)(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool); +typedef VK_RESULT (VKAPI *vkGetQueryPoolResultsType)(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData); +typedef VK_RESULT (VKAPI *vkGetFormatInfoType)(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData); +typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer); +typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView); +typedef VK_RESULT (VKAPI *vkCreateImageType)(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage); +typedef VK_RESULT (VKAPI *vkGetImageSubresourceInfoType)(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData); +typedef VK_RESULT (VKAPI *vkCreateImageViewType)(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView); +typedef VK_RESULT (VKAPI *vkCreateColorAttachmentViewType)(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView); +typedef VK_RESULT (VKAPI *vkCreateDepthStencilViewType)(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView); +typedef VK_RESULT (VKAPI *vkCreateShaderType)(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader); +typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline); +typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineDerivativeType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline); +typedef VK_RESULT (VKAPI *vkCreateComputePipelineType)(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline); +typedef VK_RESULT (VKAPI *vkStorePipelineType)(VK_PIPELINE pipeline, size_t* pDataSize, void* pData); +typedef VK_RESULT (VKAPI *vkLoadPipelineType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline); +typedef VK_RESULT (VKAPI *vkLoadPipelineDerivativeType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline); +typedef VK_RESULT (VKAPI *vkCreateSamplerType)(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler); +typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutType)(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); +typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutChainType)(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); +typedef VK_RESULT (VKAPI *vkBeginDescriptorPoolUpdateType)(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode); +typedef VK_RESULT (VKAPI *vkEndDescriptorPoolUpdateType)(VK_DEVICE device, VK_CMD_BUFFER cmd); +typedef VK_RESULT (VKAPI *vkCreateDescriptorPoolType)(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool); +typedef VK_RESULT (VKAPI *vkResetDescriptorPoolType)(VK_DESCRIPTOR_POOL descriptorPool); +typedef VK_RESULT (VKAPI *vkAllocDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount); +typedef void (VKAPI *vkClearDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets); +typedef void (VKAPI *vkUpdateDescriptorsType)(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray); +typedef VK_RESULT (VKAPI *vkCreateDynamicViewportStateType)(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState); +typedef VK_RESULT (VKAPI *vkCreateDynamicRasterStateType)(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState); +typedef VK_RESULT (VKAPI *vkCreateDynamicColorBlendStateType)(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState); +typedef VK_RESULT (VKAPI *vkCreateDynamicDepthStencilStateType)(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState); +typedef VK_RESULT (VKAPI *vkCreateCommandBufferType)(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer); +typedef VK_RESULT (VKAPI *vkBeginCommandBufferType)(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); +typedef VK_RESULT (VKAPI *vkEndCommandBufferType)(VK_CMD_BUFFER cmdBuffer); +typedef VK_RESULT (VKAPI *vkResetCommandBufferType)(VK_CMD_BUFFER cmdBuffer); +typedef void (VKAPI *vkCmdBindPipelineType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline); +typedef void (VKAPI *vkCmdBindDynamicStateObjectType)(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state); +typedef void (VKAPI *vkCmdBindDescriptorSetsType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData); +typedef void (VKAPI *vkCmdBindIndexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType); +typedef void (VKAPI *vkCmdBindVertexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding); +typedef void (VKAPI *vkCmdDrawType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *vkCmdDrawIndexedType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *vkCmdDrawIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *vkCmdDrawIndexedIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *vkCmdDispatchType)(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z); +typedef void (VKAPI *vkCmdDispatchIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset); +typedef void (VKAPI *vkCmdCopyBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions); +typedef void (VKAPI *vkCmdCopyImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions); +typedef void (VKAPI *vkCmdBlitImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions); +typedef void (VKAPI *vkCmdCopyBufferToImageType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions); +typedef void (VKAPI *vkCmdCopyImageToBufferType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions); +typedef void (VKAPI *vkCmdCloneImageDataType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout); +typedef void (VKAPI *vkCmdUpdateBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData); +typedef void (VKAPI *vkCmdFillBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data); +typedef void (VKAPI *vkCmdClearColorImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); +typedef void (VKAPI *vkCmdClearDepthStencilType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); +typedef void (VKAPI *vkCmdResolveImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects); +typedef void (VKAPI *vkCmdSetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent); +typedef void (VKAPI *vkCmdResetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent); +typedef void (VKAPI *vkCmdWaitEventsType)(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo); +typedef void (VKAPI *vkCmdPipelineBarrierType)(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier); +typedef void (VKAPI *vkCmdBeginQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags); +typedef void (VKAPI *vkCmdEndQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot); +typedef void (VKAPI *vkCmdResetQueryPoolType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount); +typedef void (VKAPI *vkCmdWriteTimestampType)(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset); +typedef void (VKAPI *vkCmdInitAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); +typedef void (VKAPI *vkCmdLoadAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset); +typedef void (VKAPI *vkCmdSaveAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset); +typedef VK_RESULT (VKAPI *vkCreateFramebufferType)(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer); +typedef VK_RESULT (VKAPI *vkCreateRenderPassType)(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass); +typedef void (VKAPI *vkCmdBeginRenderPassType)(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin); +typedef void (VKAPI *vkCmdEndRenderPassType)(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass); + +#ifdef VK_PROTOTYPES // GPU initialization -XGL_RESULT XGLAPI xglCreateInstance( - const XGL_INSTANCE_CREATE_INFO* pCreateInfo, - XGL_INSTANCE* pInstance); +VK_RESULT VKAPI vkCreateInstance( + const VK_INSTANCE_CREATE_INFO* pCreateInfo, + VK_INSTANCE* pInstance); -XGL_RESULT XGLAPI xglDestroyInstance( - XGL_INSTANCE instance); +VK_RESULT VKAPI vkDestroyInstance( + VK_INSTANCE instance); -XGL_RESULT XGLAPI xglEnumerateGpus( - XGL_INSTANCE instance, +VK_RESULT VKAPI vkEnumerateGpus( + VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, - XGL_PHYSICAL_GPU* pGpus); + VK_PHYSICAL_GPU* pGpus); -XGL_RESULT XGLAPI xglGetGpuInfo( - XGL_PHYSICAL_GPU gpu, - XGL_PHYSICAL_GPU_INFO_TYPE infoType, +VK_RESULT VKAPI vkGetGpuInfo( + VK_PHYSICAL_GPU gpu, + VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData); -void * XGLAPI xglGetProcAddr( - XGL_PHYSICAL_GPU gpu, +void * VKAPI vkGetProcAddr( + VK_PHYSICAL_GPU gpu, const char* pName); // Device functions -XGL_RESULT XGLAPI xglCreateDevice( - XGL_PHYSICAL_GPU gpu, - const XGL_DEVICE_CREATE_INFO* pCreateInfo, - XGL_DEVICE* pDevice); +VK_RESULT VKAPI vkCreateDevice( + VK_PHYSICAL_GPU gpu, + const VK_DEVICE_CREATE_INFO* pCreateInfo, + VK_DEVICE* pDevice); -XGL_RESULT XGLAPI xglDestroyDevice( - XGL_DEVICE device); +VK_RESULT VKAPI vkDestroyDevice( + VK_DEVICE device); // Extension discovery functions -XGL_RESULT XGLAPI xglGetExtensionSupport( - XGL_PHYSICAL_GPU gpu, +VK_RESULT VKAPI vkGetExtensionSupport( + VK_PHYSICAL_GPU gpu, const char* pExtName); // Layer discovery functions -XGL_RESULT XGLAPI xglEnumerateLayers( - XGL_PHYSICAL_GPU gpu, +VK_RESULT VKAPI vkEnumerateLayers( + VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, @@ -2434,182 +2434,182 @@ XGL_RESULT XGLAPI xglEnumerateLayers( // Queue functions -XGL_RESULT XGLAPI xglGetDeviceQueue( - XGL_DEVICE device, +VK_RESULT VKAPI vkGetDeviceQueue( + VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, - XGL_QUEUE* pQueue); + VK_QUEUE* pQueue); -XGL_RESULT XGLAPI xglQueueSubmit( - XGL_QUEUE queue, +VK_RESULT VKAPI vkQueueSubmit( + VK_QUEUE queue, uint32_t cmdBufferCount, - const XGL_CMD_BUFFER* pCmdBuffers, - XGL_FENCE fence); + const VK_CMD_BUFFER* pCmdBuffers, + VK_FENCE fence); -XGL_RESULT XGLAPI xglQueueAddMemReference( - XGL_QUEUE queue, - XGL_GPU_MEMORY mem); +VK_RESULT VKAPI vkQueueAddMemReference( + VK_QUEUE queue, + VK_GPU_MEMORY mem); -XGL_RESULT XGLAPI xglQueueRemoveMemReference( - XGL_QUEUE queue, - XGL_GPU_MEMORY mem); +VK_RESULT VKAPI vkQueueRemoveMemReference( + VK_QUEUE queue, + VK_GPU_MEMORY mem); -XGL_RESULT XGLAPI xglQueueWaitIdle( - XGL_QUEUE queue); +VK_RESULT VKAPI vkQueueWaitIdle( + VK_QUEUE queue); -XGL_RESULT XGLAPI xglDeviceWaitIdle( - XGL_DEVICE device); +VK_RESULT VKAPI vkDeviceWaitIdle( + VK_DEVICE device); // Memory functions -XGL_RESULT XGLAPI xglAllocMemory( - XGL_DEVICE device, - const XGL_MEMORY_ALLOC_INFO* pAllocInfo, - XGL_GPU_MEMORY* pMem); +VK_RESULT VKAPI vkAllocMemory( + VK_DEVICE device, + const VK_MEMORY_ALLOC_INFO* pAllocInfo, + VK_GPU_MEMORY* pMem); -XGL_RESULT XGLAPI xglFreeMemory( - XGL_GPU_MEMORY mem); +VK_RESULT VKAPI vkFreeMemory( + VK_GPU_MEMORY mem); -XGL_RESULT XGLAPI xglSetMemoryPriority( - XGL_GPU_MEMORY mem, - XGL_MEMORY_PRIORITY priority); +VK_RESULT VKAPI vkSetMemoryPriority( + VK_GPU_MEMORY mem, + VK_MEMORY_PRIORITY priority); -XGL_RESULT XGLAPI xglMapMemory( - XGL_GPU_MEMORY mem, - XGL_FLAGS flags, // Reserved +VK_RESULT VKAPI vkMapMemory( + VK_GPU_MEMORY mem, + VK_FLAGS flags, // Reserved void** ppData); -XGL_RESULT XGLAPI xglUnmapMemory( - XGL_GPU_MEMORY mem); +VK_RESULT VKAPI vkUnmapMemory( + VK_GPU_MEMORY mem); -XGL_RESULT XGLAPI xglPinSystemMemory( - XGL_DEVICE device, +VK_RESULT VKAPI vkPinSystemMemory( + VK_DEVICE device, const void* pSysMem, size_t memSize, - XGL_GPU_MEMORY* pMem); + VK_GPU_MEMORY* pMem); // Multi-device functions -XGL_RESULT XGLAPI xglGetMultiGpuCompatibility( - XGL_PHYSICAL_GPU gpu0, - XGL_PHYSICAL_GPU gpu1, - XGL_GPU_COMPATIBILITY_INFO* pInfo); +VK_RESULT VKAPI vkGetMultiGpuCompatibility( + VK_PHYSICAL_GPU gpu0, + VK_PHYSICAL_GPU gpu1, + VK_GPU_COMPATIBILITY_INFO* pInfo); -XGL_RESULT XGLAPI xglOpenSharedMemory( - XGL_DEVICE device, - const XGL_MEMORY_OPEN_INFO* pOpenInfo, - XGL_GPU_MEMORY* pMem); +VK_RESULT VKAPI vkOpenSharedMemory( + VK_DEVICE device, + const VK_MEMORY_OPEN_INFO* pOpenInfo, + VK_GPU_MEMORY* pMem); -XGL_RESULT XGLAPI xglOpenSharedSemaphore( - XGL_DEVICE device, - const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, - XGL_SEMAPHORE* pSemaphore); +VK_RESULT VKAPI vkOpenSharedSemaphore( + VK_DEVICE device, + const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, + VK_SEMAPHORE* pSemaphore); -XGL_RESULT XGLAPI xglOpenPeerMemory( - XGL_DEVICE device, - const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, - XGL_GPU_MEMORY* pMem); +VK_RESULT VKAPI vkOpenPeerMemory( + VK_DEVICE device, + const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, + VK_GPU_MEMORY* pMem); -XGL_RESULT XGLAPI xglOpenPeerImage( - XGL_DEVICE device, - const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, - XGL_IMAGE* pImage, - XGL_GPU_MEMORY* pMem); +VK_RESULT VKAPI vkOpenPeerImage( + VK_DEVICE device, + const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, + VK_IMAGE* pImage, + VK_GPU_MEMORY* pMem); // Generic API object functions -XGL_RESULT XGLAPI xglDestroyObject( - XGL_OBJECT object); +VK_RESULT VKAPI vkDestroyObject( + VK_OBJECT object); -XGL_RESULT XGLAPI xglGetObjectInfo( - XGL_BASE_OBJECT object, - XGL_OBJECT_INFO_TYPE infoType, +VK_RESULT VKAPI vkGetObjectInfo( + VK_BASE_OBJECT object, + VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData); -XGL_RESULT XGLAPI xglBindObjectMemory( - XGL_OBJECT object, +VK_RESULT VKAPI vkBindObjectMemory( + VK_OBJECT object, uint32_t allocationIdx, - XGL_GPU_MEMORY mem, - XGL_GPU_SIZE memOffset); + VK_GPU_MEMORY mem, + VK_GPU_SIZE memOffset); -XGL_RESULT XGLAPI xglBindObjectMemoryRange( - XGL_OBJECT object, +VK_RESULT VKAPI vkBindObjectMemoryRange( + VK_OBJECT object, uint32_t allocationIdx, - XGL_GPU_SIZE rangeOffset, - XGL_GPU_SIZE rangeSize, - XGL_GPU_MEMORY mem, - XGL_GPU_SIZE memOffset); + VK_GPU_SIZE rangeOffset, + VK_GPU_SIZE rangeSize, + VK_GPU_MEMORY mem, + VK_GPU_SIZE memOffset); -XGL_RESULT XGLAPI xglBindImageMemoryRange( - XGL_IMAGE image, +VK_RESULT VKAPI vkBindImageMemoryRange( + VK_IMAGE image, uint32_t allocationIdx, - const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, - XGL_GPU_MEMORY mem, - XGL_GPU_SIZE memOffset); + const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, + VK_GPU_MEMORY mem, + VK_GPU_SIZE memOffset); // Fence functions -XGL_RESULT XGLAPI xglCreateFence( - XGL_DEVICE device, - const XGL_FENCE_CREATE_INFO* pCreateInfo, - XGL_FENCE* pFence); +VK_RESULT VKAPI vkCreateFence( + VK_DEVICE device, + const VK_FENCE_CREATE_INFO* pCreateInfo, + VK_FENCE* pFence); -XGL_RESULT XGLAPI xglResetFences( - XGL_DEVICE device, +VK_RESULT VKAPI vkResetFences( + VK_DEVICE device, uint32_t fenceCount, - XGL_FENCE* pFences); + VK_FENCE* pFences); -XGL_RESULT XGLAPI xglGetFenceStatus( - XGL_FENCE fence); +VK_RESULT VKAPI vkGetFenceStatus( + VK_FENCE fence); -XGL_RESULT XGLAPI xglWaitForFences( - XGL_DEVICE device, +VK_RESULT VKAPI vkWaitForFences( + VK_DEVICE device, uint32_t fenceCount, - const XGL_FENCE* pFences, + const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout); // timeout in nanoseconds // Queue semaphore functions -XGL_RESULT XGLAPI xglCreateSemaphore( - XGL_DEVICE device, - const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, - XGL_SEMAPHORE* pSemaphore); +VK_RESULT VKAPI vkCreateSemaphore( + VK_DEVICE device, + const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, + VK_SEMAPHORE* pSemaphore); -XGL_RESULT XGLAPI xglQueueSignalSemaphore( - XGL_QUEUE queue, - XGL_SEMAPHORE semaphore); +VK_RESULT VKAPI vkQueueSignalSemaphore( + VK_QUEUE queue, + VK_SEMAPHORE semaphore); -XGL_RESULT XGLAPI xglQueueWaitSemaphore( - XGL_QUEUE queue, - XGL_SEMAPHORE semaphore); +VK_RESULT VKAPI vkQueueWaitSemaphore( + VK_QUEUE queue, + VK_SEMAPHORE semaphore); // Event functions -XGL_RESULT XGLAPI xglCreateEvent( - XGL_DEVICE device, - const XGL_EVENT_CREATE_INFO* pCreateInfo, - XGL_EVENT* pEvent); +VK_RESULT VKAPI vkCreateEvent( + VK_DEVICE device, + const VK_EVENT_CREATE_INFO* pCreateInfo, + VK_EVENT* pEvent); -XGL_RESULT XGLAPI xglGetEventStatus( - XGL_EVENT event); +VK_RESULT VKAPI vkGetEventStatus( + VK_EVENT event); -XGL_RESULT XGLAPI xglSetEvent( - XGL_EVENT event); +VK_RESULT VKAPI vkSetEvent( + VK_EVENT event); -XGL_RESULT XGLAPI xglResetEvent( - XGL_EVENT event); +VK_RESULT VKAPI vkResetEvent( + VK_EVENT event); // Query functions -XGL_RESULT XGLAPI xglCreateQueryPool( - XGL_DEVICE device, - const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, - XGL_QUERY_POOL* pQueryPool); +VK_RESULT VKAPI vkCreateQueryPool( + VK_DEVICE device, + const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, + VK_QUERY_POOL* pQueryPool); -XGL_RESULT XGLAPI xglGetQueryPoolResults( - XGL_QUERY_POOL queryPool, +VK_RESULT VKAPI vkGetQueryPoolResults( + VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, @@ -2617,446 +2617,446 @@ XGL_RESULT XGLAPI xglGetQueryPoolResults( // Format capabilities -XGL_RESULT XGLAPI xglGetFormatInfo( - XGL_DEVICE device, - XGL_FORMAT format, - XGL_FORMAT_INFO_TYPE infoType, +VK_RESULT VKAPI vkGetFormatInfo( + VK_DEVICE device, + VK_FORMAT format, + VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData); // Buffer functions -XGL_RESULT XGLAPI xglCreateBuffer( - XGL_DEVICE device, - const XGL_BUFFER_CREATE_INFO* pCreateInfo, - XGL_BUFFER* pBuffer); +VK_RESULT VKAPI vkCreateBuffer( + VK_DEVICE device, + const VK_BUFFER_CREATE_INFO* pCreateInfo, + VK_BUFFER* pBuffer); // Buffer view functions -XGL_RESULT XGLAPI xglCreateBufferView( - XGL_DEVICE device, - const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, - XGL_BUFFER_VIEW* pView); +VK_RESULT VKAPI vkCreateBufferView( + VK_DEVICE device, + const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, + VK_BUFFER_VIEW* pView); // Image functions -XGL_RESULT XGLAPI xglCreateImage( - XGL_DEVICE device, - const XGL_IMAGE_CREATE_INFO* pCreateInfo, - XGL_IMAGE* pImage); +VK_RESULT VKAPI vkCreateImage( + VK_DEVICE device, + const VK_IMAGE_CREATE_INFO* pCreateInfo, + VK_IMAGE* pImage); -XGL_RESULT XGLAPI xglGetImageSubresourceInfo( - XGL_IMAGE image, - const XGL_IMAGE_SUBRESOURCE* pSubresource, - XGL_SUBRESOURCE_INFO_TYPE infoType, +VK_RESULT VKAPI vkGetImageSubresourceInfo( + VK_IMAGE image, + const VK_IMAGE_SUBRESOURCE* pSubresource, + VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData); // Image view functions -XGL_RESULT XGLAPI xglCreateImageView( - XGL_DEVICE device, - const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, - XGL_IMAGE_VIEW* pView); +VK_RESULT VKAPI vkCreateImageView( + VK_DEVICE device, + const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, + VK_IMAGE_VIEW* pView); -XGL_RESULT XGLAPI xglCreateColorAttachmentView( - XGL_DEVICE device, - const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - XGL_COLOR_ATTACHMENT_VIEW* pView); +VK_RESULT VKAPI vkCreateColorAttachmentView( + VK_DEVICE device, + const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, + VK_COLOR_ATTACHMENT_VIEW* pView); -XGL_RESULT XGLAPI xglCreateDepthStencilView( - XGL_DEVICE device, - const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, - XGL_DEPTH_STENCIL_VIEW* pView); +VK_RESULT VKAPI vkCreateDepthStencilView( + VK_DEVICE device, + const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, + VK_DEPTH_STENCIL_VIEW* pView); // Shader functions -XGL_RESULT XGLAPI xglCreateShader( - XGL_DEVICE device, - const XGL_SHADER_CREATE_INFO* pCreateInfo, - XGL_SHADER* pShader); +VK_RESULT VKAPI vkCreateShader( + VK_DEVICE device, + const VK_SHADER_CREATE_INFO* pCreateInfo, + VK_SHADER* pShader); // Pipeline functions -XGL_RESULT XGLAPI xglCreateGraphicsPipeline( - XGL_DEVICE device, - const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - XGL_PIPELINE* pPipeline); +VK_RESULT VKAPI vkCreateGraphicsPipeline( + VK_DEVICE device, + const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, + VK_PIPELINE* pPipeline); -XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative( - XGL_DEVICE device, - const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - XGL_PIPELINE basePipeline, - XGL_PIPELINE* pPipeline); +VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( + VK_DEVICE device, + const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, + VK_PIPELINE basePipeline, + VK_PIPELINE* pPipeline); -XGL_RESULT XGLAPI xglCreateComputePipeline( - XGL_DEVICE device, - const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, - XGL_PIPELINE* pPipeline); +VK_RESULT VKAPI vkCreateComputePipeline( + VK_DEVICE device, + const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, + VK_PIPELINE* pPipeline); -XGL_RESULT XGLAPI xglStorePipeline( - XGL_PIPELINE pipeline, +VK_RESULT VKAPI vkStorePipeline( + VK_PIPELINE pipeline, size_t* pDataSize, void* pData); -XGL_RESULT XGLAPI xglLoadPipeline( - XGL_DEVICE device, +VK_RESULT VKAPI vkLoadPipeline( + VK_DEVICE device, size_t dataSize, const void* pData, - XGL_PIPELINE* pPipeline); + VK_PIPELINE* pPipeline); -XGL_RESULT XGLAPI xglLoadPipelineDerivative( - XGL_DEVICE device, +VK_RESULT VKAPI vkLoadPipelineDerivative( + VK_DEVICE device, size_t dataSize, const void* pData, - XGL_PIPELINE basePipeline, - XGL_PIPELINE* pPipeline); + VK_PIPELINE basePipeline, + VK_PIPELINE* pPipeline); // Sampler functions -XGL_RESULT XGLAPI xglCreateSampler( - XGL_DEVICE device, - const XGL_SAMPLER_CREATE_INFO* pCreateInfo, - XGL_SAMPLER* pSampler); +VK_RESULT VKAPI vkCreateSampler( + VK_DEVICE device, + const VK_SAMPLER_CREATE_INFO* pCreateInfo, + VK_SAMPLER* pSampler); // Descriptor set functions -XGL_RESULT XGLAPI xglCreateDescriptorSetLayout( - XGL_DEVICE device, - const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, - XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout); +VK_RESULT VKAPI vkCreateDescriptorSetLayout( + VK_DEVICE device, + const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, + VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); -XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain( - XGL_DEVICE device, +VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain( + VK_DEVICE device, uint32_t setLayoutArrayCount, - const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, - XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); + const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, + VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); -XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate( - XGL_DEVICE device, - XGL_DESCRIPTOR_UPDATE_MODE updateMode); +VK_RESULT VKAPI vkBeginDescriptorPoolUpdate( + VK_DEVICE device, + VK_DESCRIPTOR_UPDATE_MODE updateMode); -XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate( - XGL_DEVICE device, - XGL_CMD_BUFFER cmd); +VK_RESULT VKAPI vkEndDescriptorPoolUpdate( + VK_DEVICE device, + VK_CMD_BUFFER cmd); -XGL_RESULT XGLAPI xglCreateDescriptorPool( - XGL_DEVICE device, - XGL_DESCRIPTOR_POOL_USAGE poolUsage, +VK_RESULT VKAPI vkCreateDescriptorPool( + VK_DEVICE device, + VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, - const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, - XGL_DESCRIPTOR_POOL* pDescriptorPool); + const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, + VK_DESCRIPTOR_POOL* pDescriptorPool); -XGL_RESULT XGLAPI xglResetDescriptorPool( - XGL_DESCRIPTOR_POOL descriptorPool); +VK_RESULT VKAPI vkResetDescriptorPool( + VK_DESCRIPTOR_POOL descriptorPool); -XGL_RESULT XGLAPI xglAllocDescriptorSets( - XGL_DESCRIPTOR_POOL descriptorPool, - XGL_DESCRIPTOR_SET_USAGE setUsage, +VK_RESULT VKAPI vkAllocDescriptorSets( + VK_DESCRIPTOR_POOL descriptorPool, + VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, - const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, - XGL_DESCRIPTOR_SET* pDescriptorSets, + const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, + VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount); -void XGLAPI xglClearDescriptorSets( - XGL_DESCRIPTOR_POOL descriptorPool, +void VKAPI vkClearDescriptorSets( + VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, - const XGL_DESCRIPTOR_SET* pDescriptorSets); + const VK_DESCRIPTOR_SET* pDescriptorSets); -void XGLAPI xglUpdateDescriptors( - XGL_DESCRIPTOR_SET descriptorSet, +void VKAPI vkUpdateDescriptors( + VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray); // State object functions -XGL_RESULT XGLAPI xglCreateDynamicViewportState( - XGL_DEVICE device, - const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - XGL_DYNAMIC_VP_STATE_OBJECT* pState); +VK_RESULT VKAPI vkCreateDynamicViewportState( + VK_DEVICE device, + const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_VP_STATE_OBJECT* pState); -XGL_RESULT XGLAPI xglCreateDynamicRasterState( - XGL_DEVICE device, - const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - XGL_DYNAMIC_RS_STATE_OBJECT* pState); +VK_RESULT VKAPI vkCreateDynamicRasterState( + VK_DEVICE device, + const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_RS_STATE_OBJECT* pState); -XGL_RESULT XGLAPI xglCreateDynamicColorBlendState( - XGL_DEVICE device, - const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - XGL_DYNAMIC_CB_STATE_OBJECT* pState); +VK_RESULT VKAPI vkCreateDynamicColorBlendState( + VK_DEVICE device, + const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_CB_STATE_OBJECT* pState); -XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState( - XGL_DEVICE device, - const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, - XGL_DYNAMIC_DS_STATE_OBJECT* pState); +VK_RESULT VKAPI vkCreateDynamicDepthStencilState( + VK_DEVICE device, + const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_DS_STATE_OBJECT* pState); // Command buffer functions -XGL_RESULT XGLAPI xglCreateCommandBuffer( - XGL_DEVICE device, - const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, - XGL_CMD_BUFFER* pCmdBuffer); +VK_RESULT VKAPI vkCreateCommandBuffer( + VK_DEVICE device, + const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, + VK_CMD_BUFFER* pCmdBuffer); -XGL_RESULT XGLAPI xglBeginCommandBuffer( - XGL_CMD_BUFFER cmdBuffer, - const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo); +VK_RESULT VKAPI vkBeginCommandBuffer( + VK_CMD_BUFFER cmdBuffer, + const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); -XGL_RESULT XGLAPI xglEndCommandBuffer( - XGL_CMD_BUFFER cmdBuffer); +VK_RESULT VKAPI vkEndCommandBuffer( + VK_CMD_BUFFER cmdBuffer); -XGL_RESULT XGLAPI xglResetCommandBuffer( - XGL_CMD_BUFFER cmdBuffer); +VK_RESULT VKAPI vkResetCommandBuffer( + VK_CMD_BUFFER cmdBuffer); // Command buffer building functions -void XGLAPI xglCmdBindPipeline( - XGL_CMD_BUFFER cmdBuffer, - XGL_PIPELINE_BIND_POINT pipelineBindPoint, - XGL_PIPELINE pipeline); +void VKAPI vkCmdBindPipeline( + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, + VK_PIPELINE pipeline); -void XGLAPI xglCmdBindDynamicStateObject( - XGL_CMD_BUFFER cmdBuffer, - XGL_STATE_BIND_POINT stateBindPoint, - XGL_DYNAMIC_STATE_OBJECT dynamicState); +void VKAPI vkCmdBindDynamicStateObject( + VK_CMD_BUFFER cmdBuffer, + VK_STATE_BIND_POINT stateBindPoint, + VK_DYNAMIC_STATE_OBJECT dynamicState); -void XGLAPI xglCmdBindDescriptorSets( - XGL_CMD_BUFFER cmdBuffer, - XGL_PIPELINE_BIND_POINT pipelineBindPoint, - XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, +void VKAPI vkCmdBindDescriptorSets( + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, + VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, - const XGL_DESCRIPTOR_SET* pDescriptorSets, + const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData); -void XGLAPI xglCmdBindIndexBuffer( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER buffer, - XGL_GPU_SIZE offset, - XGL_INDEX_TYPE indexType); +void VKAPI vkCmdBindIndexBuffer( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, + VK_INDEX_TYPE indexType); -void XGLAPI xglCmdBindVertexBuffer( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER buffer, - XGL_GPU_SIZE offset, +void VKAPI vkCmdBindVertexBuffer( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, uint32_t binding); -void XGLAPI xglCmdDraw( - XGL_CMD_BUFFER cmdBuffer, +void VKAPI vkCmdDraw( + VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); -void XGLAPI xglCmdDrawIndexed( - XGL_CMD_BUFFER cmdBuffer, +void VKAPI vkCmdDrawIndexed( + VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); -void XGLAPI xglCmdDrawIndirect( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER buffer, - XGL_GPU_SIZE offset, +void VKAPI vkCmdDrawIndirect( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, uint32_t count, uint32_t stride); -void XGLAPI xglCmdDrawIndexedIndirect( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER buffer, - XGL_GPU_SIZE offset, +void VKAPI vkCmdDrawIndexedIndirect( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, uint32_t count, uint32_t stride); -void XGLAPI xglCmdDispatch( - XGL_CMD_BUFFER cmdBuffer, +void VKAPI vkCmdDispatch( + VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -void XGLAPI xglCmdDispatchIndirect( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER buffer, - XGL_GPU_SIZE offset); +void VKAPI vkCmdDispatchIndirect( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset); -void XGLAPI xglCmdCopyBuffer( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER srcBuffer, - XGL_BUFFER destBuffer, +void VKAPI vkCmdCopyBuffer( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER srcBuffer, + VK_BUFFER destBuffer, uint32_t regionCount, - const XGL_BUFFER_COPY* pRegions); - -void XGLAPI xglCmdCopyImage( - XGL_CMD_BUFFER cmdBuffer, - XGL_IMAGE srcImage, - XGL_IMAGE_LAYOUT srcImageLayout, - XGL_IMAGE destImage, - XGL_IMAGE_LAYOUT destImageLayout, + const VK_BUFFER_COPY* pRegions); + +void VKAPI vkCmdCopyImage( + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE srcImage, + VK_IMAGE_LAYOUT srcImageLayout, + VK_IMAGE destImage, + VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, - const XGL_IMAGE_COPY* pRegions); - -void XGLAPI xglCmdBlitImage( - XGL_CMD_BUFFER cmdBuffer, - XGL_IMAGE srcImage, - XGL_IMAGE_LAYOUT srcImageLayout, - XGL_IMAGE destImage, - XGL_IMAGE_LAYOUT destImageLayout, + const VK_IMAGE_COPY* pRegions); + +void VKAPI vkCmdBlitImage( + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE srcImage, + VK_IMAGE_LAYOUT srcImageLayout, + VK_IMAGE destImage, + VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, - const XGL_IMAGE_BLIT* pRegions); + const VK_IMAGE_BLIT* pRegions); -void XGLAPI xglCmdCopyBufferToImage( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER srcBuffer, - XGL_IMAGE destImage, - XGL_IMAGE_LAYOUT destImageLayout, +void VKAPI vkCmdCopyBufferToImage( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER srcBuffer, + VK_IMAGE destImage, + VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, - const XGL_BUFFER_IMAGE_COPY* pRegions); + const VK_BUFFER_IMAGE_COPY* pRegions); -void XGLAPI xglCmdCopyImageToBuffer( - XGL_CMD_BUFFER cmdBuffer, - XGL_IMAGE srcImage, - XGL_IMAGE_LAYOUT srcImageLayout, - XGL_BUFFER destBuffer, +void VKAPI vkCmdCopyImageToBuffer( + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE srcImage, + VK_IMAGE_LAYOUT srcImageLayout, + VK_BUFFER destBuffer, uint32_t regionCount, - const XGL_BUFFER_IMAGE_COPY* pRegions); - -void XGLAPI xglCmdCloneImageData( - XGL_CMD_BUFFER cmdBuffer, - XGL_IMAGE srcImage, - XGL_IMAGE_LAYOUT srcImageLayout, - XGL_IMAGE destImage, - XGL_IMAGE_LAYOUT destImageLayout); - -void XGLAPI xglCmdUpdateBuffer( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER destBuffer, - XGL_GPU_SIZE destOffset, - XGL_GPU_SIZE dataSize, + const VK_BUFFER_IMAGE_COPY* pRegions); + +void VKAPI vkCmdCloneImageData( + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE srcImage, + VK_IMAGE_LAYOUT srcImageLayout, + VK_IMAGE destImage, + VK_IMAGE_LAYOUT destImageLayout); + +void VKAPI vkCmdUpdateBuffer( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset, + VK_GPU_SIZE dataSize, const uint32_t* pData); -void XGLAPI xglCmdFillBuffer( - XGL_CMD_BUFFER cmdBuffer, - XGL_BUFFER destBuffer, - XGL_GPU_SIZE destOffset, - XGL_GPU_SIZE fillSize, +void VKAPI vkCmdFillBuffer( + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset, + VK_GPU_SIZE fillSize, uint32_t data); -void XGLAPI xglCmdClearColorImage( - XGL_CMD_BUFFER cmdBuffer, - XGL_IMAGE image, - XGL_IMAGE_LAYOUT imageLayout, - XGL_CLEAR_COLOR color, +void VKAPI vkCmdClearColorImage( + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE image, + VK_IMAGE_LAYOUT imageLayout, + VK_CLEAR_COLOR color, uint32_t rangeCount, - const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges); + const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); -void XGLAPI xglCmdClearDepthStencil( - XGL_CMD_BUFFER cmdBuffer, - XGL_IMAGE image, - XGL_IMAGE_LAYOUT imageLayout, +void VKAPI vkCmdClearDepthStencil( + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE image, + VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, - const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges); - -void XGLAPI xglCmdResolveImage( - XGL_CMD_BUFFER cmdBuffer, - XGL_IMAGE srcImage, - XGL_IMAGE_LAYOUT srcImageLayout, - XGL_IMAGE destImage, - XGL_IMAGE_LAYOUT destImageLayout, + const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); + +void VKAPI vkCmdResolveImage( + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE srcImage, + VK_IMAGE_LAYOUT srcImageLayout, + VK_IMAGE destImage, + VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, - const XGL_IMAGE_RESOLVE* pRects); + const VK_IMAGE_RESOLVE* pRects); -void XGLAPI xglCmdSetEvent( - XGL_CMD_BUFFER cmdBuffer, - XGL_EVENT event, - XGL_PIPE_EVENT pipeEvent); +void VKAPI vkCmdSetEvent( + VK_CMD_BUFFER cmdBuffer, + VK_EVENT event, + VK_PIPE_EVENT pipeEvent); -void XGLAPI xglCmdResetEvent( - XGL_CMD_BUFFER cmdBuffer, - XGL_EVENT event, - XGL_PIPE_EVENT pipeEvent); +void VKAPI vkCmdResetEvent( + VK_CMD_BUFFER cmdBuffer, + VK_EVENT event, + VK_PIPE_EVENT pipeEvent); -void XGLAPI xglCmdWaitEvents( - XGL_CMD_BUFFER cmdBuffer, - const XGL_EVENT_WAIT_INFO* pWaitInfo); +void VKAPI vkCmdWaitEvents( + VK_CMD_BUFFER cmdBuffer, + const VK_EVENT_WAIT_INFO* pWaitInfo); -void XGLAPI xglCmdPipelineBarrier( - XGL_CMD_BUFFER cmdBuffer, - const XGL_PIPELINE_BARRIER* pBarrier); +void VKAPI vkCmdPipelineBarrier( + VK_CMD_BUFFER cmdBuffer, + const VK_PIPELINE_BARRIER* pBarrier); -void XGLAPI xglCmdBeginQuery( - XGL_CMD_BUFFER cmdBuffer, - XGL_QUERY_POOL queryPool, +void VKAPI vkCmdBeginQuery( + VK_CMD_BUFFER cmdBuffer, + VK_QUERY_POOL queryPool, uint32_t slot, - XGL_FLAGS flags); + VK_FLAGS flags); -void XGLAPI xglCmdEndQuery( - XGL_CMD_BUFFER cmdBuffer, - XGL_QUERY_POOL queryPool, +void VKAPI vkCmdEndQuery( + VK_CMD_BUFFER cmdBuffer, + VK_QUERY_POOL queryPool, uint32_t slot); -void XGLAPI xglCmdResetQueryPool( - XGL_CMD_BUFFER cmdBuffer, - XGL_QUERY_POOL queryPool, +void VKAPI vkCmdResetQueryPool( + VK_CMD_BUFFER cmdBuffer, + VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount); -void XGLAPI xglCmdWriteTimestamp( - XGL_CMD_BUFFER cmdBuffer, - XGL_TIMESTAMP_TYPE timestampType, - XGL_BUFFER destBuffer, - XGL_GPU_SIZE destOffset); +void VKAPI vkCmdWriteTimestamp( + VK_CMD_BUFFER cmdBuffer, + VK_TIMESTAMP_TYPE timestampType, + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset); -void XGLAPI xglCmdInitAtomicCounters( - XGL_CMD_BUFFER cmdBuffer, - XGL_PIPELINE_BIND_POINT pipelineBindPoint, +void VKAPI vkCmdInitAtomicCounters( + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); -void XGLAPI xglCmdLoadAtomicCounters( - XGL_CMD_BUFFER cmdBuffer, - XGL_PIPELINE_BIND_POINT pipelineBindPoint, +void VKAPI vkCmdLoadAtomicCounters( + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - XGL_BUFFER srcBuffer, - XGL_GPU_SIZE srcOffset); + VK_BUFFER srcBuffer, + VK_GPU_SIZE srcOffset); -void XGLAPI xglCmdSaveAtomicCounters( - XGL_CMD_BUFFER cmdBuffer, - XGL_PIPELINE_BIND_POINT pipelineBindPoint, +void VKAPI vkCmdSaveAtomicCounters( + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - XGL_BUFFER destBuffer, - XGL_GPU_SIZE destOffset); + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset); -XGL_RESULT XGLAPI xglCreateFramebuffer( - XGL_DEVICE device, - const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, - XGL_FRAMEBUFFER* pFramebuffer); +VK_RESULT VKAPI vkCreateFramebuffer( + VK_DEVICE device, + const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, + VK_FRAMEBUFFER* pFramebuffer); -XGL_RESULT XGLAPI xglCreateRenderPass( - XGL_DEVICE device, - const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, - XGL_RENDER_PASS* pRenderPass); +VK_RESULT VKAPI vkCreateRenderPass( + VK_DEVICE device, + const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, + VK_RENDER_PASS* pRenderPass); -void XGLAPI xglCmdBeginRenderPass( - XGL_CMD_BUFFER cmdBuffer, - const XGL_RENDER_PASS_BEGIN* pRenderPassBegin); +void VKAPI vkCmdBeginRenderPass( + VK_CMD_BUFFER cmdBuffer, + const VK_RENDER_PASS_BEGIN* pRenderPassBegin); -void XGLAPI xglCmdEndRenderPass( - XGL_CMD_BUFFER cmdBuffer, - XGL_RENDER_PASS renderPass); +void VKAPI vkCmdEndRenderPass( + VK_CMD_BUFFER cmdBuffer, + VK_RENDER_PASS renderPass); -#endif // XGL_PROTOTYPES +#endif // VK_PROTOTYPES #ifdef __cplusplus } // extern "C" #endif // __cplusplus -#endif // __XGL_H__ +#endif // __VULKAN_H__ /****************************************************************************************** @@ -3076,27 +3076,27 @@ void XGLAPI xglCmdEndRenderPass( To incorporate trasnform feedback, we could create a new pipeline stage. This would be injected into a PSO by including the following in the chain: - typedef struct _XGL_XFB_CREATE_INFO + typedef struct _VK_XFB_CREATE_INFO { - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO const void* pNext; // Pointer to next structure // More XFB state, if any goes here - } XGL_DEPTH_STENCIL_VIEW_CREATE_INFO; + } VK_DEPTH_STENCIL_VIEW_CREATE_INFO; We expect that only the shader-side configuration (via layout qualifiers or their IR equivalent) is used to configure the data written to each stream. When transform feedback is part of the pipeline, transform feedback binding would be available through a new API bind point: - xglCmdBindTransformFeedbackMemoryView( - XGL_CMD_BUFFER cmdBuffer, - XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS + vkCmdBindTransformFeedbackMemoryView( + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS uint32_t index, - const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView); + const VK_MEMORY_VIEW_ATTACH_INFO* pMemView); 2) "Bindless" + support for non-bindless hardware. - XGL doesn't have bindless textures the way that GL does. It has resource descriptor + VK doesn't have bindless textures the way that GL does. It has resource descriptor sets, or resource tables. Resource tables can be nested and hold references to more resource tables. They are explicitly sized by the application and have no artificial upper size limit. An application can still attach as many textures as they want to diff --git a/include/xglDbg.h b/include/xglDbg.h index 5a6c8fa0..fb224829 100644 --- a/include/xglDbg.h +++ b/include/xglDbg.h @@ -1,171 +1,171 @@ -#ifndef __XGLDBG_H__ -#define __XGLDBG_H__ +#ifndef __VKDBG_H__ +#define __VKDBG_H__ -#include <xgl.h> +#include <vulkan.h> #ifdef __cplusplus extern "C" { #endif // __cplusplus -typedef enum _XGL_DBG_MSG_TYPE +typedef enum _VK_DBG_MSG_TYPE { - XGL_DBG_MSG_UNKNOWN = 0x0, - XGL_DBG_MSG_ERROR = 0x1, - XGL_DBG_MSG_WARNING = 0x2, - XGL_DBG_MSG_PERF_WARNING = 0x3, + VK_DBG_MSG_UNKNOWN = 0x0, + VK_DBG_MSG_ERROR = 0x1, + VK_DBG_MSG_WARNING = 0x2, + VK_DBG_MSG_PERF_WARNING = 0x3, - XGL_DBG_MSG_TYPE_BEGIN_RANGE = XGL_DBG_MSG_UNKNOWN, - XGL_DBG_MSG_TYPE_END_RANGE = XGL_DBG_MSG_PERF_WARNING, - XGL_NUM_DBG_MSG_TYPE = (XGL_DBG_MSG_TYPE_END_RANGE - XGL_DBG_MSG_TYPE_BEGIN_RANGE + 1), -} XGL_DBG_MSG_TYPE; + VK_DBG_MSG_TYPE_BEGIN_RANGE = VK_DBG_MSG_UNKNOWN, + VK_DBG_MSG_TYPE_END_RANGE = VK_DBG_MSG_PERF_WARNING, + VK_NUM_DBG_MSG_TYPE = (VK_DBG_MSG_TYPE_END_RANGE - VK_DBG_MSG_TYPE_BEGIN_RANGE + 1), +} VK_DBG_MSG_TYPE; -typedef enum _XGL_DBG_MSG_FILTER +typedef enum _VK_DBG_MSG_FILTER { - XGL_DBG_MSG_FILTER_NONE = 0x0, - XGL_DBG_MSG_FILTER_REPEATED = 0x1, - XGL_DBG_MSG_FILTER_ALL = 0x2, + VK_DBG_MSG_FILTER_NONE = 0x0, + VK_DBG_MSG_FILTER_REPEATED = 0x1, + VK_DBG_MSG_FILTER_ALL = 0x2, - XGL_DBG_MSG_FILTER_BEGIN_RANGE = XGL_DBG_MSG_FILTER_NONE, - XGL_DBG_MSG_FILTER_END_RANGE = XGL_DBG_MSG_FILTER_ALL, - XGL_NUM_DBG_MSG_FILTER = (XGL_DBG_MSG_FILTER_END_RANGE - XGL_DBG_MSG_FILTER_BEGIN_RANGE + 1), -} XGL_DBG_MSG_FILTER; + VK_DBG_MSG_FILTER_BEGIN_RANGE = VK_DBG_MSG_FILTER_NONE, + VK_DBG_MSG_FILTER_END_RANGE = VK_DBG_MSG_FILTER_ALL, + VK_NUM_DBG_MSG_FILTER = (VK_DBG_MSG_FILTER_END_RANGE - VK_DBG_MSG_FILTER_BEGIN_RANGE + 1), +} VK_DBG_MSG_FILTER; -typedef enum _XGL_DBG_GLOBAL_OPTION +typedef enum _VK_DBG_GLOBAL_OPTION { - XGL_DBG_OPTION_DEBUG_ECHO_ENABLE = 0x0, - XGL_DBG_OPTION_BREAK_ON_ERROR = 0x1, - XGL_DBG_OPTION_BREAK_ON_WARNING = 0x2, + VK_DBG_OPTION_DEBUG_ECHO_ENABLE = 0x0, + VK_DBG_OPTION_BREAK_ON_ERROR = 0x1, + VK_DBG_OPTION_BREAK_ON_WARNING = 0x2, - XGL_DBG_GLOBAL_OPTION_BEGIN_RANGE = XGL_DBG_OPTION_DEBUG_ECHO_ENABLE, - XGL_DBG_GLOBAL_OPTION_END_RANGE = XGL_DBG_OPTION_BREAK_ON_WARNING, - XGL_NUM_DBG_GLOBAL_OPTION = (XGL_DBG_GLOBAL_OPTION_END_RANGE - XGL_DBG_GLOBAL_OPTION_BEGIN_RANGE + 1), -} XGL_DBG_GLOBAL_OPTION; + VK_DBG_GLOBAL_OPTION_BEGIN_RANGE = VK_DBG_OPTION_DEBUG_ECHO_ENABLE, + VK_DBG_GLOBAL_OPTION_END_RANGE = VK_DBG_OPTION_BREAK_ON_WARNING, + VK_NUM_DBG_GLOBAL_OPTION = (VK_DBG_GLOBAL_OPTION_END_RANGE - VK_DBG_GLOBAL_OPTION_BEGIN_RANGE + 1), +} VK_DBG_GLOBAL_OPTION; -typedef enum _XGL_DBG_DEVICE_OPTION +typedef enum _VK_DBG_DEVICE_OPTION { - XGL_DBG_OPTION_DISABLE_PIPELINE_LOADS = 0x0, - XGL_DBG_OPTION_FORCE_OBJECT_MEMORY_REQS = 0x1, - XGL_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT = 0x2, + VK_DBG_OPTION_DISABLE_PIPELINE_LOADS = 0x0, + VK_DBG_OPTION_FORCE_OBJECT_MEMORY_REQS = 0x1, + VK_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT = 0x2, - XGL_DBG_DEVICE_OPTION_BEGIN_RANGE = XGL_DBG_OPTION_DISABLE_PIPELINE_LOADS, - XGL_DBG_DEVICE_OPTION_END_RANGE = XGL_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT, - XGL_NUM_DBG_DEVICE_OPTION = (XGL_DBG_DEVICE_OPTION_END_RANGE - XGL_DBG_DEVICE_OPTION_BEGIN_RANGE + 1), -} XGL_DBG_DEVICE_OPTION; + VK_DBG_DEVICE_OPTION_BEGIN_RANGE = VK_DBG_OPTION_DISABLE_PIPELINE_LOADS, + VK_DBG_DEVICE_OPTION_END_RANGE = VK_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT, + VK_NUM_DBG_DEVICE_OPTION = (VK_DBG_DEVICE_OPTION_END_RANGE - VK_DBG_DEVICE_OPTION_BEGIN_RANGE + 1), +} VK_DBG_DEVICE_OPTION; -typedef enum _XGL_DBG_OBJECT_TYPE +typedef enum _VK_DBG_OBJECT_TYPE { - XGL_DBG_OBJECT_UNKNOWN = 0x00, - XGL_DBG_OBJECT_DEVICE = 0x01, - XGL_DBG_OBJECT_QUEUE = 0x02, - XGL_DBG_OBJECT_GPU_MEMORY = 0x03, - XGL_DBG_OBJECT_IMAGE = 0x04, - XGL_DBG_OBJECT_IMAGE_VIEW = 0x05, - XGL_DBG_OBJECT_COLOR_TARGET_VIEW = 0x06, - XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW = 0x07, - XGL_DBG_OBJECT_SHADER = 0x08, - XGL_DBG_OBJECT_GRAPHICS_PIPELINE = 0x09, - XGL_DBG_OBJECT_COMPUTE_PIPELINE = 0x0a, - XGL_DBG_OBJECT_SAMPLER = 0x0b, - XGL_DBG_OBJECT_DESCRIPTOR_SET = 0x0c, - XGL_DBG_OBJECT_VIEWPORT_STATE = 0x0d, - XGL_DBG_OBJECT_RASTER_STATE = 0x0e, - XGL_DBG_OBJECT_MSAA_STATE = 0x0f, - XGL_DBG_OBJECT_COLOR_BLEND_STATE = 0x10, - XGL_DBG_OBJECT_DEPTH_STENCIL_STATE = 0x11, - XGL_DBG_OBJECT_CMD_BUFFER = 0x12, - XGL_DBG_OBJECT_FENCE = 0x13, - XGL_DBG_OBJECT_SEMAPHORE = 0x14, - XGL_DBG_OBJECT_EVENT = 0x15, - XGL_DBG_OBJECT_QUERY_POOL = 0x16, - XGL_DBG_OBJECT_SHARED_GPU_MEMORY = 0x17, - XGL_DBG_OBJECT_SHARED_SEMAPHORE = 0x18, - XGL_DBG_OBJECT_PEER_GPU_MEMORY = 0x19, - XGL_DBG_OBJECT_PEER_IMAGE = 0x1a, - XGL_DBG_OBJECT_PINNED_GPU_MEMORY = 0x1b, - XGL_DBG_OBJECT_INTERNAL_GPU_MEMORY = 0x1c, - XGL_DBG_OBJECT_FRAMEBUFFER = 0x1d, - XGL_DBG_OBJECT_RENDER_PASS = 0x1e, - - XGL_DBG_OBJECT_INSTANCE, - XGL_DBG_OBJECT_BUFFER, - XGL_DBG_OBJECT_BUFFER_VIEW, - XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT, - XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT_CHAIN, - XGL_DBG_OBJECT_DESCRIPTOR_POOL, - - XGL_DBG_OBJECT_TYPE_BEGIN_RANGE = XGL_DBG_OBJECT_UNKNOWN, - XGL_DBG_OBJECT_TYPE_END_RANGE = XGL_DBG_OBJECT_DESCRIPTOR_POOL, - XGL_NUM_DBG_OBJECT_TYPE = (XGL_DBG_OBJECT_TYPE_END_RANGE - XGL_DBG_OBJECT_TYPE_BEGIN_RANGE + 1), -} XGL_DBG_OBJECT_TYPE; - -typedef void (XGLAPI *XGL_DBG_MSG_CALLBACK_FUNCTION)( - XGL_DBG_MSG_TYPE msgType, - XGL_VALIDATION_LEVEL validationLevel, - XGL_BASE_OBJECT srcObject, + VK_DBG_OBJECT_UNKNOWN = 0x00, + VK_DBG_OBJECT_DEVICE = 0x01, + VK_DBG_OBJECT_QUEUE = 0x02, + VK_DBG_OBJECT_GPU_MEMORY = 0x03, + VK_DBG_OBJECT_IMAGE = 0x04, + VK_DBG_OBJECT_IMAGE_VIEW = 0x05, + VK_DBG_OBJECT_COLOR_TARGET_VIEW = 0x06, + VK_DBG_OBJECT_DEPTH_STENCIL_VIEW = 0x07, + VK_DBG_OBJECT_SHADER = 0x08, + VK_DBG_OBJECT_GRAPHICS_PIPELINE = 0x09, + VK_DBG_OBJECT_COMPUTE_PIPELINE = 0x0a, + VK_DBG_OBJECT_SAMPLER = 0x0b, + VK_DBG_OBJECT_DESCRIPTOR_SET = 0x0c, + VK_DBG_OBJECT_VIEWPORT_STATE = 0x0d, + VK_DBG_OBJECT_RASTER_STATE = 0x0e, + VK_DBG_OBJECT_MSAA_STATE = 0x0f, + VK_DBG_OBJECT_COLOR_BLEND_STATE = 0x10, + VK_DBG_OBJECT_DEPTH_STENCIL_STATE = 0x11, + VK_DBG_OBJECT_CMD_BUFFER = 0x12, + VK_DBG_OBJECT_FENCE = 0x13, + VK_DBG_OBJECT_SEMAPHORE = 0x14, + VK_DBG_OBJECT_EVENT = 0x15, + VK_DBG_OBJECT_QUERY_POOL = 0x16, + VK_DBG_OBJECT_SHARED_GPU_MEMORY = 0x17, + VK_DBG_OBJECT_SHARED_SEMAPHORE = 0x18, + VK_DBG_OBJECT_PEER_GPU_MEMORY = 0x19, + VK_DBG_OBJECT_PEER_IMAGE = 0x1a, + VK_DBG_OBJECT_PINNED_GPU_MEMORY = 0x1b, + VK_DBG_OBJECT_INTERNAL_GPU_MEMORY = 0x1c, + VK_DBG_OBJECT_FRAMEBUFFER = 0x1d, + VK_DBG_OBJECT_RENDER_PASS = 0x1e, + + VK_DBG_OBJECT_INSTANCE, + VK_DBG_OBJECT_BUFFER, + VK_DBG_OBJECT_BUFFER_VIEW, + VK_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT, + VK_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT_CHAIN, + VK_DBG_OBJECT_DESCRIPTOR_POOL, + + VK_DBG_OBJECT_TYPE_BEGIN_RANGE = VK_DBG_OBJECT_UNKNOWN, + VK_DBG_OBJECT_TYPE_END_RANGE = VK_DBG_OBJECT_DESCRIPTOR_POOL, + VK_NUM_DBG_OBJECT_TYPE = (VK_DBG_OBJECT_TYPE_END_RANGE - VK_DBG_OBJECT_TYPE_BEGIN_RANGE + 1), +} VK_DBG_OBJECT_TYPE; + +typedef void (VKAPI *VK_DBG_MSG_CALLBACK_FUNCTION)( + VK_DBG_MSG_TYPE msgType, + VK_VALIDATION_LEVEL validationLevel, + VK_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg, void* pUserData); // Debug functions -typedef XGL_RESULT (XGLAPI *xglDbgSetValidationLevelType)(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel); -typedef XGL_RESULT (XGLAPI *xglDbgRegisterMsgCallbackType)(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData); -typedef XGL_RESULT (XGLAPI *xglDbgUnregisterMsgCallbackType)(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); -typedef XGL_RESULT (XGLAPI *xglDbgSetMessageFilterType)(XGL_DEVICE device, int32_t msgCode, XGL_DBG_MSG_FILTER filter); -typedef XGL_RESULT (XGLAPI *xglDbgSetObjectTagType)(XGL_BASE_OBJECT object, size_t tagSize, const void* pTag); -typedef XGL_RESULT (XGLAPI *xglDbgSetGlobalOptionType)(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData); -typedef XGL_RESULT (XGLAPI *xglDbgSetDeviceOptionType)(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData); -typedef void (XGLAPI *xglCmdDbgMarkerBeginType)(XGL_CMD_BUFFER cmdBuffer, const char* pMarker); -typedef void (XGLAPI *xglCmdDbgMarkerEndType)(XGL_CMD_BUFFER cmdBuffer); - -#ifdef XGL_PROTOTYPES -XGL_RESULT XGLAPI xglDbgSetValidationLevel( - XGL_DEVICE device, - XGL_VALIDATION_LEVEL validationLevel); - -XGL_RESULT XGLAPI xglDbgRegisterMsgCallback( - XGL_INSTANCE instance, - XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, +typedef VK_RESULT (VKAPI *vkDbgSetValidationLevelType)(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel); +typedef VK_RESULT (VKAPI *vkDbgRegisterMsgCallbackType)(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData); +typedef VK_RESULT (VKAPI *vkDbgUnregisterMsgCallbackType)(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); +typedef VK_RESULT (VKAPI *vkDbgSetMessageFilterType)(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter); +typedef VK_RESULT (VKAPI *vkDbgSetObjectTagType)(VK_BASE_OBJECT object, size_t tagSize, const void* pTag); +typedef VK_RESULT (VKAPI *vkDbgSetGlobalOptionType)(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData); +typedef VK_RESULT (VKAPI *vkDbgSetDeviceOptionType)(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData); +typedef void (VKAPI *vkCmdDbgMarkerBeginType)(VK_CMD_BUFFER cmdBuffer, const char* pMarker); +typedef void (VKAPI *vkCmdDbgMarkerEndType)(VK_CMD_BUFFER cmdBuffer); + +#ifdef VK_PROTOTYPES +VK_RESULT VKAPI vkDbgSetValidationLevel( + VK_DEVICE device, + VK_VALIDATION_LEVEL validationLevel); + +VK_RESULT VKAPI vkDbgRegisterMsgCallback( + VK_INSTANCE instance, + VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData); -XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback( - XGL_INSTANCE instance, - XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); +VK_RESULT VKAPI vkDbgUnregisterMsgCallback( + VK_INSTANCE instance, + VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); -XGL_RESULT XGLAPI xglDbgSetMessageFilter( - XGL_DEVICE device, +VK_RESULT VKAPI vkDbgSetMessageFilter( + VK_DEVICE device, int32_t msgCode, - XGL_DBG_MSG_FILTER filter); + VK_DBG_MSG_FILTER filter); -XGL_RESULT XGLAPI xglDbgSetObjectTag( - XGL_BASE_OBJECT object, +VK_RESULT VKAPI vkDbgSetObjectTag( + VK_BASE_OBJECT object, size_t tagSize, const void* pTag); -XGL_RESULT XGLAPI xglDbgSetGlobalOption( - XGL_INSTANCE instance, - XGL_DBG_GLOBAL_OPTION dbgOption, +VK_RESULT VKAPI vkDbgSetGlobalOption( + VK_INSTANCE instance, + VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData); -XGL_RESULT XGLAPI xglDbgSetDeviceOption( - XGL_DEVICE device, - XGL_DBG_DEVICE_OPTION dbgOption, +VK_RESULT VKAPI vkDbgSetDeviceOption( + VK_DEVICE device, + VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData); -void XGLAPI xglCmdDbgMarkerBegin( - XGL_CMD_BUFFER cmdBuffer, +void VKAPI vkCmdDbgMarkerBegin( + VK_CMD_BUFFER cmdBuffer, const char* pMarker); -void XGLAPI xglCmdDbgMarkerEnd( - XGL_CMD_BUFFER cmdBuffer); +void VKAPI vkCmdDbgMarkerEnd( + VK_CMD_BUFFER cmdBuffer); -#endif // XGL_PROTOTYPES +#endif // VK_PROTOTYPES #ifdef __cplusplus }; // extern "C" #endif // __cplusplus -#endif // __XGLDBG_H__ +#endif // __VKDBG_H__ diff --git a/include/xglIcd.h b/include/xglIcd.h index 1c25936d..b7916a86 100644 --- a/include/xglIcd.h +++ b/include/xglIcd.h @@ -1,9 +1,9 @@ -#ifndef XGLICD_H -#define XGLICD_H +#ifndef VKICD_H +#define VKICD_H #include <stdint.h> #include <stdbool.h> -#include "xglPlatform.h" +#include "vkPlatform.h" /* * The ICD must reserve space for a pointer for the loader's dispatch @@ -13,20 +13,20 @@ #define ICD_LOADER_MAGIC 0x01CDC0DE -typedef union _XGL_LOADER_DATA { +typedef union _VK_LOADER_DATA { uint32_t loaderMagic; void *loaderData; -} XGL_LOADER_DATA; +} VK_LOADER_DATA; static inline void set_loader_magic_value(void *pNewObject) { - XGL_LOADER_DATA *loader_info = (XGL_LOADER_DATA *) pNewObject; + VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *) pNewObject; loader_info->loaderMagic = ICD_LOADER_MAGIC; } static inline bool valid_loader_magic_value(void *pNewObject) { - const XGL_LOADER_DATA *loader_info = (XGL_LOADER_DATA *) pNewObject; + const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *) pNewObject; return loader_info->loaderMagic == ICD_LOADER_MAGIC; } -#endif // XGLICD_H +#endif // VKICD_H diff --git a/include/xglLayer.h b/include/xglLayer.h index c3d63a6e..c3679a00 100644 --- a/include/xglLayer.h +++ b/include/xglLayer.h @@ -4,184 +4,184 @@ */ #pragma once -#include "xgl.h" -#include "xglDbg.h" +#include "vulkan.h" +#include "vkDbg.h" #if defined(__linux__) || defined(XCB_NVIDIA) -#include "xglWsiX11Ext.h" +#include "vkWsiX11Ext.h" #endif #if defined(__GNUC__) && __GNUC__ >= 4 -# define XGL_LAYER_EXPORT __attribute__((visibility("default"))) +# define VK_LAYER_EXPORT __attribute__((visibility("default"))) #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -# define XGL_LAYER_EXPORT __attribute__((visibility("default"))) +# define VK_LAYER_EXPORT __attribute__((visibility("default"))) #else -# define XGL_LAYER_EXPORT +# define VK_LAYER_EXPORT #endif -typedef struct _XGL_BASE_LAYER_OBJECT +typedef struct _VK_BASE_LAYER_OBJECT { - xglGetProcAddrType pGPA; - XGL_BASE_OBJECT nextObject; - XGL_BASE_OBJECT baseObject; -} XGL_BASE_LAYER_OBJECT; + vkGetProcAddrType pGPA; + VK_BASE_OBJECT nextObject; + VK_BASE_OBJECT baseObject; +} VK_BASE_LAYER_OBJECT; -typedef struct _XGL_LAYER_DISPATCH_TABLE +typedef struct _VK_LAYER_DISPATCH_TABLE { - xglGetProcAddrType GetProcAddr; - xglCreateInstanceType CreateInstance; - xglDestroyInstanceType DestroyInstance; - xglEnumerateGpusType EnumerateGpus; - xglGetGpuInfoType GetGpuInfo; - xglCreateDeviceType CreateDevice; - xglDestroyDeviceType DestroyDevice; - xglGetExtensionSupportType GetExtensionSupport; - xglEnumerateLayersType EnumerateLayers; - xglGetDeviceQueueType GetDeviceQueue; - xglQueueSubmitType QueueSubmit; - xglQueueAddMemReferenceType QueueAddMemReference; - xglQueueRemoveMemReferenceType QueueRemoveMemReference; - xglQueueWaitIdleType QueueWaitIdle; - xglDeviceWaitIdleType DeviceWaitIdle; - xglAllocMemoryType AllocMemory; - xglFreeMemoryType FreeMemory; - xglSetMemoryPriorityType SetMemoryPriority; - xglMapMemoryType MapMemory; - xglUnmapMemoryType UnmapMemory; - xglPinSystemMemoryType PinSystemMemory; - xglGetMultiGpuCompatibilityType GetMultiGpuCompatibility; - xglOpenSharedMemoryType OpenSharedMemory; - xglOpenSharedSemaphoreType OpenSharedSemaphore; - xglOpenPeerMemoryType OpenPeerMemory; - xglOpenPeerImageType OpenPeerImage; - xglDestroyObjectType DestroyObject; - xglGetObjectInfoType GetObjectInfo; - xglBindObjectMemoryType BindObjectMemory; - xglBindObjectMemoryRangeType BindObjectMemoryRange; - xglBindImageMemoryRangeType BindImageMemoryRange; - xglCreateFenceType CreateFence; - xglGetFenceStatusType GetFenceStatus; - xglResetFencesType ResetFences; - xglWaitForFencesType WaitForFences; - xglCreateSemaphoreType CreateSemaphore; - xglQueueSignalSemaphoreType QueueSignalSemaphore; - xglQueueWaitSemaphoreType QueueWaitSemaphore; - xglCreateEventType CreateEvent; - xglGetEventStatusType GetEventStatus; - xglSetEventType SetEvent; - xglResetEventType ResetEvent; - xglCreateQueryPoolType CreateQueryPool; - xglGetQueryPoolResultsType GetQueryPoolResults; - xglGetFormatInfoType GetFormatInfo; - xglCreateBufferType CreateBuffer; - xglCreateBufferViewType CreateBufferView; - xglCreateImageType CreateImage; - xglGetImageSubresourceInfoType GetImageSubresourceInfo; - xglCreateImageViewType CreateImageView; - xglCreateColorAttachmentViewType CreateColorAttachmentView; - xglCreateDepthStencilViewType CreateDepthStencilView; - xglCreateShaderType CreateShader; - xglCreateGraphicsPipelineType CreateGraphicsPipeline; - xglCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative; - xglCreateComputePipelineType CreateComputePipeline; - xglStorePipelineType StorePipeline; - xglLoadPipelineType LoadPipeline; - xglLoadPipelineDerivativeType LoadPipelineDerivative; - xglCreateSamplerType CreateSampler; - xglCreateDescriptorSetLayoutType CreateDescriptorSetLayout; - xglCreateDescriptorSetLayoutChainType CreateDescriptorSetLayoutChain; - xglBeginDescriptorPoolUpdateType BeginDescriptorPoolUpdate; - xglEndDescriptorPoolUpdateType EndDescriptorPoolUpdate; - xglCreateDescriptorPoolType CreateDescriptorPool; - xglResetDescriptorPoolType ResetDescriptorPool; - xglAllocDescriptorSetsType AllocDescriptorSets; - xglClearDescriptorSetsType ClearDescriptorSets; - xglUpdateDescriptorsType UpdateDescriptors; - xglCreateDynamicViewportStateType CreateDynamicViewportState; - xglCreateDynamicRasterStateType CreateDynamicRasterState; - xglCreateDynamicColorBlendStateType CreateDynamicColorBlendState; - xglCreateDynamicDepthStencilStateType CreateDynamicDepthStencilState; - xglCreateCommandBufferType CreateCommandBuffer; - xglBeginCommandBufferType BeginCommandBuffer; - xglEndCommandBufferType EndCommandBuffer; - xglResetCommandBufferType ResetCommandBuffer; - xglCmdBindPipelineType CmdBindPipeline; - xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject; - xglCmdBindDescriptorSetsType CmdBindDescriptorSets; - xglCmdBindVertexBufferType CmdBindVertexBuffer; - xglCmdBindIndexBufferType CmdBindIndexBuffer; - xglCmdDrawType CmdDraw; - xglCmdDrawIndexedType CmdDrawIndexed; - xglCmdDrawIndirectType CmdDrawIndirect; - xglCmdDrawIndexedIndirectType CmdDrawIndexedIndirect; - xglCmdDispatchType CmdDispatch; - xglCmdDispatchIndirectType CmdDispatchIndirect; - xglCmdCopyBufferType CmdCopyBuffer; - xglCmdCopyImageType CmdCopyImage; - xglCmdBlitImageType CmdBlitImage; - xglCmdCopyBufferToImageType CmdCopyBufferToImage; - xglCmdCopyImageToBufferType CmdCopyImageToBuffer; - xglCmdCloneImageDataType CmdCloneImageData; - xglCmdUpdateBufferType CmdUpdateBuffer; - xglCmdFillBufferType CmdFillBuffer; - xglCmdClearColorImageType CmdClearColorImage; - xglCmdClearDepthStencilType CmdClearDepthStencil; - xglCmdResolveImageType CmdResolveImage; - xglCmdSetEventType CmdSetEvent; - xglCmdResetEventType CmdResetEvent; - xglCmdWaitEventsType CmdWaitEvents; - xglCmdPipelineBarrierType CmdPipelineBarrier; - xglCmdBeginQueryType CmdBeginQuery; - xglCmdEndQueryType CmdEndQuery; - xglCmdResetQueryPoolType CmdResetQueryPool; - xglCmdWriteTimestampType CmdWriteTimestamp; - xglCmdInitAtomicCountersType CmdInitAtomicCounters; - xglCmdLoadAtomicCountersType CmdLoadAtomicCounters; - xglCmdSaveAtomicCountersType CmdSaveAtomicCounters; - xglCreateFramebufferType CreateFramebuffer; - xglCreateRenderPassType CreateRenderPass; - xglCmdBeginRenderPassType CmdBeginRenderPass; - xglCmdEndRenderPassType CmdEndRenderPass; - xglDbgSetValidationLevelType DbgSetValidationLevel; - xglDbgRegisterMsgCallbackType DbgRegisterMsgCallback; - xglDbgUnregisterMsgCallbackType DbgUnregisterMsgCallback; - xglDbgSetMessageFilterType DbgSetMessageFilter; - xglDbgSetObjectTagType DbgSetObjectTag; - xglDbgSetGlobalOptionType DbgSetGlobalOption; - xglDbgSetDeviceOptionType DbgSetDeviceOption; - xglCmdDbgMarkerBeginType CmdDbgMarkerBegin; - xglCmdDbgMarkerEndType CmdDbgMarkerEnd; + vkGetProcAddrType GetProcAddr; + vkCreateInstanceType CreateInstance; + vkDestroyInstanceType DestroyInstance; + vkEnumerateGpusType EnumerateGpus; + vkGetGpuInfoType GetGpuInfo; + vkCreateDeviceType CreateDevice; + vkDestroyDeviceType DestroyDevice; + vkGetExtensionSupportType GetExtensionSupport; + vkEnumerateLayersType EnumerateLayers; + vkGetDeviceQueueType GetDeviceQueue; + vkQueueSubmitType QueueSubmit; + vkQueueAddMemReferenceType QueueAddMemReference; + vkQueueRemoveMemReferenceType QueueRemoveMemReference; + vkQueueWaitIdleType QueueWaitIdle; + vkDeviceWaitIdleType DeviceWaitIdle; + vkAllocMemoryType AllocMemory; + vkFreeMemoryType FreeMemory; + vkSetMemoryPriorityType SetMemoryPriority; + vkMapMemoryType MapMemory; + vkUnmapMemoryType UnmapMemory; + vkPinSystemMemoryType PinSystemMemory; + vkGetMultiGpuCompatibilityType GetMultiGpuCompatibility; + vkOpenSharedMemoryType OpenSharedMemory; + vkOpenSharedSemaphoreType OpenSharedSemaphore; + vkOpenPeerMemoryType OpenPeerMemory; + vkOpenPeerImageType OpenPeerImage; + vkDestroyObjectType DestroyObject; + vkGetObjectInfoType GetObjectInfo; + vkBindObjectMemoryType BindObjectMemory; + vkBindObjectMemoryRangeType BindObjectMemoryRange; + vkBindImageMemoryRangeType BindImageMemoryRange; + vkCreateFenceType CreateFence; + vkGetFenceStatusType GetFenceStatus; + vkResetFencesType ResetFences; + vkWaitForFencesType WaitForFences; + vkCreateSemaphoreType CreateSemaphore; + vkQueueSignalSemaphoreType QueueSignalSemaphore; + vkQueueWaitSemaphoreType QueueWaitSemaphore; + vkCreateEventType CreateEvent; + vkGetEventStatusType GetEventStatus; + vkSetEventType SetEvent; + vkResetEventType ResetEvent; + vkCreateQueryPoolType CreateQueryPool; + vkGetQueryPoolResultsType GetQueryPoolResults; + vkGetFormatInfoType GetFormatInfo; + vkCreateBufferType CreateBuffer; + vkCreateBufferViewType CreateBufferView; + vkCreateImageType CreateImage; + vkGetImageSubresourceInfoType GetImageSubresourceInfo; + vkCreateImageViewType CreateImageView; + vkCreateColorAttachmentViewType CreateColorAttachmentView; + vkCreateDepthStencilViewType CreateDepthStencilView; + vkCreateShaderType CreateShader; + vkCreateGraphicsPipelineType CreateGraphicsPipeline; + vkCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative; + vkCreateComputePipelineType CreateComputePipeline; + vkStorePipelineType StorePipeline; + vkLoadPipelineType LoadPipeline; + vkLoadPipelineDerivativeType LoadPipelineDerivative; + vkCreateSamplerType CreateSampler; + vkCreateDescriptorSetLayoutType CreateDescriptorSetLayout; + vkCreateDescriptorSetLayoutChainType CreateDescriptorSetLayoutChain; + vkBeginDescriptorPoolUpdateType BeginDescriptorPoolUpdate; + vkEndDescriptorPoolUpdateType EndDescriptorPoolUpdate; + vkCreateDescriptorPoolType CreateDescriptorPool; + vkResetDescriptorPoolType ResetDescriptorPool; + vkAllocDescriptorSetsType AllocDescriptorSets; + vkClearDescriptorSetsType ClearDescriptorSets; + vkUpdateDescriptorsType UpdateDescriptors; + vkCreateDynamicViewportStateType CreateDynamicViewportState; + vkCreateDynamicRasterStateType CreateDynamicRasterState; + vkCreateDynamicColorBlendStateType CreateDynamicColorBlendState; + vkCreateDynamicDepthStencilStateType CreateDynamicDepthStencilState; + vkCreateCommandBufferType CreateCommandBuffer; + vkBeginCommandBufferType BeginCommandBuffer; + vkEndCommandBufferType EndCommandBuffer; + vkResetCommandBufferType ResetCommandBuffer; + vkCmdBindPipelineType CmdBindPipeline; + vkCmdBindDynamicStateObjectType CmdBindDynamicStateObject; + vkCmdBindDescriptorSetsType CmdBindDescriptorSets; + vkCmdBindVertexBufferType CmdBindVertexBuffer; + vkCmdBindIndexBufferType CmdBindIndexBuffer; + vkCmdDrawType CmdDraw; + vkCmdDrawIndexedType CmdDrawIndexed; + vkCmdDrawIndirectType CmdDrawIndirect; + vkCmdDrawIndexedIndirectType CmdDrawIndexedIndirect; + vkCmdDispatchType CmdDispatch; + vkCmdDispatchIndirectType CmdDispatchIndirect; + vkCmdCopyBufferType CmdCopyBuffer; + vkCmdCopyImageType CmdCopyImage; + vkCmdBlitImageType CmdBlitImage; + vkCmdCopyBufferToImageType CmdCopyBufferToImage; + vkCmdCopyImageToBufferType CmdCopyImageToBuffer; + vkCmdCloneImageDataType CmdCloneImageData; + vkCmdUpdateBufferType CmdUpdateBuffer; + vkCmdFillBufferType CmdFillBuffer; + vkCmdClearColorImageType CmdClearColorImage; + vkCmdClearDepthStencilType CmdClearDepthStencil; + vkCmdResolveImageType CmdResolveImage; + vkCmdSetEventType CmdSetEvent; + vkCmdResetEventType CmdResetEvent; + vkCmdWaitEventsType CmdWaitEvents; + vkCmdPipelineBarrierType CmdPipelineBarrier; + vkCmdBeginQueryType CmdBeginQuery; + vkCmdEndQueryType CmdEndQuery; + vkCmdResetQueryPoolType CmdResetQueryPool; + vkCmdWriteTimestampType CmdWriteTimestamp; + vkCmdInitAtomicCountersType CmdInitAtomicCounters; + vkCmdLoadAtomicCountersType CmdLoadAtomicCounters; + vkCmdSaveAtomicCountersType CmdSaveAtomicCounters; + vkCreateFramebufferType CreateFramebuffer; + vkCreateRenderPassType CreateRenderPass; + vkCmdBeginRenderPassType CmdBeginRenderPass; + vkCmdEndRenderPassType CmdEndRenderPass; + vkDbgSetValidationLevelType DbgSetValidationLevel; + vkDbgRegisterMsgCallbackType DbgRegisterMsgCallback; + vkDbgUnregisterMsgCallbackType DbgUnregisterMsgCallback; + vkDbgSetMessageFilterType DbgSetMessageFilter; + vkDbgSetObjectTagType DbgSetObjectTag; + vkDbgSetGlobalOptionType DbgSetGlobalOption; + vkDbgSetDeviceOptionType DbgSetDeviceOption; + vkCmdDbgMarkerBeginType CmdDbgMarkerBegin; + vkCmdDbgMarkerEndType CmdDbgMarkerEnd; #if defined(__linux__) || defined(XCB_NVIDIA) - xglWsiX11AssociateConnectionType WsiX11AssociateConnection; - xglWsiX11GetMSCType WsiX11GetMSC; - xglWsiX11CreatePresentableImageType WsiX11CreatePresentableImage; - xglWsiX11QueuePresentType WsiX11QueuePresent; + vkWsiX11AssociateConnectionType WsiX11AssociateConnection; + vkWsiX11GetMSCType WsiX11GetMSC; + vkWsiX11CreatePresentableImageType WsiX11CreatePresentableImage; + vkWsiX11QueuePresentType WsiX11QueuePresent; #endif // WIN32 -} XGL_LAYER_DISPATCH_TABLE; +} VK_LAYER_DISPATCH_TABLE; // LL node for tree of dbg callback functions -typedef struct _XGL_LAYER_DBG_FUNCTION_NODE +typedef struct _VK_LAYER_DBG_FUNCTION_NODE { - XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback; + VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback; void *pUserData; - struct _XGL_LAYER_DBG_FUNCTION_NODE *pNext; -} XGL_LAYER_DBG_FUNCTION_NODE; + struct _VK_LAYER_DBG_FUNCTION_NODE *pNext; +} VK_LAYER_DBG_FUNCTION_NODE; -typedef enum _XGL_LAYER_DBG_ACTION +typedef enum _VK_LAYER_DBG_ACTION { - XGL_DBG_LAYER_ACTION_IGNORE = 0x0, - XGL_DBG_LAYER_ACTION_CALLBACK = 0x1, - XGL_DBG_LAYER_ACTION_LOG_MSG = 0x2, - XGL_DBG_LAYER_ACTION_BREAK = 0x4 -} XGL_LAYER_DBG_ACTION; + VK_DBG_LAYER_ACTION_IGNORE = 0x0, + VK_DBG_LAYER_ACTION_CALLBACK = 0x1, + VK_DBG_LAYER_ACTION_LOG_MSG = 0x2, + VK_DBG_LAYER_ACTION_BREAK = 0x4 +} VK_LAYER_DBG_ACTION; -typedef enum _XGL_LAYER_DBG_REPORT_LEVEL +typedef enum _VK_LAYER_DBG_REPORT_LEVEL { - XGL_DBG_LAYER_LEVEL_INFO = 0, - XGL_DBG_LAYER_LEVEL_WARN, - XGL_DBG_LAYER_LEVEL_PERF_WARN, - XGL_DBG_LAYER_LEVEL_ERROR, - XGL_DBG_LAYER_LEVEL_NONE, -} XGL_LAYER_DBG_REPORT_LEVEL; + VK_DBG_LAYER_LEVEL_INFO = 0, + VK_DBG_LAYER_LEVEL_WARN, + VK_DBG_LAYER_LEVEL_PERF_WARN, + VK_DBG_LAYER_LEVEL_ERROR, + VK_DBG_LAYER_LEVEL_NONE, +} VK_LAYER_DBG_REPORT_LEVEL; // ------------------------------------------------------------------------------------------------ // API functions diff --git a/include/xglPlatform.h b/include/xglPlatform.h index fcd3d591..526a1de8 100644 --- a/include/xglPlatform.h +++ b/include/xglPlatform.h @@ -1,5 +1,5 @@ // -// File: xglPlatform.h +// File: vkPlatform.h // /* ** Copyright (c) 2014 The Khronos Group Inc. @@ -25,8 +25,8 @@ */ -#ifndef __XGLPLATFORM_H__ -#define __XGLPLATFORM_H__ +#ifndef __VKPLATFORM_H__ +#define __VKPLATFORM_H__ #ifdef __cplusplus extern "C" @@ -43,8 +43,8 @@ extern "C" // Ensure we don't pick up min/max macros from Winddef.h #define NOMINMAX - // On Windows, XGLAPI should equate to the __stdcall convention - #define XGLAPI __stdcall + // On Windows, VKAPI should equate to the __stdcall convention + #define VKAPI __stdcall // C99: #ifndef __cplusplus @@ -52,8 +52,8 @@ extern "C" #define inline __inline #endif // __cplusplus #elif defined(__GNUC__) - // On other platforms using GCC, XGLAPI stays undefined - #define XGLAPI + // On other platforms using GCC, VKAPI stays undefined + #define VKAPI #else // Unsupported Platform! #error "Unsupported OS Platform detected!" @@ -61,7 +61,7 @@ extern "C" #include <stddef.h> -#if !defined(XGL_NO_STDINT_H) +#if !defined(VK_NO_STDINT_H) #if defined(_MSC_VER) && (_MSC_VER < 1600) typedef signed __int8 int8_t; typedef unsigned __int8 uint8_t; @@ -74,17 +74,17 @@ extern "C" #else #include <stdint.h> #endif -#endif // !defined(XGL_NO_STDINT_H) +#endif // !defined(VK_NO_STDINT_H) -typedef uint64_t XGL_GPU_SIZE; +typedef uint64_t VK_GPU_SIZE; typedef uint32_t bool32_t; -typedef uint32_t XGL_SAMPLE_MASK; -typedef uint32_t XGL_FLAGS; -typedef int32_t XGL_ENUM; +typedef uint32_t VK_SAMPLE_MASK; +typedef uint32_t VK_FLAGS; +typedef int32_t VK_ENUM; #ifdef __cplusplus } // extern "C" #endif // __cplusplus -#endif // __XGLPLATFORM_H__ +#endif // __VKPLATFORM_H__ diff --git a/include/xglWsiWinExt.h b/include/xglWsiWinExt.h index b93841b1..f3ee0f33 100644 --- a/include/xglWsiWinExt.h +++ b/include/xglWsiWinExt.h @@ -1,14 +1,14 @@ /* IN DEVELOPMENT. DO NOT SHIP. */ -#ifndef __XGLWSIWINEXT_H__ -#define __XGLWSIWINEXT_H__ +#ifndef __VKWSIWINEXT_H__ +#define __VKWSIWINEXT_H__ // This is just to get windows to build. // Need to replace with the declarations for Windows wsi. -typedef void XGL_WSI_X11_CONNECTION_INFO; +typedef void VK_WSI_X11_CONNECTION_INFO; typedef unsigned int xcb_window_t; typedef unsigned int xcb_randr_crtc_t; -typedef void XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO; -typedef void XGL_WSI_X11_PRESENT_INFO; +typedef void VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO; +typedef void VK_WSI_X11_PRESENT_INFO; -#endif // __XGLWSIWINEXT_H__ +#endif // __VKWSIWINEXT_H__ diff --git a/include/xglWsiX11Ext.h b/include/xglWsiX11Ext.h index 5235758d..f7046375 100644 --- a/include/xglWsiX11Ext.h +++ b/include/xglWsiX11Ext.h @@ -1,36 +1,36 @@ /* IN DEVELOPMENT. DO NOT SHIP. */ -#ifndef __XGLWSIX11EXT_H__ -#define __XGLWSIX11EXT_H__ +#ifndef __VKWSIX11EXT_H__ +#define __VKWSIX11EXT_H__ #include <xcb/xcb.h> #include <xcb/randr.h> -#include "xgl.h" +#include "vulkan.h" #ifdef __cplusplus extern "C" { #endif // __cplusplus -typedef struct _XGL_WSI_X11_CONNECTION_INFO { +typedef struct _VK_WSI_X11_CONNECTION_INFO { xcb_connection_t* pConnection; xcb_window_t root; xcb_randr_provider_t provider; -} XGL_WSI_X11_CONNECTION_INFO; +} VK_WSI_X11_CONNECTION_INFO; -typedef struct _XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO +typedef struct _VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO { - XGL_FORMAT format; - XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS - XGL_EXTENT2D extent; - XGL_FLAGS flags; -} XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO; + VK_FORMAT format; + VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS + VK_EXTENT2D extent; + VK_FLAGS flags; +} VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO; -typedef struct _XGL_WSI_X11_PRESENT_INFO +typedef struct _VK_WSI_X11_PRESENT_INFO { /* which window to present to */ xcb_window_t destWindow; - XGL_IMAGE srcImage; + VK_IMAGE srcImage; /** * After the command buffers in the queue have been completed, if the MSC @@ -49,7 +49,7 @@ typedef struct _XGL_WSI_X11_PRESENT_INFO * } * * In other words, either set \p target_msc to an absolute value (require - * xglWsiX11GetMSC(), potentially a round-trip to the server, to get the + * vkWsiX11GetMSC(), potentially a round-trip to the server, to get the * current MSC first), or set \p target_msc to zero and set a "swap * interval". * @@ -78,66 +78,66 @@ typedef struct _XGL_WSI_X11_PRESENT_INFO * be flipped to. */ bool32_t flip; -} XGL_WSI_X11_PRESENT_INFO; +} VK_WSI_X11_PRESENT_INFO; -typedef XGL_RESULT (XGLAPI *xglWsiX11AssociateConnectionType)(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo); -typedef XGL_RESULT (XGLAPI *xglWsiX11GetMSCType)(XGL_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc); -typedef XGL_RESULT (XGLAPI *xglWsiX11CreatePresentableImageType)(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem); -typedef XGL_RESULT (XGLAPI *xglWsiX11QueuePresentType)(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence); +typedef VK_RESULT (VKAPI *vkWsiX11AssociateConnectionType)(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); +typedef VK_RESULT (VKAPI *vkWsiX11GetMSCType)(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc); +typedef VK_RESULT (VKAPI *vkWsiX11CreatePresentableImageType)(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem); +typedef VK_RESULT (VKAPI *vkWsiX11QueuePresentType)(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence); /** * Associate an X11 connection with a GPU. This should be done before device * creation. If the device is already created, - * XGL_ERROR_DEVICE_ALREADY_CREATED is returned. + * VK_ERROR_DEVICE_ALREADY_CREATED is returned. * * Truth is, given a connection, we could find the associated GPU. But * without having a GPU as the first parameter, the loader could not find the * dispatch table. * - * This function is available when xglGetExtensionSupport says "XGL_WSI_X11" + * This function is available when vkGetExtensionSupport says "VK_WSI_X11" * is supported. */ -XGL_RESULT XGLAPI xglWsiX11AssociateConnection( - XGL_PHYSICAL_GPU gpu, - const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo); +VK_RESULT VKAPI vkWsiX11AssociateConnection( + VK_PHYSICAL_GPU gpu, + const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); /** * Return the current MSC (Media Stream Counter, incremented for each vblank) * of \p crtc. If crtc is \p XCB_NONE, a suitable CRTC is picked based on \p * win. */ -XGL_RESULT XGLAPI xglWsiX11GetMSC( - XGL_DEVICE device, +VK_RESULT VKAPI vkWsiX11GetMSC( + VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc); /** - * Create an XGL_IMAGE that can be presented. An XGL_GPU_MEMORY is created + * Create an VK_IMAGE that can be presented. An VK_GPU_MEMORY is created * and bound automatically. The memory returned can only be used in - * xglQueue[Add|Remove]MemReference. Destroying the memory or binding another memory to the + * vkQueue[Add|Remove]MemReference. Destroying the memory or binding another memory to the * image is not allowed. */ -XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage( - XGL_DEVICE device, - const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, - XGL_IMAGE* pImage, - XGL_GPU_MEMORY* pMem); +VK_RESULT VKAPI vkWsiX11CreatePresentableImage( + VK_DEVICE device, + const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, + VK_IMAGE* pImage, + VK_GPU_MEMORY* pMem); /** * Present an image to an X11 window. The presentation always occurs after * the command buffers in the queue have been completed, subject to other - * parameters specified in XGL_WSI_X11_PRESENT_INFO. + * parameters specified in VK_WSI_X11_PRESENT_INFO. * * Fence is reached when the presentation occurs. */ -XGL_RESULT XGLAPI xglWsiX11QueuePresent( - XGL_QUEUE queue, - const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, - XGL_FENCE fence); +VK_RESULT VKAPI vkWsiX11QueuePresent( + VK_QUEUE queue, + const VK_WSI_X11_PRESENT_INFO* pPresentInfo, + VK_FENCE fence); #ifdef __cplusplus } // extern "C" #endif // __cplusplus -#endif // __XGLWSIX11EXT_H__ +#endif // __VKWSIX11EXT_H__ |