From 6082a4d9ed91b53bc7642ea67399ca354366369e Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Tue, 14 Apr 2015 14:55:44 -0600 Subject: renaming: Move many xgl files to vk version --- .gitignore | 2 +- CMakeLists.txt | 14 +- demos/CMakeLists.txt | 10 +- demos/cube.c | 2 +- demos/tri.c | 2 +- demos/vulkaninfo.c | 697 +++++++++ demos/xglinfo.c | 697 --------- docs/vk_ds.dot | 180 +++ docs/vk_ds.png | Bin 0 -> 858990 bytes docs/vk_full_pipeline_ds.dot | 282 ++++ docs/vk_full_pipeline_ds.png | Bin 0 -> 1209173 bytes docs/vk_graphics_pipeline.dot | 105 ++ docs/vk_graphics_pipeline.png | Bin 0 -> 657320 bytes docs/xgl_ds.dot | 180 --- docs/xgl_ds.png | Bin 858990 -> 0 bytes docs/xgl_full_pipeline_ds.dot | 282 ---- docs/xgl_full_pipeline_ds.png | Bin 1209173 -> 0 bytes docs/xgl_graphics_pipeline.dot | 105 -- docs/xgl_graphics_pipeline.png | Bin 657320 -> 0 bytes icd/nulldrv/CMakeLists.txt | 16 +- include/vk.h | 3135 ------------------------------------- include/vulkan.h | 3325 ++++++++++++++++++++-------------------- include/xgl.h | 3060 ------------------------------------ include/xglDbg.h | 171 --- include/xglIcd.h | 32 - include/xglLayer.h | 187 --- include/xglPlatform.h | 90 -- include/xglWsiWinExt.h | 14 - include/xglWsiX11Ext.h | 143 -- layers/CMakeLists.txt | 12 +- layers/draw_state.cpp | 2 +- layers/glave_snapshot.h | 2 +- loader/CMakeLists.txt | 32 +- vk-generate.py | 484 ++++++ vk-layer-generate.py | 1539 +++++++++++++++++++ vk_helper.py | 2 +- vulkan.py | 1034 +++++++++++++ xgl-generate.py | 484 ------ xgl-layer-generate.py | 1539 ------------------- xgl.py | 1034 ------------- 40 files changed, 5994 insertions(+), 12901 deletions(-) create mode 100644 demos/vulkaninfo.c delete mode 100644 demos/xglinfo.c create mode 100644 docs/vk_ds.dot create mode 100644 docs/vk_ds.png create mode 100644 docs/vk_full_pipeline_ds.dot create mode 100644 docs/vk_full_pipeline_ds.png create mode 100644 docs/vk_graphics_pipeline.dot create mode 100644 docs/vk_graphics_pipeline.png delete mode 100644 docs/xgl_ds.dot delete mode 100644 docs/xgl_ds.png delete mode 100644 docs/xgl_full_pipeline_ds.dot delete mode 100644 docs/xgl_full_pipeline_ds.png delete mode 100644 docs/xgl_graphics_pipeline.dot delete mode 100644 docs/xgl_graphics_pipeline.png delete mode 100644 include/vk.h delete mode 100644 include/xgl.h delete mode 100644 include/xglDbg.h delete mode 100644 include/xglIcd.h delete mode 100644 include/xglLayer.h delete mode 100644 include/xglPlatform.h delete mode 100644 include/xglWsiWinExt.h delete mode 100644 include/xglWsiX11Ext.h create mode 100755 vk-generate.py create mode 100755 vk-layer-generate.py create mode 100755 vulkan.py delete mode 100755 xgl-generate.py delete mode 100755 xgl-layer-generate.py delete mode 100755 xgl.py diff --git a/.gitignore b/.gitignore index 07077421..08d00518 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,7 @@ CMakeFiles/ cmake_install.cmake Makefile __pycache__ -XGLConfig.h +VKConfig.h *.so *.so.* icd/common/libicd.a diff --git a/CMakeLists.txt b/CMakeLists.txt index 25a91f6c..4150af6f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,8 +1,8 @@ -# The name of our project is "XGL". CMakeLists files in this project can -# refer to the root source directory of the project as ${XGL_SOURCE_DIR} and -# to the root binary directory of the project as ${XGL_BINARY_DIR}. +# The name of our project is "VULKAN". CMakeLists files in this project can +# refer to the root source directory of the project as ${VULKAN_SOURCE_DIR} and +# to the root binary directory of the project as ${VULKAN_BINARY_DIR}. cmake_minimum_required(VERSION 2.8.11) -project (XGL) +project (VULKAN) # set (CMAKE_VERBOSE_MAKEFILE 1) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake") @@ -42,9 +42,9 @@ else() set(PYTHON_CMD "py") endif() -# loader: Generic XGL ICD loader -# icd: Device dependent (DD) XGL components -# tests: XGL tests +# loader: Generic VULKAN ICD loader +# icd: Device dependent (DD) VULKAN components +# tests: VULKAN tests add_subdirectory(loader) add_subdirectory(icd) if (NOT WIN32) diff --git a/demos/CMakeLists.txt b/demos/CMakeLists.txt index 19d8361e..0b6f3d03 100644 --- a/demos/CMakeLists.txt +++ b/demos/CMakeLists.txt @@ -20,10 +20,10 @@ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES") set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_PROTOTYPES") if(WIN32) - set (LIBRARIES "XGL") + set (LIBRARIES "vulkan") endif() if(NOT WIN32) - set (LIBRARIES "XGL") + set (LIBRARIES "vulkan") add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-vert.spv COMMAND ${GLSLANG_PREFIX}/build/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.vert COMMAND mv vert.spv ${CMAKE_BINARY_DIR}/demos/cube-vert.spv @@ -43,7 +43,7 @@ if(NOT WIN32) "${PROJECT_SOURCE_DIR}/icd/common" ) - link_libraries(${XCB_LIBRARIES} XGL png m) + link_libraries(${XCB_LIBRARIES} vulkan png m) endif() if(WIN32) include_directories ( @@ -59,8 +59,8 @@ else() set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DEXTERNAL_SPV") endif() -add_executable(xglinfo xglinfo.c) -target_link_libraries(xglinfo ${LIBRARIES}) +add_executable(vulkaninfo vulkaninfo.c) +target_link_libraries(vulkaninfo ${LIBRARIES}) add_executable(tri tri.c) target_link_libraries(tri ${LIBRARIES}) diff --git a/demos/cube.c b/demos/cube.c index df58990d..bea67ee1 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -1543,7 +1543,7 @@ static void demo_prepare_descriptor_set(struct demo *demo) view_info[i].view = demo->textures[i].view, view_info[i].layout = VK_IMAGE_LAYOUT_GENERAL; - combined_info[i].sampler = demo->textures[i].sampler; + combined_info[i].pSampler = demo->textures[i].sampler; combined_info[i].pImageView = &view_info[i]; } diff --git a/demos/tri.c b/demos/tri.c index cfb7f391..a1553c8d 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -1111,7 +1111,7 @@ static void demo_prepare_descriptor_set(struct demo *demo) view_info[i].view = demo->textures[i].view, view_info[i].layout = VK_IMAGE_LAYOUT_GENERAL; - combined_info[i].sampler = demo->textures[i].sampler; + combined_info[i].pSampler = demo->textures[i].sampler; combined_info[i].pImageView = &view_info[i]; } diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c new file mode 100644 index 00000000..80f238a6 --- /dev/null +++ b/demos/vulkaninfo.c @@ -0,0 +1,697 @@ +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +#include +#include +#include +#include +#include + +#include + +#define ERR(err) printf("%s:%d: failed with %s\n", \ + __FILE__, __LINE__, vk_result_string(err)); + +#define ERR_EXIT(err) do { ERR(err); exit(-1); } while (0) + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) + +#define MAX_GPUS 8 + +#define MAX_QUEUE_TYPES 5 + +struct app_gpu; + +struct app_dev { + struct app_gpu *gpu; /* point back to the GPU */ + + VK_DEVICE obj; + + + VK_FORMAT_PROPERTIES format_props[VK_NUM_FMT]; +}; + +struct app_gpu { + uint32_t id; + VK_PHYSICAL_GPU obj; + + VK_PHYSICAL_GPU_PROPERTIES props; + VK_PHYSICAL_GPU_PERFORMANCE perf; + + uint32_t queue_count; + VK_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props; + VK_DEVICE_QUEUE_CREATE_INFO *queue_reqs; + + VK_PHYSICAL_GPU_MEMORY_PROPERTIES memory_props; + + uint32_t extension_count; + char **extensions; + + struct app_dev dev; +}; + +static const char *vk_result_string(VK_RESULT err) +{ + switch (err) { +#define STR(r) case r: return #r + STR(VK_SUCCESS); + STR(VK_UNSUPPORTED); + STR(VK_NOT_READY); + STR(VK_TIMEOUT); + STR(VK_EVENT_SET); + STR(VK_EVENT_RESET); + STR(VK_ERROR_UNKNOWN); + STR(VK_ERROR_UNAVAILABLE); + STR(VK_ERROR_INITIALIZATION_FAILED); + STR(VK_ERROR_OUT_OF_MEMORY); + STR(VK_ERROR_OUT_OF_GPU_MEMORY); + STR(VK_ERROR_DEVICE_ALREADY_CREATED); + STR(VK_ERROR_DEVICE_LOST); + STR(VK_ERROR_INVALID_POINTER); + STR(VK_ERROR_INVALID_VALUE); + STR(VK_ERROR_INVALID_HANDLE); + STR(VK_ERROR_INVALID_ORDINAL); + STR(VK_ERROR_INVALID_MEMORY_SIZE); + STR(VK_ERROR_INVALID_EXTENSION); + STR(VK_ERROR_INVALID_FLAGS); + STR(VK_ERROR_INVALID_ALIGNMENT); + STR(VK_ERROR_INVALID_FORMAT); + STR(VK_ERROR_INVALID_IMAGE); + STR(VK_ERROR_INVALID_DESCRIPTOR_SET_DATA); + STR(VK_ERROR_INVALID_QUEUE_TYPE); + STR(VK_ERROR_INVALID_OBJECT_TYPE); + STR(VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION); + STR(VK_ERROR_BAD_SHADER_CODE); + STR(VK_ERROR_BAD_PIPELINE_DATA); + STR(VK_ERROR_TOO_MANY_MEMORY_REFERENCES); + STR(VK_ERROR_NOT_MAPPABLE); + STR(VK_ERROR_MEMORY_MAP_FAILED); + STR(VK_ERROR_MEMORY_UNMAP_FAILED); + STR(VK_ERROR_INCOMPATIBLE_DEVICE); + STR(VK_ERROR_INCOMPATIBLE_DRIVER); + STR(VK_ERROR_INCOMPLETE_COMMAND_BUFFER); + STR(VK_ERROR_BUILDING_COMMAND_BUFFER); + STR(VK_ERROR_MEMORY_NOT_BOUND); + STR(VK_ERROR_INCOMPATIBLE_QUEUE); + STR(VK_ERROR_NOT_SHAREABLE); +#undef STR + default: return "UNKNOWN_RESULT"; + } +} + +static const char *vk_gpu_type_string(VK_PHYSICAL_GPU_TYPE type) +{ + switch (type) { +#define STR(r) case VK_GPU_TYPE_ ##r: return #r + STR(OTHER); + STR(INTEGRATED); + STR(DISCRETE); + STR(VIRTUAL); +#undef STR + default: return "UNKNOWN_GPU"; + } +} + +static const char *vk_format_string(VK_FORMAT fmt) +{ + switch (fmt) { +#define STR(r) case VK_FMT_ ##r: return #r + STR(UNDEFINED); + STR(R4G4_UNORM); + STR(R4G4_USCALED); + STR(R4G4B4A4_UNORM); + STR(R4G4B4A4_USCALED); + STR(R5G6B5_UNORM); + STR(R5G6B5_USCALED); + STR(R5G5B5A1_UNORM); + STR(R5G5B5A1_USCALED); + STR(R8_UNORM); + STR(R8_SNORM); + STR(R8_USCALED); + STR(R8_SSCALED); + STR(R8_UINT); + STR(R8_SINT); + STR(R8_SRGB); + STR(R8G8_UNORM); + STR(R8G8_SNORM); + STR(R8G8_USCALED); + STR(R8G8_SSCALED); + STR(R8G8_UINT); + STR(R8G8_SINT); + STR(R8G8_SRGB); + STR(R8G8B8_UNORM); + STR(R8G8B8_SNORM); + STR(R8G8B8_USCALED); + STR(R8G8B8_SSCALED); + STR(R8G8B8_UINT); + STR(R8G8B8_SINT); + STR(R8G8B8_SRGB); + STR(R8G8B8A8_UNORM); + STR(R8G8B8A8_SNORM); + STR(R8G8B8A8_USCALED); + STR(R8G8B8A8_SSCALED); + STR(R8G8B8A8_UINT); + STR(R8G8B8A8_SINT); + STR(R8G8B8A8_SRGB); + STR(R10G10B10A2_UNORM); + STR(R10G10B10A2_SNORM); + STR(R10G10B10A2_USCALED); + STR(R10G10B10A2_SSCALED); + STR(R10G10B10A2_UINT); + STR(R10G10B10A2_SINT); + STR(R16_UNORM); + STR(R16_SNORM); + STR(R16_USCALED); + STR(R16_SSCALED); + STR(R16_UINT); + STR(R16_SINT); + STR(R16_SFLOAT); + STR(R16G16_UNORM); + STR(R16G16_SNORM); + STR(R16G16_USCALED); + STR(R16G16_SSCALED); + STR(R16G16_UINT); + STR(R16G16_SINT); + STR(R16G16_SFLOAT); + STR(R16G16B16_UNORM); + STR(R16G16B16_SNORM); + STR(R16G16B16_USCALED); + STR(R16G16B16_SSCALED); + STR(R16G16B16_UINT); + STR(R16G16B16_SINT); + STR(R16G16B16_SFLOAT); + STR(R16G16B16A16_UNORM); + STR(R16G16B16A16_SNORM); + STR(R16G16B16A16_USCALED); + STR(R16G16B16A16_SSCALED); + STR(R16G16B16A16_UINT); + STR(R16G16B16A16_SINT); + STR(R16G16B16A16_SFLOAT); + STR(R32_UINT); + STR(R32_SINT); + STR(R32_SFLOAT); + STR(R32G32_UINT); + STR(R32G32_SINT); + STR(R32G32_SFLOAT); + STR(R32G32B32_UINT); + STR(R32G32B32_SINT); + STR(R32G32B32_SFLOAT); + STR(R32G32B32A32_UINT); + STR(R32G32B32A32_SINT); + STR(R32G32B32A32_SFLOAT); + STR(R64_SFLOAT); + STR(R64G64_SFLOAT); + STR(R64G64B64_SFLOAT); + STR(R64G64B64A64_SFLOAT); + STR(R11G11B10_UFLOAT); + STR(R9G9B9E5_UFLOAT); + STR(D16_UNORM); + STR(D24_UNORM); + STR(D32_SFLOAT); + STR(S8_UINT); + STR(D16_UNORM_S8_UINT); + STR(D24_UNORM_S8_UINT); + STR(D32_SFLOAT_S8_UINT); + STR(BC1_RGB_UNORM); + STR(BC1_RGB_SRGB); + STR(BC2_UNORM); + STR(BC2_SRGB); + STR(BC3_UNORM); + STR(BC3_SRGB); + STR(BC4_UNORM); + STR(BC4_SNORM); + STR(BC5_UNORM); + STR(BC5_SNORM); + STR(BC6H_UFLOAT); + STR(BC6H_SFLOAT); + STR(BC7_UNORM); + STR(BC7_SRGB); + STR(ETC2_R8G8B8_UNORM); + STR(ETC2_R8G8B8A1_UNORM); + STR(ETC2_R8G8B8A8_UNORM); + STR(EAC_R11_UNORM); + STR(EAC_R11_SNORM); + STR(EAC_R11G11_UNORM); + STR(EAC_R11G11_SNORM); + STR(ASTC_4x4_UNORM); + STR(ASTC_4x4_SRGB); + STR(ASTC_5x4_UNORM); + STR(ASTC_5x4_SRGB); + STR(ASTC_5x5_UNORM); + STR(ASTC_5x5_SRGB); + STR(ASTC_6x5_UNORM); + STR(ASTC_6x5_SRGB); + STR(ASTC_6x6_UNORM); + STR(ASTC_6x6_SRGB); + STR(ASTC_8x5_UNORM); + STR(ASTC_8x5_SRGB); + STR(ASTC_8x6_UNORM); + STR(ASTC_8x6_SRGB); + STR(ASTC_8x8_UNORM); + STR(ASTC_8x8_SRGB); + STR(ASTC_10x5_UNORM); + STR(ASTC_10x5_SRGB); + STR(ASTC_10x6_UNORM); + STR(ASTC_10x6_SRGB); + STR(ASTC_10x8_UNORM); + STR(ASTC_10x8_SRGB); + STR(ASTC_10x10_UNORM); + STR(ASTC_10x10_SRGB); + STR(ASTC_12x10_UNORM); + STR(ASTC_12x10_SRGB); + STR(ASTC_12x12_UNORM); + STR(ASTC_12x12_SRGB); + STR(B5G6R5_UNORM); + STR(B5G6R5_USCALED); + STR(B8G8R8_UNORM); + STR(B8G8R8_SNORM); + STR(B8G8R8_USCALED); + STR(B8G8R8_SSCALED); + STR(B8G8R8_UINT); + STR(B8G8R8_SINT); + STR(B8G8R8_SRGB); + STR(B8G8R8A8_UNORM); + STR(B8G8R8A8_SNORM); + STR(B8G8R8A8_USCALED); + STR(B8G8R8A8_SSCALED); + STR(B8G8R8A8_UINT); + STR(B8G8R8A8_SINT); + STR(B8G8R8A8_SRGB); + STR(B10G10R10A2_UNORM); + STR(B10G10R10A2_SNORM); + STR(B10G10R10A2_USCALED); + STR(B10G10R10A2_SSCALED); + STR(B10G10R10A2_UINT); + STR(B10G10R10A2_SINT); +#undef STR + default: return "UNKNOWN_FORMAT"; + } +} + +static void app_dev_init_formats(struct app_dev *dev) +{ + VK_FORMAT f; + + for (f = 0; f < VK_NUM_FMT; f++) { + const VK_FORMAT fmt = f; + VK_RESULT err; + size_t size = sizeof(dev->format_props[f]); + + err = vkGetFormatInfo(dev->obj, fmt, + VK_INFO_TYPE_FORMAT_PROPERTIES, + &size, &dev->format_props[f]); + if (err) { + memset(&dev->format_props[f], 0, + sizeof(dev->format_props[f])); + } + else if (size != sizeof(dev->format_props[f])) { + ERR_EXIT(VK_ERROR_UNKNOWN); + } + } +} + +static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu) +{ + VK_DEVICE_CREATE_INFO info = { + .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + .pNext = NULL, + .queueRecordCount = 0, + .pRequestedQueues = NULL, + .extensionCount = 0, + .ppEnabledExtensionNames = NULL, + .maxValidationLevel = VK_VALIDATION_LEVEL_END_RANGE, + .flags = VK_DEVICE_CREATE_VALIDATION_BIT, + }; + VK_RESULT err; + + /* request all queues */ + info.queueRecordCount = gpu->queue_count; + info.pRequestedQueues = gpu->queue_reqs; + + /* enable all extensions */ + info.extensionCount = gpu->extension_count; + info.ppEnabledExtensionNames = (const char*const*) gpu->extensions; + dev->gpu = gpu; + err = vkCreateDevice(gpu->obj, &info, &dev->obj); + if (err) + ERR_EXIT(err); + +} + +static void app_dev_destroy(struct app_dev *dev) +{ + vkDestroyDevice(dev->obj); +} + +static void app_gpu_init_extensions(struct app_gpu *gpu) +{ + VK_RESULT err; + uint32_t i; + + static char *known_extensions[] = { + "VK_WSI_X11", + }; + + for (i = 0; i < ARRAY_SIZE(known_extensions); i++) { + err = vkGetExtensionSupport(gpu->obj, known_extensions[i]); + if (!err) + gpu->extension_count++; + } + + gpu->extensions = + malloc(sizeof(gpu->extensions[0]) * gpu->extension_count); + if (!gpu->extensions) + ERR_EXIT(VK_ERROR_OUT_OF_MEMORY); + + gpu->extension_count = 0; + for (i = 0; i < ARRAY_SIZE(known_extensions); i++) { + err = vkGetExtensionSupport(gpu->obj, known_extensions[i]); + if (!err) + gpu->extensions[gpu->extension_count++] = known_extensions[i]; + } +} + +static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VK_PHYSICAL_GPU obj) +{ + size_t size; + VK_RESULT err; + uint32_t i; + + memset(gpu, 0, sizeof(*gpu)); + + gpu->id = id; + gpu->obj = obj; + size = sizeof(gpu->props); + err = vkGetGpuInfo(gpu->obj, + VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, + &size, &gpu->props); + if (err || size != sizeof(gpu->props)) + ERR_EXIT(err); + + size = sizeof(gpu->perf); + err = vkGetGpuInfo(gpu->obj, + VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE, + &size, &gpu->perf); + if (err || size != sizeof(gpu->perf)) + ERR_EXIT(err); + + /* get queue count */ + err = vkGetGpuInfo(gpu->obj, + VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, + &size, NULL); + if (err || size % sizeof(gpu->queue_props[0])) + ERR_EXIT(err); + gpu->queue_count = (uint32_t) (size / sizeof(gpu->queue_props[0])); + + gpu->queue_props = + malloc(sizeof(gpu->queue_props[0]) * gpu->queue_count); + size = sizeof(gpu->queue_props[0]) * gpu->queue_count; + if (!gpu->queue_props) + ERR_EXIT(VK_ERROR_OUT_OF_MEMORY); + err = vkGetGpuInfo(gpu->obj, + VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, + &size, gpu->queue_props); + if (err || size != sizeof(gpu->queue_props[0]) * gpu->queue_count) + ERR_EXIT(err); + + /* set up queue requests */ + size = sizeof(*gpu->queue_reqs) * gpu->queue_count; + gpu->queue_reqs = malloc(sizeof(*gpu->queue_reqs) * gpu->queue_count); + if (!gpu->queue_reqs) + ERR_EXIT(VK_ERROR_OUT_OF_MEMORY); + for (i = 0; i < gpu->queue_count; i++) { + gpu->queue_reqs[i].queueNodeIndex = i; + gpu->queue_reqs[i].queueCount = gpu->queue_props[i].queueCount; + } + + size = sizeof(gpu->memory_props); + err = vkGetGpuInfo(gpu->obj, + VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, + &size, &gpu->memory_props); + if (err || size != sizeof(gpu->memory_props)) + ERR_EXIT(err); + + app_gpu_init_extensions(gpu); + app_dev_init(&gpu->dev, gpu); + app_dev_init_formats(&gpu->dev); +} + +static void app_gpu_destroy(struct app_gpu *gpu) +{ + app_dev_destroy(&gpu->dev); + free(gpu->extensions); + free(gpu->queue_reqs); + free(gpu->queue_props); +} + +static void app_dev_dump_format_props(const struct app_dev *dev, VK_FORMAT fmt) +{ + const VK_FORMAT_PROPERTIES *props = &dev->format_props[fmt]; + struct { + const char *name; + VK_FLAGS flags; + } tilings[2]; + uint32_t i; + + if (!props->linearTilingFeatures && !props->optimalTilingFeatures) + return; + + tilings[0].name = "linear"; + tilings[0].flags = props->linearTilingFeatures; + tilings[1].name = "optimal"; + tilings[1].flags = props->optimalTilingFeatures; + + printf("FORMAT_%s\n", vk_format_string(fmt)); + for (i = 0; i < ARRAY_SIZE(tilings); i++) { + if (!tilings[i].flags) + continue; + + printf("\t%s tiling image =%s%s%s\n", tilings[i].name, + (tilings[i].flags & VK_FORMAT_IMAGE_SHADER_READ_BIT) ? " read" : "", + (tilings[i].flags & VK_FORMAT_IMAGE_SHADER_WRITE_BIT) ? " write" : "", + (tilings[i].flags & VK_FORMAT_IMAGE_COPY_BIT) ? " copy" : ""); + printf("\t%s tiling memory =%s\n", tilings[i].name, + (tilings[i].flags & VK_FORMAT_MEMORY_SHADER_ACCESS_BIT) ? " access" : ""); + printf("\t%s tiling attachment =%s%s%s%s%s\n", tilings[i].name, + (tilings[i].flags & VK_FORMAT_COLOR_ATTACHMENT_WRITE_BIT) ? " color" : "", + (tilings[i].flags & VK_FORMAT_COLOR_ATTACHMENT_BLEND_BIT) ? " blend" : "", + (tilings[i].flags & VK_FORMAT_DEPTH_ATTACHMENT_BIT) ? " depth" : "", + (tilings[i].flags & VK_FORMAT_STENCIL_ATTACHMENT_BIT) ? " stencil" : "", + (tilings[i].flags & VK_FORMAT_MSAA_ATTACHMENT_BIT) ? " msaa" : ""); + printf("\t%s tiling conversion = %u\n", tilings[i].name, + (bool) (tilings[i].flags & VK_FORMAT_CONVERSION_BIT)); + } +} + + +static void +app_dev_dump(const struct app_dev *dev) +{ + VK_FORMAT fmt; + + for (fmt = 0; fmt < VK_NUM_FMT; fmt++) { + app_dev_dump_format_props(dev, fmt); + } +} + +static void app_gpu_dump_multi_compat(const struct app_gpu *gpu, const struct app_gpu *other, + const VK_GPU_COMPATIBILITY_INFO *info) +{ + printf("VK_GPU_COMPATIBILITY_INFO[GPU%d]\n", other->id); + +#define TEST(info, b) printf(#b " = %u\n", (bool) (info->compatibilityFlags & VK_GPU_COMPAT_ ##b## _BIT)) + TEST(info, ASIC_FEATURES); + TEST(info, IQ_MATCH); + TEST(info, PEER_TRANSFER); + TEST(info, SHARED_MEMORY); + TEST(info, SHARED_SYNC); + TEST(info, SHARED_GPU0_DISPLAY); + TEST(info, SHARED_GPU1_DISPLAY); +#undef TEST +} + +static void app_gpu_multi_compat(struct app_gpu *gpus, uint32_t gpu_count) +{ + VK_RESULT err; + uint32_t i, j; + + for (i = 0; i < gpu_count; i++) { + for (j = 0; j < gpu_count; j++) { + VK_GPU_COMPATIBILITY_INFO info; + + if (i == j) + continue; + + err = vkGetMultiGpuCompatibility(gpus[i].obj, + gpus[j].obj, &info); + if (err) + ERR_EXIT(err); + + app_gpu_dump_multi_compat(&gpus[i], &gpus[j], &info); + } + } +} + +static void app_gpu_dump_props(const struct app_gpu *gpu) +{ + const VK_PHYSICAL_GPU_PROPERTIES *props = &gpu->props; + + printf("VK_PHYSICAL_GPU_PROPERTIES\n"); + printf("\tapiVersion = %u\n", props->apiVersion); + printf("\tdriverVersion = %u\n", props->driverVersion); + printf("\tvendorId = 0x%04x\n", props->vendorId); + printf("\tdeviceId = 0x%04x\n", props->deviceId); + printf("\tgpuType = %s\n", vk_gpu_type_string(props->gpuType)); + printf("\tgpuName = %s\n", props->gpuName); + printf("\tmaxInlineMemoryUpdateSize = %zu\n", props->maxInlineMemoryUpdateSize); + printf("\tmaxBoundDescriptorSets = %u\n", props->maxBoundDescriptorSets); + printf("\tmaxThreadGroupSize = %u\n", props->maxThreadGroupSize); + printf("\ttimestampFrequency = %lu\n", props->timestampFrequency); + printf("\tmultiColorAttachmentClears = %u\n", props->multiColorAttachmentClears); +} + +static void app_gpu_dump_perf(const struct app_gpu *gpu) +{ + const VK_PHYSICAL_GPU_PERFORMANCE *perf = &gpu->perf; + + printf("VK_PHYSICAL_GPU_PERFORMANCE\n"); + printf("\tmaxGpuClock = %f\n", perf->maxGpuClock); + printf("\taluPerClock = %f\n", perf->aluPerClock); + printf("\ttexPerClock = %f\n", perf->texPerClock); + printf("\tprimsPerClock = %f\n", perf->primsPerClock); + printf("\tpixelsPerClock = %f\n", perf->pixelsPerClock); +} + +static void app_gpu_dump_extensions(const struct app_gpu *gpu) +{ + uint32_t i; + printf("Extensions"); + printf("\tcount = %d\n", gpu->extension_count); + printf("\t"); + for (i=0; i< gpu->extension_count; i++) { + if (i>0) + printf(", "); // separator between extension names + printf("%s", gpu->extensions[i]); + } + printf("\n"); +} + +static void app_gpu_dump_queue_props(const struct app_gpu *gpu, uint32_t id) +{ + const VK_PHYSICAL_GPU_QUEUE_PROPERTIES *props = &gpu->queue_props[id]; + + printf("VK_PHYSICAL_GPU_QUEUE_PROPERTIES[%d]\n", id); + printf("\tqueueFlags = %c%c%c%c\n", + (props->queueFlags & VK_QUEUE_GRAPHICS_BIT) ? 'G' : '.', + (props->queueFlags & VK_QUEUE_COMPUTE_BIT) ? 'C' : '.', + (props->queueFlags & VK_QUEUE_DMA_BIT) ? 'D' : '.', + (props->queueFlags & VK_QUEUE_EXTENDED_BIT) ? 'X' : '.'); + printf("\tqueueCount = %u\n", props->queueCount); + printf("\tmaxAtomicCounters = %u\n", props->maxAtomicCounters); + printf("\tsupportsTimestamps = %u\n", props->supportsTimestamps); + printf("\tmaxMemReferences = %u\n", props->maxMemReferences); +} + +static void app_gpu_dump_memory_props(const struct app_gpu *gpu) +{ + const VK_PHYSICAL_GPU_MEMORY_PROPERTIES *props = &gpu->memory_props; + + printf("VK_PHYSICAL_GPU_MEMORY_PROPERTIES\n"); + printf("\tsupportsMigration = %u\n", props->supportsMigration); + printf("\tsupportsPinning = %u\n", props->supportsPinning); +} + +static void app_gpu_dump(const struct app_gpu *gpu) +{ + uint32_t i; + + printf("GPU%u\n", gpu->id); + app_gpu_dump_props(gpu); + printf("\n"); + app_gpu_dump_extensions(gpu); + printf("\n"); + app_gpu_dump_perf(gpu); + printf("\n"); + for (i = 0; i < gpu->queue_count; i++) { + app_gpu_dump_queue_props(gpu, i); + printf("\n"); + } + app_gpu_dump_memory_props(gpu); + printf("\n"); + app_dev_dump(&gpu->dev); +} + +int main(int argc, char **argv) +{ + static const VK_APPLICATION_INFO app_info = { + .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, + .pNext = NULL, + .pAppName = "vkinfo", + .appVersion = 1, + .pEngineName = "vkinfo", + .engineVersion = 1, + .apiVersion = VK_API_VERSION, + }; + static const VK_INSTANCE_CREATE_INFO inst_info = { + .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + .pNext = NULL, + .pAppInfo = &app_info, + .pAllocCb = NULL, + .extensionCount = 0, + .ppEnabledExtensionNames = NULL, + }; + struct app_gpu gpus[MAX_GPUS]; + VK_PHYSICAL_GPU objs[MAX_GPUS]; + VK_INSTANCE inst; + uint32_t gpu_count, i; + VK_RESULT err; + + err = vkCreateInstance(&inst_info, &inst); + if (err == VK_ERROR_INCOMPATIBLE_DRIVER) { + printf("Cannot find a compatible Vulkan installable client driver " + "(ICD).\nExiting ...\n"); + fflush(stdout); + exit(1); + } else if (err) { + + ERR_EXIT(err); + } + err = vkEnumerateGpus(inst, MAX_GPUS, &gpu_count, objs); + if (err) + ERR_EXIT(err); + + for (i = 0; i < gpu_count; i++) { + app_gpu_init(&gpus[i], i, objs[i]); + app_gpu_dump(&gpus[i]); + printf("\n\n"); + } + + app_gpu_multi_compat(gpus, gpu_count); + + for (i = 0; i < gpu_count; i++) + app_gpu_destroy(&gpus[i]); + + vkDestroyInstance(inst); + + return 0; +} diff --git a/demos/xglinfo.c b/demos/xglinfo.c deleted file mode 100644 index 80f238a6..00000000 --- a/demos/xglinfo.c +++ /dev/null @@ -1,697 +0,0 @@ -/* - * Vulkan - * - * Copyright (C) 2014 LunarG, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER - * DEALINGS IN THE SOFTWARE. - */ -#include -#include -#include -#include -#include - -#include - -#define ERR(err) printf("%s:%d: failed with %s\n", \ - __FILE__, __LINE__, vk_result_string(err)); - -#define ERR_EXIT(err) do { ERR(err); exit(-1); } while (0) - -#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) - -#define MAX_GPUS 8 - -#define MAX_QUEUE_TYPES 5 - -struct app_gpu; - -struct app_dev { - struct app_gpu *gpu; /* point back to the GPU */ - - VK_DEVICE obj; - - - VK_FORMAT_PROPERTIES format_props[VK_NUM_FMT]; -}; - -struct app_gpu { - uint32_t id; - VK_PHYSICAL_GPU obj; - - VK_PHYSICAL_GPU_PROPERTIES props; - VK_PHYSICAL_GPU_PERFORMANCE perf; - - uint32_t queue_count; - VK_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props; - VK_DEVICE_QUEUE_CREATE_INFO *queue_reqs; - - VK_PHYSICAL_GPU_MEMORY_PROPERTIES memory_props; - - uint32_t extension_count; - char **extensions; - - struct app_dev dev; -}; - -static const char *vk_result_string(VK_RESULT err) -{ - switch (err) { -#define STR(r) case r: return #r - STR(VK_SUCCESS); - STR(VK_UNSUPPORTED); - STR(VK_NOT_READY); - STR(VK_TIMEOUT); - STR(VK_EVENT_SET); - STR(VK_EVENT_RESET); - STR(VK_ERROR_UNKNOWN); - STR(VK_ERROR_UNAVAILABLE); - STR(VK_ERROR_INITIALIZATION_FAILED); - STR(VK_ERROR_OUT_OF_MEMORY); - STR(VK_ERROR_OUT_OF_GPU_MEMORY); - STR(VK_ERROR_DEVICE_ALREADY_CREATED); - STR(VK_ERROR_DEVICE_LOST); - STR(VK_ERROR_INVALID_POINTER); - STR(VK_ERROR_INVALID_VALUE); - STR(VK_ERROR_INVALID_HANDLE); - STR(VK_ERROR_INVALID_ORDINAL); - STR(VK_ERROR_INVALID_MEMORY_SIZE); - STR(VK_ERROR_INVALID_EXTENSION); - STR(VK_ERROR_INVALID_FLAGS); - STR(VK_ERROR_INVALID_ALIGNMENT); - STR(VK_ERROR_INVALID_FORMAT); - STR(VK_ERROR_INVALID_IMAGE); - STR(VK_ERROR_INVALID_DESCRIPTOR_SET_DATA); - STR(VK_ERROR_INVALID_QUEUE_TYPE); - STR(VK_ERROR_INVALID_OBJECT_TYPE); - STR(VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION); - STR(VK_ERROR_BAD_SHADER_CODE); - STR(VK_ERROR_BAD_PIPELINE_DATA); - STR(VK_ERROR_TOO_MANY_MEMORY_REFERENCES); - STR(VK_ERROR_NOT_MAPPABLE); - STR(VK_ERROR_MEMORY_MAP_FAILED); - STR(VK_ERROR_MEMORY_UNMAP_FAILED); - STR(VK_ERROR_INCOMPATIBLE_DEVICE); - STR(VK_ERROR_INCOMPATIBLE_DRIVER); - STR(VK_ERROR_INCOMPLETE_COMMAND_BUFFER); - STR(VK_ERROR_BUILDING_COMMAND_BUFFER); - STR(VK_ERROR_MEMORY_NOT_BOUND); - STR(VK_ERROR_INCOMPATIBLE_QUEUE); - STR(VK_ERROR_NOT_SHAREABLE); -#undef STR - default: return "UNKNOWN_RESULT"; - } -} - -static const char *vk_gpu_type_string(VK_PHYSICAL_GPU_TYPE type) -{ - switch (type) { -#define STR(r) case VK_GPU_TYPE_ ##r: return #r - STR(OTHER); - STR(INTEGRATED); - STR(DISCRETE); - STR(VIRTUAL); -#undef STR - default: return "UNKNOWN_GPU"; - } -} - -static const char *vk_format_string(VK_FORMAT fmt) -{ - switch (fmt) { -#define STR(r) case VK_FMT_ ##r: return #r - STR(UNDEFINED); - STR(R4G4_UNORM); - STR(R4G4_USCALED); - STR(R4G4B4A4_UNORM); - STR(R4G4B4A4_USCALED); - STR(R5G6B5_UNORM); - STR(R5G6B5_USCALED); - STR(R5G5B5A1_UNORM); - STR(R5G5B5A1_USCALED); - STR(R8_UNORM); - STR(R8_SNORM); - STR(R8_USCALED); - STR(R8_SSCALED); - STR(R8_UINT); - STR(R8_SINT); - STR(R8_SRGB); - STR(R8G8_UNORM); - STR(R8G8_SNORM); - STR(R8G8_USCALED); - STR(R8G8_SSCALED); - STR(R8G8_UINT); - STR(R8G8_SINT); - STR(R8G8_SRGB); - STR(R8G8B8_UNORM); - STR(R8G8B8_SNORM); - STR(R8G8B8_USCALED); - STR(R8G8B8_SSCALED); - STR(R8G8B8_UINT); - STR(R8G8B8_SINT); - STR(R8G8B8_SRGB); - STR(R8G8B8A8_UNORM); - STR(R8G8B8A8_SNORM); - STR(R8G8B8A8_USCALED); - STR(R8G8B8A8_SSCALED); - STR(R8G8B8A8_UINT); - STR(R8G8B8A8_SINT); - STR(R8G8B8A8_SRGB); - STR(R10G10B10A2_UNORM); - STR(R10G10B10A2_SNORM); - STR(R10G10B10A2_USCALED); - STR(R10G10B10A2_SSCALED); - STR(R10G10B10A2_UINT); - STR(R10G10B10A2_SINT); - STR(R16_UNORM); - STR(R16_SNORM); - STR(R16_USCALED); - STR(R16_SSCALED); - STR(R16_UINT); - STR(R16_SINT); - STR(R16_SFLOAT); - STR(R16G16_UNORM); - STR(R16G16_SNORM); - STR(R16G16_USCALED); - STR(R16G16_SSCALED); - STR(R16G16_UINT); - STR(R16G16_SINT); - STR(R16G16_SFLOAT); - STR(R16G16B16_UNORM); - STR(R16G16B16_SNORM); - STR(R16G16B16_USCALED); - STR(R16G16B16_SSCALED); - STR(R16G16B16_UINT); - STR(R16G16B16_SINT); - STR(R16G16B16_SFLOAT); - STR(R16G16B16A16_UNORM); - STR(R16G16B16A16_SNORM); - STR(R16G16B16A16_USCALED); - STR(R16G16B16A16_SSCALED); - STR(R16G16B16A16_UINT); - STR(R16G16B16A16_SINT); - STR(R16G16B16A16_SFLOAT); - STR(R32_UINT); - STR(R32_SINT); - STR(R32_SFLOAT); - STR(R32G32_UINT); - STR(R32G32_SINT); - STR(R32G32_SFLOAT); - STR(R32G32B32_UINT); - STR(R32G32B32_SINT); - STR(R32G32B32_SFLOAT); - STR(R32G32B32A32_UINT); - STR(R32G32B32A32_SINT); - STR(R32G32B32A32_SFLOAT); - STR(R64_SFLOAT); - STR(R64G64_SFLOAT); - STR(R64G64B64_SFLOAT); - STR(R64G64B64A64_SFLOAT); - STR(R11G11B10_UFLOAT); - STR(R9G9B9E5_UFLOAT); - STR(D16_UNORM); - STR(D24_UNORM); - STR(D32_SFLOAT); - STR(S8_UINT); - STR(D16_UNORM_S8_UINT); - STR(D24_UNORM_S8_UINT); - STR(D32_SFLOAT_S8_UINT); - STR(BC1_RGB_UNORM); - STR(BC1_RGB_SRGB); - STR(BC2_UNORM); - STR(BC2_SRGB); - STR(BC3_UNORM); - STR(BC3_SRGB); - STR(BC4_UNORM); - STR(BC4_SNORM); - STR(BC5_UNORM); - STR(BC5_SNORM); - STR(BC6H_UFLOAT); - STR(BC6H_SFLOAT); - STR(BC7_UNORM); - STR(BC7_SRGB); - STR(ETC2_R8G8B8_UNORM); - STR(ETC2_R8G8B8A1_UNORM); - STR(ETC2_R8G8B8A8_UNORM); - STR(EAC_R11_UNORM); - STR(EAC_R11_SNORM); - STR(EAC_R11G11_UNORM); - STR(EAC_R11G11_SNORM); - STR(ASTC_4x4_UNORM); - STR(ASTC_4x4_SRGB); - STR(ASTC_5x4_UNORM); - STR(ASTC_5x4_SRGB); - STR(ASTC_5x5_UNORM); - STR(ASTC_5x5_SRGB); - STR(ASTC_6x5_UNORM); - STR(ASTC_6x5_SRGB); - STR(ASTC_6x6_UNORM); - STR(ASTC_6x6_SRGB); - STR(ASTC_8x5_UNORM); - STR(ASTC_8x5_SRGB); - STR(ASTC_8x6_UNORM); - STR(ASTC_8x6_SRGB); - STR(ASTC_8x8_UNORM); - STR(ASTC_8x8_SRGB); - STR(ASTC_10x5_UNORM); - STR(ASTC_10x5_SRGB); - STR(ASTC_10x6_UNORM); - STR(ASTC_10x6_SRGB); - STR(ASTC_10x8_UNORM); - STR(ASTC_10x8_SRGB); - STR(ASTC_10x10_UNORM); - STR(ASTC_10x10_SRGB); - STR(ASTC_12x10_UNORM); - STR(ASTC_12x10_SRGB); - STR(ASTC_12x12_UNORM); - STR(ASTC_12x12_SRGB); - STR(B5G6R5_UNORM); - STR(B5G6R5_USCALED); - STR(B8G8R8_UNORM); - STR(B8G8R8_SNORM); - STR(B8G8R8_USCALED); - STR(B8G8R8_SSCALED); - STR(B8G8R8_UINT); - STR(B8G8R8_SINT); - STR(B8G8R8_SRGB); - STR(B8G8R8A8_UNORM); - STR(B8G8R8A8_SNORM); - STR(B8G8R8A8_USCALED); - STR(B8G8R8A8_SSCALED); - STR(B8G8R8A8_UINT); - STR(B8G8R8A8_SINT); - STR(B8G8R8A8_SRGB); - STR(B10G10R10A2_UNORM); - STR(B10G10R10A2_SNORM); - STR(B10G10R10A2_USCALED); - STR(B10G10R10A2_SSCALED); - STR(B10G10R10A2_UINT); - STR(B10G10R10A2_SINT); -#undef STR - default: return "UNKNOWN_FORMAT"; - } -} - -static void app_dev_init_formats(struct app_dev *dev) -{ - VK_FORMAT f; - - for (f = 0; f < VK_NUM_FMT; f++) { - const VK_FORMAT fmt = f; - VK_RESULT err; - size_t size = sizeof(dev->format_props[f]); - - err = vkGetFormatInfo(dev->obj, fmt, - VK_INFO_TYPE_FORMAT_PROPERTIES, - &size, &dev->format_props[f]); - if (err) { - memset(&dev->format_props[f], 0, - sizeof(dev->format_props[f])); - } - else if (size != sizeof(dev->format_props[f])) { - ERR_EXIT(VK_ERROR_UNKNOWN); - } - } -} - -static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu) -{ - VK_DEVICE_CREATE_INFO info = { - .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, - .pNext = NULL, - .queueRecordCount = 0, - .pRequestedQueues = NULL, - .extensionCount = 0, - .ppEnabledExtensionNames = NULL, - .maxValidationLevel = VK_VALIDATION_LEVEL_END_RANGE, - .flags = VK_DEVICE_CREATE_VALIDATION_BIT, - }; - VK_RESULT err; - - /* request all queues */ - info.queueRecordCount = gpu->queue_count; - info.pRequestedQueues = gpu->queue_reqs; - - /* enable all extensions */ - info.extensionCount = gpu->extension_count; - info.ppEnabledExtensionNames = (const char*const*) gpu->extensions; - dev->gpu = gpu; - err = vkCreateDevice(gpu->obj, &info, &dev->obj); - if (err) - ERR_EXIT(err); - -} - -static void app_dev_destroy(struct app_dev *dev) -{ - vkDestroyDevice(dev->obj); -} - -static void app_gpu_init_extensions(struct app_gpu *gpu) -{ - VK_RESULT err; - uint32_t i; - - static char *known_extensions[] = { - "VK_WSI_X11", - }; - - for (i = 0; i < ARRAY_SIZE(known_extensions); i++) { - err = vkGetExtensionSupport(gpu->obj, known_extensions[i]); - if (!err) - gpu->extension_count++; - } - - gpu->extensions = - malloc(sizeof(gpu->extensions[0]) * gpu->extension_count); - if (!gpu->extensions) - ERR_EXIT(VK_ERROR_OUT_OF_MEMORY); - - gpu->extension_count = 0; - for (i = 0; i < ARRAY_SIZE(known_extensions); i++) { - err = vkGetExtensionSupport(gpu->obj, known_extensions[i]); - if (!err) - gpu->extensions[gpu->extension_count++] = known_extensions[i]; - } -} - -static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VK_PHYSICAL_GPU obj) -{ - size_t size; - VK_RESULT err; - uint32_t i; - - memset(gpu, 0, sizeof(*gpu)); - - gpu->id = id; - gpu->obj = obj; - size = sizeof(gpu->props); - err = vkGetGpuInfo(gpu->obj, - VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, - &size, &gpu->props); - if (err || size != sizeof(gpu->props)) - ERR_EXIT(err); - - size = sizeof(gpu->perf); - err = vkGetGpuInfo(gpu->obj, - VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE, - &size, &gpu->perf); - if (err || size != sizeof(gpu->perf)) - ERR_EXIT(err); - - /* get queue count */ - err = vkGetGpuInfo(gpu->obj, - VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, - &size, NULL); - if (err || size % sizeof(gpu->queue_props[0])) - ERR_EXIT(err); - gpu->queue_count = (uint32_t) (size / sizeof(gpu->queue_props[0])); - - gpu->queue_props = - malloc(sizeof(gpu->queue_props[0]) * gpu->queue_count); - size = sizeof(gpu->queue_props[0]) * gpu->queue_count; - if (!gpu->queue_props) - ERR_EXIT(VK_ERROR_OUT_OF_MEMORY); - err = vkGetGpuInfo(gpu->obj, - VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, - &size, gpu->queue_props); - if (err || size != sizeof(gpu->queue_props[0]) * gpu->queue_count) - ERR_EXIT(err); - - /* set up queue requests */ - size = sizeof(*gpu->queue_reqs) * gpu->queue_count; - gpu->queue_reqs = malloc(sizeof(*gpu->queue_reqs) * gpu->queue_count); - if (!gpu->queue_reqs) - ERR_EXIT(VK_ERROR_OUT_OF_MEMORY); - for (i = 0; i < gpu->queue_count; i++) { - gpu->queue_reqs[i].queueNodeIndex = i; - gpu->queue_reqs[i].queueCount = gpu->queue_props[i].queueCount; - } - - size = sizeof(gpu->memory_props); - err = vkGetGpuInfo(gpu->obj, - VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, - &size, &gpu->memory_props); - if (err || size != sizeof(gpu->memory_props)) - ERR_EXIT(err); - - app_gpu_init_extensions(gpu); - app_dev_init(&gpu->dev, gpu); - app_dev_init_formats(&gpu->dev); -} - -static void app_gpu_destroy(struct app_gpu *gpu) -{ - app_dev_destroy(&gpu->dev); - free(gpu->extensions); - free(gpu->queue_reqs); - free(gpu->queue_props); -} - -static void app_dev_dump_format_props(const struct app_dev *dev, VK_FORMAT fmt) -{ - const VK_FORMAT_PROPERTIES *props = &dev->format_props[fmt]; - struct { - const char *name; - VK_FLAGS flags; - } tilings[2]; - uint32_t i; - - if (!props->linearTilingFeatures && !props->optimalTilingFeatures) - return; - - tilings[0].name = "linear"; - tilings[0].flags = props->linearTilingFeatures; - tilings[1].name = "optimal"; - tilings[1].flags = props->optimalTilingFeatures; - - printf("FORMAT_%s\n", vk_format_string(fmt)); - for (i = 0; i < ARRAY_SIZE(tilings); i++) { - if (!tilings[i].flags) - continue; - - printf("\t%s tiling image =%s%s%s\n", tilings[i].name, - (tilings[i].flags & VK_FORMAT_IMAGE_SHADER_READ_BIT) ? " read" : "", - (tilings[i].flags & VK_FORMAT_IMAGE_SHADER_WRITE_BIT) ? " write" : "", - (tilings[i].flags & VK_FORMAT_IMAGE_COPY_BIT) ? " copy" : ""); - printf("\t%s tiling memory =%s\n", tilings[i].name, - (tilings[i].flags & VK_FORMAT_MEMORY_SHADER_ACCESS_BIT) ? " access" : ""); - printf("\t%s tiling attachment =%s%s%s%s%s\n", tilings[i].name, - (tilings[i].flags & VK_FORMAT_COLOR_ATTACHMENT_WRITE_BIT) ? " color" : "", - (tilings[i].flags & VK_FORMAT_COLOR_ATTACHMENT_BLEND_BIT) ? " blend" : "", - (tilings[i].flags & VK_FORMAT_DEPTH_ATTACHMENT_BIT) ? " depth" : "", - (tilings[i].flags & VK_FORMAT_STENCIL_ATTACHMENT_BIT) ? " stencil" : "", - (tilings[i].flags & VK_FORMAT_MSAA_ATTACHMENT_BIT) ? " msaa" : ""); - printf("\t%s tiling conversion = %u\n", tilings[i].name, - (bool) (tilings[i].flags & VK_FORMAT_CONVERSION_BIT)); - } -} - - -static void -app_dev_dump(const struct app_dev *dev) -{ - VK_FORMAT fmt; - - for (fmt = 0; fmt < VK_NUM_FMT; fmt++) { - app_dev_dump_format_props(dev, fmt); - } -} - -static void app_gpu_dump_multi_compat(const struct app_gpu *gpu, const struct app_gpu *other, - const VK_GPU_COMPATIBILITY_INFO *info) -{ - printf("VK_GPU_COMPATIBILITY_INFO[GPU%d]\n", other->id); - -#define TEST(info, b) printf(#b " = %u\n", (bool) (info->compatibilityFlags & VK_GPU_COMPAT_ ##b## _BIT)) - TEST(info, ASIC_FEATURES); - TEST(info, IQ_MATCH); - TEST(info, PEER_TRANSFER); - TEST(info, SHARED_MEMORY); - TEST(info, SHARED_SYNC); - TEST(info, SHARED_GPU0_DISPLAY); - TEST(info, SHARED_GPU1_DISPLAY); -#undef TEST -} - -static void app_gpu_multi_compat(struct app_gpu *gpus, uint32_t gpu_count) -{ - VK_RESULT err; - uint32_t i, j; - - for (i = 0; i < gpu_count; i++) { - for (j = 0; j < gpu_count; j++) { - VK_GPU_COMPATIBILITY_INFO info; - - if (i == j) - continue; - - err = vkGetMultiGpuCompatibility(gpus[i].obj, - gpus[j].obj, &info); - if (err) - ERR_EXIT(err); - - app_gpu_dump_multi_compat(&gpus[i], &gpus[j], &info); - } - } -} - -static void app_gpu_dump_props(const struct app_gpu *gpu) -{ - const VK_PHYSICAL_GPU_PROPERTIES *props = &gpu->props; - - printf("VK_PHYSICAL_GPU_PROPERTIES\n"); - printf("\tapiVersion = %u\n", props->apiVersion); - printf("\tdriverVersion = %u\n", props->driverVersion); - printf("\tvendorId = 0x%04x\n", props->vendorId); - printf("\tdeviceId = 0x%04x\n", props->deviceId); - printf("\tgpuType = %s\n", vk_gpu_type_string(props->gpuType)); - printf("\tgpuName = %s\n", props->gpuName); - printf("\tmaxInlineMemoryUpdateSize = %zu\n", props->maxInlineMemoryUpdateSize); - printf("\tmaxBoundDescriptorSets = %u\n", props->maxBoundDescriptorSets); - printf("\tmaxThreadGroupSize = %u\n", props->maxThreadGroupSize); - printf("\ttimestampFrequency = %lu\n", props->timestampFrequency); - printf("\tmultiColorAttachmentClears = %u\n", props->multiColorAttachmentClears); -} - -static void app_gpu_dump_perf(const struct app_gpu *gpu) -{ - const VK_PHYSICAL_GPU_PERFORMANCE *perf = &gpu->perf; - - printf("VK_PHYSICAL_GPU_PERFORMANCE\n"); - printf("\tmaxGpuClock = %f\n", perf->maxGpuClock); - printf("\taluPerClock = %f\n", perf->aluPerClock); - printf("\ttexPerClock = %f\n", perf->texPerClock); - printf("\tprimsPerClock = %f\n", perf->primsPerClock); - printf("\tpixelsPerClock = %f\n", perf->pixelsPerClock); -} - -static void app_gpu_dump_extensions(const struct app_gpu *gpu) -{ - uint32_t i; - printf("Extensions"); - printf("\tcount = %d\n", gpu->extension_count); - printf("\t"); - for (i=0; i< gpu->extension_count; i++) { - if (i>0) - printf(", "); // separator between extension names - printf("%s", gpu->extensions[i]); - } - printf("\n"); -} - -static void app_gpu_dump_queue_props(const struct app_gpu *gpu, uint32_t id) -{ - const VK_PHYSICAL_GPU_QUEUE_PROPERTIES *props = &gpu->queue_props[id]; - - printf("VK_PHYSICAL_GPU_QUEUE_PROPERTIES[%d]\n", id); - printf("\tqueueFlags = %c%c%c%c\n", - (props->queueFlags & VK_QUEUE_GRAPHICS_BIT) ? 'G' : '.', - (props->queueFlags & VK_QUEUE_COMPUTE_BIT) ? 'C' : '.', - (props->queueFlags & VK_QUEUE_DMA_BIT) ? 'D' : '.', - (props->queueFlags & VK_QUEUE_EXTENDED_BIT) ? 'X' : '.'); - printf("\tqueueCount = %u\n", props->queueCount); - printf("\tmaxAtomicCounters = %u\n", props->maxAtomicCounters); - printf("\tsupportsTimestamps = %u\n", props->supportsTimestamps); - printf("\tmaxMemReferences = %u\n", props->maxMemReferences); -} - -static void app_gpu_dump_memory_props(const struct app_gpu *gpu) -{ - const VK_PHYSICAL_GPU_MEMORY_PROPERTIES *props = &gpu->memory_props; - - printf("VK_PHYSICAL_GPU_MEMORY_PROPERTIES\n"); - printf("\tsupportsMigration = %u\n", props->supportsMigration); - printf("\tsupportsPinning = %u\n", props->supportsPinning); -} - -static void app_gpu_dump(const struct app_gpu *gpu) -{ - uint32_t i; - - printf("GPU%u\n", gpu->id); - app_gpu_dump_props(gpu); - printf("\n"); - app_gpu_dump_extensions(gpu); - printf("\n"); - app_gpu_dump_perf(gpu); - printf("\n"); - for (i = 0; i < gpu->queue_count; i++) { - app_gpu_dump_queue_props(gpu, i); - printf("\n"); - } - app_gpu_dump_memory_props(gpu); - printf("\n"); - app_dev_dump(&gpu->dev); -} - -int main(int argc, char **argv) -{ - static const VK_APPLICATION_INFO app_info = { - .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, - .pNext = NULL, - .pAppName = "vkinfo", - .appVersion = 1, - .pEngineName = "vkinfo", - .engineVersion = 1, - .apiVersion = VK_API_VERSION, - }; - static const VK_INSTANCE_CREATE_INFO inst_info = { - .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - .pNext = NULL, - .pAppInfo = &app_info, - .pAllocCb = NULL, - .extensionCount = 0, - .ppEnabledExtensionNames = NULL, - }; - struct app_gpu gpus[MAX_GPUS]; - VK_PHYSICAL_GPU objs[MAX_GPUS]; - VK_INSTANCE inst; - uint32_t gpu_count, i; - VK_RESULT err; - - err = vkCreateInstance(&inst_info, &inst); - if (err == VK_ERROR_INCOMPATIBLE_DRIVER) { - printf("Cannot find a compatible Vulkan installable client driver " - "(ICD).\nExiting ...\n"); - fflush(stdout); - exit(1); - } else if (err) { - - ERR_EXIT(err); - } - err = vkEnumerateGpus(inst, MAX_GPUS, &gpu_count, objs); - if (err) - ERR_EXIT(err); - - for (i = 0; i < gpu_count; i++) { - app_gpu_init(&gpus[i], i, objs[i]); - app_gpu_dump(&gpus[i]); - printf("\n\n"); - } - - app_gpu_multi_compat(gpus, gpu_count); - - for (i = 0; i < gpu_count; i++) - app_gpu_destroy(&gpus[i]); - - vkDestroyInstance(inst); - - return 0; -} diff --git a/docs/vk_ds.dot b/docs/vk_ds.dot new file mode 100644 index 00000000..2615beeb --- /dev/null +++ b/docs/vk_ds.dot @@ -0,0 +1,180 @@ +digraph g { +graph [ +rankdir = "LR" +]; +node [ +fontsize = "16" +shape = "plaintext" +]; +edge [ +]; +subgraph clusterDSCreate1 +{ +label="vkCreateDescriptorSet()" +"_VK_DESCRIPTOR_SET_CREATE_INFO1" [ +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> +]; +} +subgraph clusterDSCreate2 +{ +label="vkCreateDescriptorSet()" +"_VK_DESCRIPTOR_SET_CREATE_INFO2" [ +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> +]; +} +subgraph clusterSamplerCreate +{ +label="vkCreateSampler - multiple calls return unique VK_SAMPLER handles" +"_VK_SAMPLER_CREATE_INFO_0" [ +label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +]; +"SAMPLER_ELLIPSES" [ +label = "..." +]; +"_VK_SAMPLER_CREATE_INFO_19" [ +label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +]; +} +subgraph clusterSamplerAttach +{ +label="vkAttachSamplerDescriptors\npSamplers array of VK_SAMPLERS" +"SAMPLER_ARRAY" [ +label = <
pSamplers
VK_SAMPLER0
VK_SAMPLER1
VK_SAMPLER2
VK_SAMPLER3
VK_SAMPLER4
VK_SAMPLER5
VK_SAMPLER6
VK_SAMPLER7
VK_SAMPLER8
VK_SAMPLER9
VK_SAMPLER10
VK_SAMPLER11
VK_SAMPLER12
VK_SAMPLER13
VK_SAMPLER14
VK_SAMPLER15
VK_SAMPLER16
VK_SAMPLER17
VK_SAMPLER18
VK_SAMPLER19
> +]; +} +"DS1_MEMORY" [ +label = <
DS1 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
> +]; +"DS2_MEMORY" [ +label = <
DS2 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
slots14
slots15
slots16
slots17
slots18
slots19
> +]; +subgraph clusterMemoryView +{ +label="vkAttachMemoryViewDescriptors - pMemViews array of VK_MEMORY_VIEW_ATTACH_INFO structs" +"_VK_MEMORY_VIEW_ATTACH_INFO_3" [ +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +]; +"MEM_VIEW_ELLIPSES" [ +label = "..." +]; +"_VK_MEMORY_VIEW_ATTACH_INFO_0" [ +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +]; +} +subgraph clusterImageView +{ +label="vkAttachImageViewDescriptors - pImageViews array of VK_IMAGE_VIEW_ATTACH_INFO structs" +"_VK_IMAGE_VIEW_ATTACH_INFO_9" [ +label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +]; +"IMG_VIEW_ELLIPSES" [ +label = "..." +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_0" [ +label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +]; +} +"VS_VK_DESCRIPTOR_SET_MAPPING" [ +label = <
VK_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=2
const VK_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> +]; +"VS_VK_DESCRIPTOR_SLOT_INFO" [ +label = <
VK_DESCRIPTOR_SLOT_INFO
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE0
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE1
uint32_tshaderEntityIndex
> +]; +"FS0_VK_DESCRIPTOR_SET_MAPPING" [ +label = <
VK_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=6
const VK_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> +]; +"FS0_VK_DESCRIPTOR_SLOT_INFO" [ +label = <
VK_DESCRIPTOR_SLOT_INFO
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_UNUSED0
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_UNUSED1
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE2
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE3
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE4
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_UAV5
uint32_tshaderEntityIndex
> +]; +"FS1_VK_DESCRIPTOR_SET_MAPPING" [ +label = <
VK_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=10
const VK_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> +]; +"FS1_VK_DESCRIPTOR_SLOT_INFO" [ +label = <
VK_DESCRIPTOR_SLOT_INFO
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER0
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER1
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER2
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER3
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER4
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER5
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER6
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER7
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER8
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER9
uint32_tshaderEntityIndex
> +]; +/* +"_VK_DESCRIPTOR_SET_CREATE_INFO1":f2 -> "_VK_DESCRIPTOR_SET_CREATE_INFO2":f0 [ +id = 0 +]; +*/ +"_VK_DESCRIPTOR_SET_CREATE_INFO1":f4 -> "DS1_MEMORY":ds1 [ +id = 1 +]; +"_VK_DESCRIPTOR_SET_CREATE_INFO2":f4 -> "DS2_MEMORY":ds2 [ +id = 2 +]; +/* +"_VK_SAMPLER_CREATE_INFO_0":f4 -> "_ELLIPSE0" [ +id = 3 +]; +"_ELLIPSE0" -> "_VK_SAMPLER_CREATE_INFO_19":f0 [ +id = 3 +]; +*/ +"_VK_SAMPLER_CREATE_INFO_0" -> "SAMPLER_ARRAY":f0 [ +id = 4 +]; +"_VK_SAMPLER_CREATE_INFO_19" -> "SAMPLER_ARRAY":f19 [ +id = 5 +]; +"SAMPLER_ARRAY":f0 -> "DS2_MEMORY":f0 [ +id = 6 +]; +"SAMPLER_ARRAY":f19 -> "DS2_MEMORY":f19 [ +id = 7 +]; +/* +"_VK_MEMORY_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE1" [ +id = 6 +]; +"_ELLIPSE1" -> "_VK_MEMORY_VIEW_ATTACH_INFO_3":f0 [ +id = 7 +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE2" [ +id = 8 +]; +"_ELLIPSE2" -> "_VK_IMAGE_VIEW_ATTACH_INFO_9":f0 [ +id = 9 +]; +*/ +"_VK_MEMORY_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f0 [ +id = 10 +]; +"_VK_MEMORY_VIEW_ATTACH_INFO_3" -> "DS1_MEMORY":f3 [ +id = 11 +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f4 [ +id = 10 +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_9" -> "DS1_MEMORY":f13 [ +id = 11 +]; +"VS_VK_DESCRIPTOR_SET_MAPPING":f4 -> "VS_VK_DESCRIPTOR_SLOT_INFO":f0 [ +id = 12 +]; +"VS_VK_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ +id = 13 +]; +"VS_VK_DESCRIPTOR_SLOT_INFO":f6 -> "DS1_MEMORY":f1 [ +id = 14 +]; +"FS0_VK_DESCRIPTOR_SET_MAPPING":f4 -> "FS0_VK_DESCRIPTOR_SLOT_INFO":f0 [ +id = 15 +]; +"FS0_VK_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ +id = 16 +]; +"FS0_VK_DESCRIPTOR_SLOT_INFO":f26 -> "DS1_MEMORY":f5 [ +id = 17 +]; +"FS1_VK_DESCRIPTOR_SET_MAPPING":f4 -> "FS1_VK_DESCRIPTOR_SLOT_INFO":f0 [ +id = 15 +]; +"FS1_VK_DESCRIPTOR_SLOT_INFO":f1 -> "DS2_MEMORY":f0 [ +id = 16 +]; +"FS1_VK_DESCRIPTOR_SLOT_INFO":f46 -> "DS2_MEMORY":f9 [ +id = 17 +]; +} + diff --git a/docs/vk_ds.png b/docs/vk_ds.png new file mode 100644 index 00000000..ffeb80c1 Binary files /dev/null and b/docs/vk_ds.png differ diff --git a/docs/vk_full_pipeline_ds.dot b/docs/vk_full_pipeline_ds.dot new file mode 100644 index 00000000..6132b3a7 --- /dev/null +++ b/docs/vk_full_pipeline_ds.dot @@ -0,0 +1,282 @@ +digraph g { +graph [ +rankdir = "TB" +]; +node [ +fontsize = "16" +shape = "plaintext" +]; +edge [ +]; +"_VK_GRAPHICS_PIPELINE_CREATE_INFO" [ +label = <
VK_GRAPHICS_PIPELINE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
VK_FLAGSflags
> +]; +"_VK_PIPELINE_IA_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_IA_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
VK_PRIMITIVE_TOPOLOGYtopology
bool32_tdisableVertexReuse
VK_PROVOKING_VERTEX_CONVENTIONprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> +]; +"_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_TESS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> +]; +"_VK_PIPELINE_RS_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_RS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> +]; +"_VK_PIPELINE_CB_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_CB_STATE
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
VK_LOGIC_OPlogicOp
VK_PIPELINE_CB_ATTACHMENT_STATEattachment
> +]; +"_VK_PIPELINE_DB_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_DB_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
VK_FORMATformat
> +]; +"VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
VK_PIPELINE_SHADERshader
> +]; +"VS_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=VS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"TC_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TC
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"TE_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TE
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"GS_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=GS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"FS_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=FS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"_VK_GRAPHICS_PIPELINE_CREATE_INFO":f2 -> "_VK_PIPELINE_IA_STATE_CREATE_INFO" [ +id = 100 +]; +"_VK_PIPELINE_IA_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ +id = 101 +]; +"_VK_PIPELINE_TESS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_RS_STATE_CREATE_INFO" [ +id = 102 +]; +"_VK_PIPELINE_RS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_CB_STATE_CREATE_INFO" [ +id = 103 +]; +"_VK_PIPELINE_CB_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ +id = 104 +]; +"_VK_PIPELINE_DB_STATE_CREATE_INFO":f2 -> "VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 105 +]; +"VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 106 +]; +"TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 107 +]; +"TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 108 +]; +"GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 109 +]; +"VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "VS_VK_PIPELINE_SHADER" [ +id = 110 +]; +"TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TE_VK_PIPELINE_SHADER" [ +id = 111 +]; +"TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TC_VK_PIPELINE_SHADER" [ +id = 112 +]; +"GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "GS_VK_PIPELINE_SHADER" [ +id = 113 +]; +"FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "FS_VK_PIPELINE_SHADER" [ +id = 114 +]; +subgraph clusterDSCreate1 +{ +label="vkCreateDescriptorSet()" +"_VK_DESCRIPTOR_SET_CREATE_INFO1" [ +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> +]; +} +subgraph clusterDSCreate2 +{ +label="vkCreateDescriptorSet()" +"_VK_DESCRIPTOR_SET_CREATE_INFO2" [ +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> +]; +} +subgraph clusterSamplerCreate +{ +label="vkCreateSampler - multiple calls return unique VK_SAMPLER handles" +"_VK_SAMPLER_CREATE_INFO_0" [ +label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +]; +"SAMPLER_ELLIPSES" [ +label = "..." +]; +"_VK_SAMPLER_CREATE_INFO_19" [ +label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +]; +} +subgraph clusterSamplerAttach +{ +label="vkAttachSamplerDescriptors\npSamplers array of VK_SAMPLERS" +"SAMPLER_ARRAY" [ +label = <
pSamplers
VK_SAMPLER0
VK_SAMPLER1
VK_SAMPLER2
VK_SAMPLER3
VK_SAMPLER4
VK_SAMPLER5
VK_SAMPLER6
VK_SAMPLER7
VK_SAMPLER8
VK_SAMPLER9
VK_SAMPLER10
VK_SAMPLER11
VK_SAMPLER12
VK_SAMPLER13
VK_SAMPLER14
VK_SAMPLER15
VK_SAMPLER16
VK_SAMPLER17
VK_SAMPLER18
VK_SAMPLER19
> +]; +} +"DS1_MEMORY" [ +label = <
DS1 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
> +]; +"DS2_MEMORY" [ +label = <
DS2 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
slots14
slots15
slots16
slots17
slots18
slots19
> +]; +subgraph clusterMemoryView +{ +label="vkAttachMemoryViewDescriptors - pMemViews array of VK_MEMORY_VIEW_ATTACH_INFO structs" +"_VK_MEMORY_VIEW_ATTACH_INFO_3" [ +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +]; +"MEM_VIEW_ELLIPSES" [ +label = "..." +]; +"_VK_MEMORY_VIEW_ATTACH_INFO_0" [ +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +]; +} +subgraph clusterImageView +{ +label="vkAttachImageViewDescriptors - pImageViews array of VK_IMAGE_VIEW_ATTACH_INFO structs" +"_VK_IMAGE_VIEW_ATTACH_INFO_9" [ +label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +]; +"IMG_VIEW_ELLIPSES" [ +label = "..." +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_0" [ +label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +]; +} +"VS_VK_DESCRIPTOR_SET_MAPPING" [ +label = <
VK_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=2
const VK_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> +]; +"VS_VK_DESCRIPTOR_SLOT_INFO" [ +label = <
VK_DESCRIPTOR_SLOT_INFO
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE0
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE1
uint32_tshaderEntityIndex
> +]; +"FS0_VK_DESCRIPTOR_SET_MAPPING" [ +label = <
VK_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=6
const VK_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> +]; +"FS0_VK_DESCRIPTOR_SLOT_INFO" [ +label = <
VK_DESCRIPTOR_SLOT_INFO
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_UNUSED0
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_UNUSED1
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE2
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE3
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_RESOURCE4
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_UAV5
uint32_tshaderEntityIndex
> +]; +"FS1_VK_DESCRIPTOR_SET_MAPPING" [ +label = <
VK_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=10
const VK_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> +]; +"FS1_VK_DESCRIPTOR_SLOT_INFO" [ +label = <
VK_DESCRIPTOR_SLOT_INFO
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER0
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER1
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER2
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER3
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER4
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER5
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER6
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER7
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER8
uint32_tshaderEntityIndex
VK_DESCRIPTOR_SET_SLOT_TYPEVK_SLOT_SHADER_SAMPLER9
uint32_tshaderEntityIndex
> +]; +/* +"_VK_DESCRIPTOR_SET_CREATE_INFO1":f2 -> "_VK_DESCRIPTOR_SET_CREATE_INFO2":f0 [ +id = 0 +]; +*/ +"_VK_DESCRIPTOR_SET_CREATE_INFO1":f4 -> "DS1_MEMORY":ds1 [ +id = 1 +]; +"_VK_DESCRIPTOR_SET_CREATE_INFO2":f4 -> "DS2_MEMORY":ds2 [ +id = 2 +]; +/* +"_VK_SAMPLER_CREATE_INFO_0":f4 -> "_ELLIPSE0" [ +id = 3 +]; +"_ELLIPSE0" -> "_VK_SAMPLER_CREATE_INFO_19":f0 [ +id = 3 +]; +*/ +"_VK_SAMPLER_CREATE_INFO_0" -> "SAMPLER_ARRAY":f0 [ +id = 4 +]; +"_VK_SAMPLER_CREATE_INFO_19" -> "SAMPLER_ARRAY":f19 [ +id = 5 +]; +"SAMPLER_ARRAY":f0 -> "DS2_MEMORY":f0 [ +id = 6 +]; +"SAMPLER_ARRAY":f19 -> "DS2_MEMORY":f19 [ +id = 7 +]; +/* +"_VK_MEMORY_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE1" [ +id = 6 +]; +"_ELLIPSE1" -> "_VK_MEMORY_VIEW_ATTACH_INFO_3":f0 [ +id = 7 +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE2" [ +id = 8 +]; +"_ELLIPSE2" -> "_VK_IMAGE_VIEW_ATTACH_INFO_9":f0 [ +id = 9 +]; +*/ +"_VK_MEMORY_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f0 [ +id = 10 +]; +"_VK_MEMORY_VIEW_ATTACH_INFO_3" -> "DS1_MEMORY":f3 [ +id = 11 +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f4 [ +id = 10 +]; +"_VK_IMAGE_VIEW_ATTACH_INFO_9" -> "DS1_MEMORY":f13 [ +id = 11 +]; +"VS_VK_DESCRIPTOR_SET_MAPPING":f4 -> "VS_VK_DESCRIPTOR_SLOT_INFO":f0 [ +id = 12 +]; +"VS_VK_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ +id = 13 +]; +"VS_VK_DESCRIPTOR_SLOT_INFO":f6 -> "DS1_MEMORY":f1 [ +id = 14 +]; +"FS0_VK_DESCRIPTOR_SET_MAPPING":f4 -> "FS0_VK_DESCRIPTOR_SLOT_INFO":f0 [ +id = 15 +]; +"FS0_VK_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ +id = 16 +]; +"FS0_VK_DESCRIPTOR_SLOT_INFO":f26 -> "DS1_MEMORY":f5 [ +id = 17 +]; +"FS1_VK_DESCRIPTOR_SET_MAPPING":f4 -> "FS1_VK_DESCRIPTOR_SLOT_INFO":f0 [ +id = 15 +]; +"FS1_VK_DESCRIPTOR_SLOT_INFO":f1 -> "DS2_MEMORY":f0 [ +id = 16 +]; +"FS1_VK_DESCRIPTOR_SLOT_INFO":f46 -> "DS2_MEMORY":f9 [ +id = 17 +]; +"FS_VK_PIPELINE_SHADER":f6 -> "FS0_VK_DESCRIPTOR_SET_MAPPING" [ +id = 18 +]; +"FS_VK_PIPELINE_SHADER":f6 -> "FS1_VK_DESCRIPTOR_SET_MAPPING" [ +id = 19 +]; +"VS_VK_PIPELINE_SHADER":f6 -> "VS_VK_DESCRIPTOR_SET_MAPPING" [ +id = 20 +]; +} + diff --git a/docs/vk_full_pipeline_ds.png b/docs/vk_full_pipeline_ds.png new file mode 100644 index 00000000..cec76227 Binary files /dev/null and b/docs/vk_full_pipeline_ds.png differ diff --git a/docs/vk_graphics_pipeline.dot b/docs/vk_graphics_pipeline.dot new file mode 100644 index 00000000..b6304552 --- /dev/null +++ b/docs/vk_graphics_pipeline.dot @@ -0,0 +1,105 @@ +digraph g { +graph [ +rankdir = "TB" +]; +node [ +fontsize = "16" +shape = "plaintext" +]; +edge [ +]; +"_VK_GRAPHICS_PIPELINE_CREATE_INFO" [ +label = <
VK_GRAPHICS_PIPELINE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
VK_FLAGSflags
> +]; +"_VK_PIPELINE_IA_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_IA_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
VK_PRIMITIVE_TOPOLOGYtopology
bool32_tdisableVertexReuse
VK_PROVOKING_VERTEX_CONVENTIONprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> +]; +"_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_TESS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> +]; +"_VK_PIPELINE_RS_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_RS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> +]; +"_VK_PIPELINE_CB_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_CB_STATE
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
VK_LOGIC_OPlogicOp
VK_PIPELINE_CB_ATTACHMENT_STATEattachment
> +]; +"_VK_PIPELINE_DB_STATE_CREATE_INFO" [ +label = <
VK_PIPELINE_DB_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
VK_FORMATformat
> +]; +"VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +]; +"FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
VK_PIPELINE_SHADERshader
> +]; +"VS_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=VS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"TC_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TC
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"TE_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TE
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"GS_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=GS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"FS_VK_PIPELINE_SHADER" [ +label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=FS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +]; +"_VK_GRAPHICS_PIPELINE_CREATE_INFO":f2 -> "_VK_PIPELINE_IA_STATE_CREATE_INFO" [ +id = 0 +]; +"_VK_PIPELINE_IA_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ +id = 1 +]; +"_VK_PIPELINE_TESS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_RS_STATE_CREATE_INFO" [ +id = 2 +]; +"_VK_PIPELINE_RS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_CB_STATE_CREATE_INFO" [ +id = 3 +]; +"_VK_PIPELINE_CB_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ +id = 4 +]; +"_VK_PIPELINE_DB_STATE_CREATE_INFO":f2 -> "VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 5 +]; +"VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 6 +]; +"TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 7 +]; +"TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 8 +]; +"GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ +id = 9 +]; +"VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "VS_VK_PIPELINE_SHADER" [ +id = 10 +]; +"TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TE_VK_PIPELINE_SHADER" [ +id = 11 +]; +"TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TC_VK_PIPELINE_SHADER" [ +id = 12 +]; +"GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "GS_VK_PIPELINE_SHADER" [ +id = 13 +]; +"FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "FS_VK_PIPELINE_SHADER" [ +id = 14 +]; +} + diff --git a/docs/vk_graphics_pipeline.png b/docs/vk_graphics_pipeline.png new file mode 100644 index 00000000..392fd3f3 Binary files /dev/null and b/docs/vk_graphics_pipeline.png differ diff --git a/docs/xgl_ds.dot b/docs/xgl_ds.dot deleted file mode 100644 index e7496de0..00000000 --- a/docs/xgl_ds.dot +++ /dev/null @@ -1,180 +0,0 @@ -digraph g { -graph [ -rankdir = "LR" -]; -node [ -fontsize = "16" -shape = "plaintext" -]; -edge [ -]; -subgraph clusterDSCreate1 -{ -label="xglCreateDescriptorSet()" -"_XGL_DESCRIPTOR_SET_CREATE_INFO1" [ -label = <
XGL_DESCRIPTOR_SET_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> -]; -} -subgraph clusterDSCreate2 -{ -label="xglCreateDescriptorSet()" -"_XGL_DESCRIPTOR_SET_CREATE_INFO2" [ -label = <
XGL_DESCRIPTOR_SET_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> -]; -} -subgraph clusterSamplerCreate -{ -label="xglCreateSampler - multiple calls return unique XGL_SAMPLER handles" -"_XGL_SAMPLER_CREATE_INFO_0" [ -label = <
XGL_SAMPLER_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
XGL_TEX_FILTERmagFilter
XGL_TEX_FILTERminFilter
XGL_TEX_MIPMAP_MODEmipMode
XGL_TEX_ADDRESSaddressU
XGL_TEX_ADDRESSaddressV
XGL_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
XGL_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
XGL_BORDER_COLOR_TYPEborderColorType
> -]; -"SAMPLER_ELLIPSES" [ -label = "..." -]; -"_XGL_SAMPLER_CREATE_INFO_19" [ -label = <
XGL_SAMPLER_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
XGL_TEX_FILTERmagFilter
XGL_TEX_FILTERminFilter
XGL_TEX_MIPMAP_MODEmipMode
XGL_TEX_ADDRESSaddressU
XGL_TEX_ADDRESSaddressV
XGL_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
XGL_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
XGL_BORDER_COLOR_TYPEborderColorType
> -]; -} -subgraph clusterSamplerAttach -{ -label="xglAttachSamplerDescriptors\npSamplers array of XGL_SAMPLERS" -"SAMPLER_ARRAY" [ -label = <
pSamplers
XGL_SAMPLER0
XGL_SAMPLER1
XGL_SAMPLER2
XGL_SAMPLER3
XGL_SAMPLER4
XGL_SAMPLER5
XGL_SAMPLER6
XGL_SAMPLER7
XGL_SAMPLER8
XGL_SAMPLER9
XGL_SAMPLER10
XGL_SAMPLER11
XGL_SAMPLER12
XGL_SAMPLER13
XGL_SAMPLER14
XGL_SAMPLER15
XGL_SAMPLER16
XGL_SAMPLER17
XGL_SAMPLER18
XGL_SAMPLER19
> -]; -} -"DS1_MEMORY" [ -label = <
DS1 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
> -]; -"DS2_MEMORY" [ -label = <
DS2 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
slots14
slots15
slots16
slots17
slots18
slots19
> -]; -subgraph clusterMemoryView -{ -label="xglAttachMemoryViewDescriptors - pMemViews array of XGL_MEMORY_VIEW_ATTACH_INFO structs" -"_XGL_MEMORY_VIEW_ATTACH_INFO_3" [ -label = <
XGL_MEMORY_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_GPU_MEMORYmem
XGL_GPU_SIZEoffset
XGL_GPU_SIZErange
XGL_GPU_SIZEstride
XGL_FORMATformat
XGL_MEMORY_STATEstate
> -]; -"MEM_VIEW_ELLIPSES" [ -label = "..." -]; -"_XGL_MEMORY_VIEW_ATTACH_INFO_0" [ -label = <
XGL_MEMORY_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_GPU_MEMORYmem
XGL_GPU_SIZEoffset
XGL_GPU_SIZErange
XGL_GPU_SIZEstride
XGL_FORMATformat
XGL_MEMORY_STATEstate
> -]; -} -subgraph clusterImageView -{ -label="xglAttachImageViewDescriptors - pImageViews array of XGL_IMAGE_VIEW_ATTACH_INFO structs" -"_XGL_IMAGE_VIEW_ATTACH_INFO_9" [ -label = <
XGL_IMAGE_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_IMAGE_VIEWview
XGL_IMAGE_STATEstate
> -]; -"IMG_VIEW_ELLIPSES" [ -label = "..." -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_0" [ -label = <
XGL_IMAGE_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_IMAGE_VIEWview
XGL_IMAGE_STATEstate
> -]; -} -"VS_XGL_DESCRIPTOR_SET_MAPPING" [ -label = <
XGL_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=2
const XGL_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> -]; -"VS_XGL_DESCRIPTOR_SLOT_INFO" [ -label = <
XGL_DESCRIPTOR_SLOT_INFO
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE0
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE1
uint32_tshaderEntityIndex
> -]; -"FS0_XGL_DESCRIPTOR_SET_MAPPING" [ -label = <
XGL_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=6
const XGL_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> -]; -"FS0_XGL_DESCRIPTOR_SLOT_INFO" [ -label = <
XGL_DESCRIPTOR_SLOT_INFO
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_UNUSED0
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_UNUSED1
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE2
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE3
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE4
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_UAV5
uint32_tshaderEntityIndex
> -]; -"FS1_XGL_DESCRIPTOR_SET_MAPPING" [ -label = <
XGL_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=10
const XGL_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> -]; -"FS1_XGL_DESCRIPTOR_SLOT_INFO" [ -label = <
XGL_DESCRIPTOR_SLOT_INFO
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER0
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER1
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER2
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER3
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER4
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER5
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER6
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER7
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER8
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER9
uint32_tshaderEntityIndex
> -]; -/* -"_XGL_DESCRIPTOR_SET_CREATE_INFO1":f2 -> "_XGL_DESCRIPTOR_SET_CREATE_INFO2":f0 [ -id = 0 -]; -*/ -"_XGL_DESCRIPTOR_SET_CREATE_INFO1":f4 -> "DS1_MEMORY":ds1 [ -id = 1 -]; -"_XGL_DESCRIPTOR_SET_CREATE_INFO2":f4 -> "DS2_MEMORY":ds2 [ -id = 2 -]; -/* -"_XGL_SAMPLER_CREATE_INFO_0":f4 -> "_ELLIPSE0" [ -id = 3 -]; -"_ELLIPSE0" -> "_XGL_SAMPLER_CREATE_INFO_19":f0 [ -id = 3 -]; -*/ -"_XGL_SAMPLER_CREATE_INFO_0" -> "SAMPLER_ARRAY":f0 [ -id = 4 -]; -"_XGL_SAMPLER_CREATE_INFO_19" -> "SAMPLER_ARRAY":f19 [ -id = 5 -]; -"SAMPLER_ARRAY":f0 -> "DS2_MEMORY":f0 [ -id = 6 -]; -"SAMPLER_ARRAY":f19 -> "DS2_MEMORY":f19 [ -id = 7 -]; -/* -"_XGL_MEMORY_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE1" [ -id = 6 -]; -"_ELLIPSE1" -> "_XGL_MEMORY_VIEW_ATTACH_INFO_3":f0 [ -id = 7 -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE2" [ -id = 8 -]; -"_ELLIPSE2" -> "_XGL_IMAGE_VIEW_ATTACH_INFO_9":f0 [ -id = 9 -]; -*/ -"_XGL_MEMORY_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f0 [ -id = 10 -]; -"_XGL_MEMORY_VIEW_ATTACH_INFO_3" -> "DS1_MEMORY":f3 [ -id = 11 -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f4 [ -id = 10 -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_9" -> "DS1_MEMORY":f13 [ -id = 11 -]; -"VS_XGL_DESCRIPTOR_SET_MAPPING":f4 -> "VS_XGL_DESCRIPTOR_SLOT_INFO":f0 [ -id = 12 -]; -"VS_XGL_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ -id = 13 -]; -"VS_XGL_DESCRIPTOR_SLOT_INFO":f6 -> "DS1_MEMORY":f1 [ -id = 14 -]; -"FS0_XGL_DESCRIPTOR_SET_MAPPING":f4 -> "FS0_XGL_DESCRIPTOR_SLOT_INFO":f0 [ -id = 15 -]; -"FS0_XGL_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ -id = 16 -]; -"FS0_XGL_DESCRIPTOR_SLOT_INFO":f26 -> "DS1_MEMORY":f5 [ -id = 17 -]; -"FS1_XGL_DESCRIPTOR_SET_MAPPING":f4 -> "FS1_XGL_DESCRIPTOR_SLOT_INFO":f0 [ -id = 15 -]; -"FS1_XGL_DESCRIPTOR_SLOT_INFO":f1 -> "DS2_MEMORY":f0 [ -id = 16 -]; -"FS1_XGL_DESCRIPTOR_SLOT_INFO":f46 -> "DS2_MEMORY":f9 [ -id = 17 -]; -} - diff --git a/docs/xgl_ds.png b/docs/xgl_ds.png deleted file mode 100644 index ffeb80c1..00000000 Binary files a/docs/xgl_ds.png and /dev/null differ diff --git a/docs/xgl_full_pipeline_ds.dot b/docs/xgl_full_pipeline_ds.dot deleted file mode 100644 index 53ae866c..00000000 --- a/docs/xgl_full_pipeline_ds.dot +++ /dev/null @@ -1,282 +0,0 @@ -digraph g { -graph [ -rankdir = "TB" -]; -node [ -fontsize = "16" -shape = "plaintext" -]; -edge [ -]; -"_XGL_GRAPHICS_PIPELINE_CREATE_INFO" [ -label = <
XGL_GRAPHICS_PIPELINE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
XGL_FLAGSflags
> -]; -"_XGL_PIPELINE_IA_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_IA_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
XGL_PRIMITIVE_TOPOLOGYtopology
bool32_tdisableVertexReuse
XGL_PROVOKING_VERTEX_CONVENTIONprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> -]; -"_XGL_PIPELINE_TESS_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_TESS_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> -]; -"_XGL_PIPELINE_RS_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_RS_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> -]; -"_XGL_PIPELINE_CB_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_CB_STATE
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
XGL_LOGIC_OPlogicOp
XGL_PIPELINE_CB_ATTACHMENT_STATEattachment
> -]; -"_XGL_PIPELINE_DB_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_DB_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
XGL_FORMATformat
> -]; -"VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"FS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
XGL_PIPELINE_SHADERshader
> -]; -"VS_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=VS
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"TC_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=TC
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"TE_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=TE
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"GS_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=GS
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"FS_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=FS
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"_XGL_GRAPHICS_PIPELINE_CREATE_INFO":f2 -> "_XGL_PIPELINE_IA_STATE_CREATE_INFO" [ -id = 100 -]; -"_XGL_PIPELINE_IA_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_TESS_STATE_CREATE_INFO" [ -id = 101 -]; -"_XGL_PIPELINE_TESS_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_RS_STATE_CREATE_INFO" [ -id = 102 -]; -"_XGL_PIPELINE_RS_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_CB_STATE_CREATE_INFO" [ -id = 103 -]; -"_XGL_PIPELINE_CB_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_DB_STATE_CREATE_INFO" [ -id = 104 -]; -"_XGL_PIPELINE_DB_STATE_CREATE_INFO":f2 -> "VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 105 -]; -"VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 106 -]; -"TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 107 -]; -"TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 108 -]; -"GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "FS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 109 -]; -"VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "VS_XGL_PIPELINE_SHADER" [ -id = 110 -]; -"TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TE_XGL_PIPELINE_SHADER" [ -id = 111 -]; -"TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TC_XGL_PIPELINE_SHADER" [ -id = 112 -]; -"GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "GS_XGL_PIPELINE_SHADER" [ -id = 113 -]; -"FS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "FS_XGL_PIPELINE_SHADER" [ -id = 114 -]; -subgraph clusterDSCreate1 -{ -label="xglCreateDescriptorSet()" -"_XGL_DESCRIPTOR_SET_CREATE_INFO1" [ -label = <
XGL_DESCRIPTOR_SET_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> -]; -} -subgraph clusterDSCreate2 -{ -label="xglCreateDescriptorSet()" -"_XGL_DESCRIPTOR_SET_CREATE_INFO2" [ -label = <
XGL_DESCRIPTOR_SET_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> -]; -} -subgraph clusterSamplerCreate -{ -label="xglCreateSampler - multiple calls return unique XGL_SAMPLER handles" -"_XGL_SAMPLER_CREATE_INFO_0" [ -label = <
XGL_SAMPLER_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
XGL_TEX_FILTERmagFilter
XGL_TEX_FILTERminFilter
XGL_TEX_MIPMAP_MODEmipMode
XGL_TEX_ADDRESSaddressU
XGL_TEX_ADDRESSaddressV
XGL_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
XGL_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
XGL_BORDER_COLOR_TYPEborderColorType
> -]; -"SAMPLER_ELLIPSES" [ -label = "..." -]; -"_XGL_SAMPLER_CREATE_INFO_19" [ -label = <
XGL_SAMPLER_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
XGL_TEX_FILTERmagFilter
XGL_TEX_FILTERminFilter
XGL_TEX_MIPMAP_MODEmipMode
XGL_TEX_ADDRESSaddressU
XGL_TEX_ADDRESSaddressV
XGL_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
XGL_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
XGL_BORDER_COLOR_TYPEborderColorType
> -]; -} -subgraph clusterSamplerAttach -{ -label="xglAttachSamplerDescriptors\npSamplers array of XGL_SAMPLERS" -"SAMPLER_ARRAY" [ -label = <
pSamplers
XGL_SAMPLER0
XGL_SAMPLER1
XGL_SAMPLER2
XGL_SAMPLER3
XGL_SAMPLER4
XGL_SAMPLER5
XGL_SAMPLER6
XGL_SAMPLER7
XGL_SAMPLER8
XGL_SAMPLER9
XGL_SAMPLER10
XGL_SAMPLER11
XGL_SAMPLER12
XGL_SAMPLER13
XGL_SAMPLER14
XGL_SAMPLER15
XGL_SAMPLER16
XGL_SAMPLER17
XGL_SAMPLER18
XGL_SAMPLER19
> -]; -} -"DS1_MEMORY" [ -label = <
DS1 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
> -]; -"DS2_MEMORY" [ -label = <
DS2 Memory
slot0
slot1
slots2
slots3
slots4
slots5
slots6
slots7
slots8
slots9
slots10
slots11
slots12
slot13
slots14
slots15
slots16
slots17
slots18
slots19
> -]; -subgraph clusterMemoryView -{ -label="xglAttachMemoryViewDescriptors - pMemViews array of XGL_MEMORY_VIEW_ATTACH_INFO structs" -"_XGL_MEMORY_VIEW_ATTACH_INFO_3" [ -label = <
XGL_MEMORY_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_GPU_MEMORYmem
XGL_GPU_SIZEoffset
XGL_GPU_SIZErange
XGL_GPU_SIZEstride
XGL_FORMATformat
XGL_MEMORY_STATEstate
> -]; -"MEM_VIEW_ELLIPSES" [ -label = "..." -]; -"_XGL_MEMORY_VIEW_ATTACH_INFO_0" [ -label = <
XGL_MEMORY_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_GPU_MEMORYmem
XGL_GPU_SIZEoffset
XGL_GPU_SIZErange
XGL_GPU_SIZEstride
XGL_FORMATformat
XGL_MEMORY_STATEstate
> -]; -} -subgraph clusterImageView -{ -label="xglAttachImageViewDescriptors - pImageViews array of XGL_IMAGE_VIEW_ATTACH_INFO structs" -"_XGL_IMAGE_VIEW_ATTACH_INFO_9" [ -label = <
XGL_IMAGE_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_IMAGE_VIEWview
XGL_IMAGE_STATEstate
> -]; -"IMG_VIEW_ELLIPSES" [ -label = "..." -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_0" [ -label = <
XGL_IMAGE_VIEW_ATTACH_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
XGL_IMAGE_VIEWview
XGL_IMAGE_STATEstate
> -]; -} -"VS_XGL_DESCRIPTOR_SET_MAPPING" [ -label = <
XGL_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=2
const XGL_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> -]; -"VS_XGL_DESCRIPTOR_SLOT_INFO" [ -label = <
XGL_DESCRIPTOR_SLOT_INFO
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE0
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE1
uint32_tshaderEntityIndex
> -]; -"FS0_XGL_DESCRIPTOR_SET_MAPPING" [ -label = <
XGL_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=6
const XGL_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> -]; -"FS0_XGL_DESCRIPTOR_SLOT_INFO" [ -label = <
XGL_DESCRIPTOR_SLOT_INFO
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_UNUSED0
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_UNUSED1
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE2
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE3
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_RESOURCE4
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_UAV5
uint32_tshaderEntityIndex
> -]; -"FS1_XGL_DESCRIPTOR_SET_MAPPING" [ -label = <
XGL_DESCRIPTOR_SET_MAPPING
uint32_tdescriptorCount=10
const XGL_DESCRIPTOR_SLOT_INFO*pDescriptorInfo
> -]; -"FS1_XGL_DESCRIPTOR_SLOT_INFO" [ -label = <
XGL_DESCRIPTOR_SLOT_INFO
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER0
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER1
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER2
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER3
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER4
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER5
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER6
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER7
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER8
uint32_tshaderEntityIndex
XGL_DESCRIPTOR_SET_SLOT_TYPEXGL_SLOT_SHADER_SAMPLER9
uint32_tshaderEntityIndex
> -]; -/* -"_XGL_DESCRIPTOR_SET_CREATE_INFO1":f2 -> "_XGL_DESCRIPTOR_SET_CREATE_INFO2":f0 [ -id = 0 -]; -*/ -"_XGL_DESCRIPTOR_SET_CREATE_INFO1":f4 -> "DS1_MEMORY":ds1 [ -id = 1 -]; -"_XGL_DESCRIPTOR_SET_CREATE_INFO2":f4 -> "DS2_MEMORY":ds2 [ -id = 2 -]; -/* -"_XGL_SAMPLER_CREATE_INFO_0":f4 -> "_ELLIPSE0" [ -id = 3 -]; -"_ELLIPSE0" -> "_XGL_SAMPLER_CREATE_INFO_19":f0 [ -id = 3 -]; -*/ -"_XGL_SAMPLER_CREATE_INFO_0" -> "SAMPLER_ARRAY":f0 [ -id = 4 -]; -"_XGL_SAMPLER_CREATE_INFO_19" -> "SAMPLER_ARRAY":f19 [ -id = 5 -]; -"SAMPLER_ARRAY":f0 -> "DS2_MEMORY":f0 [ -id = 6 -]; -"SAMPLER_ARRAY":f19 -> "DS2_MEMORY":f19 [ -id = 7 -]; -/* -"_XGL_MEMORY_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE1" [ -id = 6 -]; -"_ELLIPSE1" -> "_XGL_MEMORY_VIEW_ATTACH_INFO_3":f0 [ -id = 7 -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_0":f4 -> "_ELLIPSE2" [ -id = 8 -]; -"_ELLIPSE2" -> "_XGL_IMAGE_VIEW_ATTACH_INFO_9":f0 [ -id = 9 -]; -*/ -"_XGL_MEMORY_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f0 [ -id = 10 -]; -"_XGL_MEMORY_VIEW_ATTACH_INFO_3" -> "DS1_MEMORY":f3 [ -id = 11 -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_0" -> "DS1_MEMORY":f4 [ -id = 10 -]; -"_XGL_IMAGE_VIEW_ATTACH_INFO_9" -> "DS1_MEMORY":f13 [ -id = 11 -]; -"VS_XGL_DESCRIPTOR_SET_MAPPING":f4 -> "VS_XGL_DESCRIPTOR_SLOT_INFO":f0 [ -id = 12 -]; -"VS_XGL_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ -id = 13 -]; -"VS_XGL_DESCRIPTOR_SLOT_INFO":f6 -> "DS1_MEMORY":f1 [ -id = 14 -]; -"FS0_XGL_DESCRIPTOR_SET_MAPPING":f4 -> "FS0_XGL_DESCRIPTOR_SLOT_INFO":f0 [ -id = 15 -]; -"FS0_XGL_DESCRIPTOR_SLOT_INFO":f1 -> "DS1_MEMORY":f0 [ -id = 16 -]; -"FS0_XGL_DESCRIPTOR_SLOT_INFO":f26 -> "DS1_MEMORY":f5 [ -id = 17 -]; -"FS1_XGL_DESCRIPTOR_SET_MAPPING":f4 -> "FS1_XGL_DESCRIPTOR_SLOT_INFO":f0 [ -id = 15 -]; -"FS1_XGL_DESCRIPTOR_SLOT_INFO":f1 -> "DS2_MEMORY":f0 [ -id = 16 -]; -"FS1_XGL_DESCRIPTOR_SLOT_INFO":f46 -> "DS2_MEMORY":f9 [ -id = 17 -]; -"FS_XGL_PIPELINE_SHADER":f6 -> "FS0_XGL_DESCRIPTOR_SET_MAPPING" [ -id = 18 -]; -"FS_XGL_PIPELINE_SHADER":f6 -> "FS1_XGL_DESCRIPTOR_SET_MAPPING" [ -id = 19 -]; -"VS_XGL_PIPELINE_SHADER":f6 -> "VS_XGL_DESCRIPTOR_SET_MAPPING" [ -id = 20 -]; -} - diff --git a/docs/xgl_full_pipeline_ds.png b/docs/xgl_full_pipeline_ds.png deleted file mode 100644 index cec76227..00000000 Binary files a/docs/xgl_full_pipeline_ds.png and /dev/null differ diff --git a/docs/xgl_graphics_pipeline.dot b/docs/xgl_graphics_pipeline.dot deleted file mode 100644 index e5434f6b..00000000 --- a/docs/xgl_graphics_pipeline.dot +++ /dev/null @@ -1,105 +0,0 @@ -digraph g { -graph [ -rankdir = "TB" -]; -node [ -fontsize = "16" -shape = "plaintext" -]; -edge [ -]; -"_XGL_GRAPHICS_PIPELINE_CREATE_INFO" [ -label = <
XGL_GRAPHICS_PIPELINE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
XGL_FLAGSflags
> -]; -"_XGL_PIPELINE_IA_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_IA_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
XGL_PRIMITIVE_TOPOLOGYtopology
bool32_tdisableVertexReuse
XGL_PROVOKING_VERTEX_CONVENTIONprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> -]; -"_XGL_PIPELINE_TESS_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_TESS_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> -]; -"_XGL_PIPELINE_RS_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_RS_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> -]; -"_XGL_PIPELINE_CB_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_CB_STATE
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
XGL_LOGIC_OPlogicOp
XGL_PIPELINE_CB_ATTACHMENT_STATEattachment
> -]; -"_XGL_PIPELINE_DB_STATE_CREATE_INFO" [ -label = <
XGL_PIPELINE_DB_STATE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
XGL_FORMATformat
> -]; -"VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
XGL_PIPELINE_SHADERshader
> -]; -"FS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
XGL_STRUCTURE_TYPEsType=
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
XGL_PIPELINE_SHADERshader
> -]; -"VS_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=VS
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"TC_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=TC
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"TE_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=TE
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"GS_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=GS
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"FS_XGL_PIPELINE_SHADER" [ -label = <
XGL_PIPELINE_SHADER
XGL_PIPELINE_SHADER_STAGEstage=FS
XGL_SHADERshader
XGL_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const XGL_LINK_CONST_BUFFER*pLinkConstBufferInfo
XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> -]; -"_XGL_GRAPHICS_PIPELINE_CREATE_INFO":f2 -> "_XGL_PIPELINE_IA_STATE_CREATE_INFO" [ -id = 0 -]; -"_XGL_PIPELINE_IA_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_TESS_STATE_CREATE_INFO" [ -id = 1 -]; -"_XGL_PIPELINE_TESS_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_RS_STATE_CREATE_INFO" [ -id = 2 -]; -"_XGL_PIPELINE_RS_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_CB_STATE_CREATE_INFO" [ -id = 3 -]; -"_XGL_PIPELINE_CB_STATE_CREATE_INFO":f2 -> "_XGL_PIPELINE_DB_STATE_CREATE_INFO" [ -id = 4 -]; -"_XGL_PIPELINE_DB_STATE_CREATE_INFO":f2 -> "VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 5 -]; -"VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 6 -]; -"TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 7 -]; -"TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 8 -]; -"GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f2 -> "FS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -id = 9 -]; -"VS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "VS_XGL_PIPELINE_SHADER" [ -id = 10 -]; -"TE_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TE_XGL_PIPELINE_SHADER" [ -id = 11 -]; -"TC_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "TC_XGL_PIPELINE_SHADER" [ -id = 12 -]; -"GS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "GS_XGL_PIPELINE_SHADER" [ -id = 13 -]; -"FS_XGL_PIPELINE_SHADER_STAGE_CREATE_INFO":f4 -> "FS_XGL_PIPELINE_SHADER" [ -id = 14 -]; -} - diff --git a/docs/xgl_graphics_pipeline.png b/docs/xgl_graphics_pipeline.png deleted file mode 100644 index 392fd3f3..00000000 Binary files a/docs/xgl_graphics_pipeline.png and /dev/null differ diff --git a/icd/nulldrv/CMakeLists.txt b/icd/nulldrv/CMakeLists.txt index 7b1e182b..54b3122b 100644 --- a/icd/nulldrv/CMakeLists.txt +++ b/icd/nulldrv/CMakeLists.txt @@ -1,10 +1,10 @@ -# Create the nulldrv XGL DRI library +# Create the nulldrv Vulkan DRI library set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES") add_custom_command(OUTPUT nulldrv_gpa.c - COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py icd-get-proc-addr > nulldrv_gpa.c - DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py) + COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk-generate.py icd-get-proc-addr > nulldrv_gpa.c + DEPENDS ${PROJECT_SOURCE_DIR}/vk-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py) set(sources nulldrv.c @@ -20,14 +20,14 @@ if (WIN32) list(APPEND definitions -DENABLE_WSI_WINDOWS) endif() -add_library(XGL_nulldrv SHARED ${sources}) -target_compile_definitions(XGL_nulldrv PRIVATE ${definitions}) -target_include_directories(XGL_nulldrv PRIVATE ${include_dirs}) -target_link_libraries(XGL_nulldrv ${libraries}) +add_library(VK_nulldrv SHARED ${sources}) +target_compile_definitions(VK_nulldrv PRIVATE ${definitions}) +target_include_directories(VK_nulldrv PRIVATE ${include_dirs}) +target_link_libraries(VK_nulldrv ${libraries}) if (WIN32) # Add in the DLL "map" file for vkGetProcAddr() - set_target_properties(XGL_nulldrv PROPERTIES + set_target_properties(VK_nulldrv PROPERTIES LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/icd/nulldrv/VK_nulldrv.def") endif() diff --git a/include/vk.h b/include/vk.h deleted file mode 100644 index b78a56cd..00000000 --- a/include/vk.h +++ /dev/null @@ -1,3135 +0,0 @@ -// -// File: vulkan.h -// -/* -** Copyright (c) 2014 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - -#ifndef __VULKAN_H__ -#define __VULKAN_H__ - -#define VK_MAKE_VERSION(major, minor, patch) \ - ((major << 22) | (minor << 12) | patch) - -#include "vkPlatform.h" - -// VK API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 67, 0) - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -/* -*************************************************************************************************** -* Core VK API -*************************************************************************************************** -*/ - -#ifdef __cplusplus - #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 VK_DEFINE_HANDLE(_obj) typedef void* _obj; - #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj; -#endif // __cplusplus - -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 VK_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF - -// ------------------------------------------------------------------------------------------------ -// Enumerations - - -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, - - 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 _VK_RESULT -{ - // Return codes for successful operation execution (>= 0) - 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) - 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; - -// ------------------------------------------------------------------------------------------------ -// 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 _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 _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 _VK_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 _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 _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 _VK_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 _VK_BUFFER_VIEW_TYPE -{ - 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) - - 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 _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 _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 _VK_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 _VK_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 _VK_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 _VK_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 _VK_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 _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 _VK_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 _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 _VK_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; - -// ------------------------------------------------------------------------------------------------ -// VK structures - -typedef struct _VK_OFFSET2D -{ - int32_t x; - int32_t y; -} VK_OFFSET2D; - -typedef struct _VK_OFFSET3D -{ - int32_t x; - int32_t y; - int32_t z; -} VK_OFFSET3D; - -typedef struct _VK_EXTENT2D -{ - int32_t width; - int32_t height; -} VK_EXTENT2D; - -typedef struct _VK_EXTENT3D -{ - int32_t width; - int32_t height; - int32_t depth; -} VK_EXTENT3D; - -typedef struct _VK_VIEWPORT -{ - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; -} VK_VIEWPORT; - -typedef struct _VK_RECT -{ - VK_OFFSET2D offset; - VK_EXTENT2D extent; -} VK_RECT; - -typedef struct _VK_CHANNEL_MAPPING -{ - VK_CHANNEL_SWIZZLE r; - VK_CHANNEL_SWIZZLE g; - VK_CHANNEL_SWIZZLE b; - VK_CHANNEL_SWIZZLE a; -} VK_CHANNEL_MAPPING; - -typedef struct _VK_PHYSICAL_GPU_PROPERTIES -{ - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorId; - uint32_t deviceId; - 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; - bool32_t multiColorAttachmentClears; - uint32_t maxDescriptorSets; // at least 2? - uint32_t maxViewports; // at least 16? - uint32_t maxColorAttachments; // at least 8? -} VK_PHYSICAL_GPU_PROPERTIES; - -typedef struct _VK_PHYSICAL_GPU_PERFORMANCE -{ - float maxGpuClock; - float aluPerClock; - float texPerClock; - float primsPerClock; - float pixelsPerClock; -} VK_PHYSICAL_GPU_PERFORMANCE; - -typedef struct _VK_GPU_COMPATIBILITY_INFO -{ - VK_FLAGS compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS -} VK_GPU_COMPATIBILITY_INFO; - -typedef struct _VK_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; -} VK_APPLICATION_INFO; - -typedef void* (VKAPI *VK_ALLOC_FUNCTION)( - void* pUserData, - size_t size, - size_t alignment, - VK_SYSTEM_ALLOC_TYPE allocType); - -typedef void (VKAPI *VK_FREE_FUNCTION)( - void* pUserData, - void* pMem); - -typedef struct _VK_ALLOC_CALLBACKS -{ - void* pUserData; - VK_ALLOC_FUNCTION pfnAlloc; - VK_FREE_FUNCTION pfnFree; -} VK_ALLOC_CALLBACKS; - -typedef struct _VK_DEVICE_QUEUE_CREATE_INFO -{ - uint32_t queueNodeIndex; - uint32_t queueCount; -} VK_DEVICE_QUEUE_CREATE_INFO; - -typedef struct _VK_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 VK_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; - VK_VALIDATION_LEVEL maxValidationLevel; - VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS -} VK_DEVICE_CREATE_INFO; - -typedef struct _VK_INSTANCE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO - const void* pNext; // Pointer to next structure - const VK_APPLICATION_INFO* pAppInfo; - const VK_ALLOC_CALLBACKS* pAllocCb; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled -} VK_INSTANCE_CREATE_INFO; - -// can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext -typedef struct _VK_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 vkEnumerateLayers()) -} VK_LAYER_CREATE_INFO; - -typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES -{ - 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 -} VK_PHYSICAL_GPU_QUEUE_PROPERTIES; - -typedef struct _VK_PHYSICAL_GPU_MEMORY_PROPERTIES -{ - bool32_t supportsMigration; - bool32_t supportsPinning; -} VK_PHYSICAL_GPU_MEMORY_PROPERTIES; - -typedef struct _VK_MEMORY_ALLOC_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO - const void* pNext; // Pointer to next structure - 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 VK_MEMORY_ALLOC_INFO chain -// for memory regions allocated for buffer usage. -typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS -} VK_MEMORY_ALLOC_BUFFER_INFO; - -// This structure is included in the VK_MEMORY_ALLOC_INFO chain -// for memory regions allocated for image usage. -typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; - uint32_t samples; -} VK_MEMORY_ALLOC_IMAGE_INFO; - -typedef struct _VK_MEMORY_OPEN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_GPU_MEMORY sharedMem; -} VK_MEMORY_OPEN_INFO; - -typedef struct _VK_PEER_MEMORY_OPEN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_GPU_MEMORY originalMem; -} VK_PEER_MEMORY_OPEN_INFO; - -typedef struct _VK_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 _VK_BUFFER_MEMORY_REQUIREMENTS -{ - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS -} VK_BUFFER_MEMORY_REQUIREMENTS; - -typedef struct _VK_IMAGE_MEMORY_REQUIREMENTS -{ - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; - uint32_t samples; -} VK_IMAGE_MEMORY_REQUIREMENTS; - -typedef struct _VK_FORMAT_PROPERTIES -{ - VK_FLAGS linearTilingFeatures; // VK_FORMAT_FEATURE_FLAGS - VK_FLAGS optimalTilingFeatures; // VK_FORMAT_FEATURE_FLAGS -} VK_FORMAT_PROPERTIES; - -typedef struct _VK_BUFFER_VIEW_ATTACH_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VK_BUFFER_VIEW view; -} VK_BUFFER_VIEW_ATTACH_INFO; - -typedef struct _VK_IMAGE_VIEW_ATTACH_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VK_IMAGE_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_IMAGE_VIEW_ATTACH_INFO; - -typedef struct _VK_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 VK_SAMPLER* pSamplers; -} VK_UPDATE_SAMPLERS; - -typedef struct _VK_SAMPLER_IMAGE_VIEW_INFO -{ - VK_SAMPLER sampler; - const VK_IMAGE_VIEW_ATTACH_INFO* pImageView; -} VK_SAMPLER_IMAGE_VIEW_INFO; - -typedef struct _VK_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 VK_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews; -} VK_UPDATE_SAMPLER_TEXTURES; - -typedef struct _VK_UPDATE_IMAGES -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES - const void* pNext; // Pointer to next structure - 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 VK_IMAGE_VIEW_ATTACH_INFO* pImageViews; -} VK_UPDATE_IMAGES; - -typedef struct _VK_UPDATE_BUFFERS -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS - const void* pNext; // Pointer to next structure - 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 VK_BUFFER_VIEW_ATTACH_INFO* pBufferViews; -} VK_UPDATE_BUFFERS; - -typedef struct _VK_UPDATE_AS_COPY -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY - const void* pNext; // Pointer to next structure - VK_DESCRIPTOR_TYPE descriptorType; - VK_DESCRIPTOR_SET descriptorSet; - uint32_t binding; - uint32_t arrayElement; - uint32_t count; -} VK_UPDATE_AS_COPY; - -typedef struct _VK_BUFFER_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO - const void* pNext; // Pointer to next structure. - 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 _VK_BUFFER_VIEW_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure. - 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 _VK_IMAGE_SUBRESOURCE -{ - VK_IMAGE_ASPECT aspect; - uint32_t mipLevel; - uint32_t arraySlice; -} VK_IMAGE_SUBRESOURCE; - -typedef struct _VK_IMAGE_SUBRESOURCE_RANGE -{ - VK_IMAGE_ASPECT aspect; - uint32_t baseMipLevel; - uint32_t mipLevels; - uint32_t baseArraySlice; - uint32_t arraySize; -} VK_IMAGE_SUBRESOURCE_RANGE; - -typedef struct _VK_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 VK_EVENT* pEvents; // Array of event objects to wait on - - 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 VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) -} VK_EVENT_WAIT_INFO; - -typedef struct _VK_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 VK_PIPE_EVENT* pEvents; // Array of pipeline events to wait on - - 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 VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) -} VK_PIPELINE_BARRIER; - -typedef struct _VK_MEMORY_BARRIER -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - 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 _VK_BUFFER_MEMORY_BARRIER -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - 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_BUFFER buffer; // Buffer to sync - - 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 _VK_IMAGE_MEMORY_BARRIER -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - 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_IMAGE_LAYOUT oldLayout; // Current layout of the image - VK_IMAGE_LAYOUT newLayout; // New layout to transition the image to - - VK_IMAGE image; // Image to sync - - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync -} VK_IMAGE_MEMORY_BARRIER; - -typedef struct _VK_IMAGE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO - const void* pNext; // Pointer to next structure. - VK_IMAGE_TYPE imageType; - VK_FORMAT format; - VK_EXTENT3D extent; - uint32_t mipLevels; - uint32_t arraySize; - uint32_t samples; - VK_IMAGE_TILING tiling; - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS -} VK_IMAGE_CREATE_INFO; - -typedef struct _VK_PEER_IMAGE_OPEN_INFO -{ - VK_IMAGE originalImage; -} VK_PEER_IMAGE_OPEN_INFO; - -typedef struct _VK_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 _VK_IMAGE_VIEW_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_IMAGE image; - VK_IMAGE_VIEW_TYPE viewType; - VK_FORMAT format; - VK_CHANNEL_MAPPING channels; - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; - float minLod; -} VK_IMAGE_VIEW_CREATE_INFO; - -typedef struct _VK_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 - VK_IMAGE image; - VK_FORMAT format; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VK_IMAGE msaaResolveImage; - VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; -} VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO; - -typedef struct _VK_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 - VK_IMAGE image; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - 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 _VK_COLOR_ATTACHMENT_BIND_INFO -{ - VK_COLOR_ATTACHMENT_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_COLOR_ATTACHMENT_BIND_INFO; - -typedef struct _VK_DEPTH_STENCIL_BIND_INFO -{ - VK_DEPTH_STENCIL_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_DEPTH_STENCIL_BIND_INFO; - -typedef struct _VK_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 _VK_IMAGE_MEMORY_BIND_INFO -{ - VK_IMAGE_SUBRESOURCE subresource; - VK_OFFSET3D offset; - VK_EXTENT3D extent; -} VK_IMAGE_MEMORY_BIND_INFO; - -typedef struct _VK_IMAGE_COPY -{ - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET3D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET3D destOffset; - VK_EXTENT3D extent; -} VK_IMAGE_COPY; - -typedef struct _VK_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 _VK_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 _VK_IMAGE_RESOLVE -{ - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET2D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET2D destOffset; - VK_EXTENT2D extent; -} VK_IMAGE_RESOLVE; - -typedef struct _VK_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; - VK_FLAGS flags; // Reserved -} VK_SHADER_CREATE_INFO; - -typedef struct _VK_DESCRIPTOR_SET_LAYOUT_BINDING -{ - VK_DESCRIPTOR_TYPE descriptorType; - uint32_t count; - VK_FLAGS stageFlags; // VK_SHADER_STAGE_FLAGS - const VK_SAMPLER* pImmutableSamplers; -} VK_DESCRIPTOR_SET_LAYOUT_BINDING; - -typedef struct _VK_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 VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings -} VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; - -typedef struct _VK_DESCRIPTOR_TYPE_COUNT -{ - VK_DESCRIPTOR_TYPE type; - uint32_t count; -} VK_DESCRIPTOR_TYPE_COUNT; - -typedef struct _VK_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 VK_DESCRIPTOR_TYPE_COUNT* pTypeCount; -} VK_DESCRIPTOR_POOL_CREATE_INFO; - -typedef struct _VK_LINK_CONST_BUFFER -{ - uint32_t bufferId; - size_t bufferSize; - const void* pBufferData; -} VK_LINK_CONST_BUFFER; - -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 -} VK_SPECIALIZATION_MAP_ENTRY; - -typedef struct _VK_SPECIALIZATION_INFO -{ - uint32_t mapEntryCount; - const VK_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries - const void* pData; -} VK_SPECIALIZATION_INFO; - -typedef struct _VK_PIPELINE_SHADER -{ - VK_PIPELINE_SHADER_STAGE stage; - VK_SHADER shader; - uint32_t linkConstBufferCount; - const VK_LINK_CONST_BUFFER* pLinkConstBufferInfo; - const VK_SPECIALIZATION_INFO* pSpecializationInfo; -} VK_PIPELINE_SHADER; - -typedef struct _VK_COMPUTE_PIPELINE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - 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; - -} VK_COMPUTE_PIPELINE_CREATE_INFO; - -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) - - VK_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented -} VK_VERTEX_INPUT_BINDING_DESCRIPTION; - -typedef struct _VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION -{ - uint32_t location; // location of the shader vertex attrib - uint32_t binding; // Vertex buffer binding id - - VK_FORMAT format; // format of source data - - uint32_t offsetInBytes; // Offset of first element in bytes from base of vertex -} VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION; - -typedef struct _VK_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 VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; - - uint32_t attributeCount; // number of attributes - const VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; -} VK_PIPELINE_VERTEX_INPUT_CREATE_INFO; - -typedef struct _VK_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 - VK_PRIMITIVE_TOPOLOGY topology; - bool32_t disableVertexReuse; // optional - bool32_t primitiveRestartEnable; - uint32_t primitiveRestartIndex; // optional (GL45) -} VK_PIPELINE_IA_STATE_CREATE_INFO; - -typedef struct _VK_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; -} VK_PIPELINE_TESS_STATE_CREATE_INFO; - -typedef struct _VK_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; - VK_COORDINATE_ORIGIN clipOrigin; // optional (GL45) - VK_DEPTH_MODE depthMode; // optional (GL45) -} VK_PIPELINE_VP_STATE_CREATE_INFO; - -typedef struct _VK_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) - 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 _VK_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) - VK_SAMPLE_MASK sampleMask; -} VK_PIPELINE_MS_STATE_CREATE_INFO; - -typedef struct _VK_PIPELINE_CB_ATTACHMENT_STATE -{ - bool32_t blendEnable; - 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; -} VK_PIPELINE_CB_ATTACHMENT_STATE; - -typedef struct _VK_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; - VK_LOGIC_OP logicOp; - uint32_t attachmentCount; // # of pAttachments - const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; -} VK_PIPELINE_CB_STATE_CREATE_INFO; - -typedef struct _VK_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 _VK_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 - VK_FORMAT format; - bool32_t depthTestEnable; - bool32_t depthWriteEnable; - VK_COMPARE_FUNC depthFunc; - bool32_t depthBoundsEnable; // optional (depth_bounds_test) - bool32_t stencilTestEnable; - VK_STENCIL_OP_STATE front; - VK_STENCIL_OP_STATE back; -} VK_PIPELINE_DS_STATE_CREATE_INFO; - -typedef struct _VK_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 - VK_PIPELINE_SHADER shader; -} VK_PIPELINE_SHADER_STAGE_CREATE_INFO; - -typedef struct _VK_GRAPHICS_PIPELINE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS - VK_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain; -} VK_GRAPHICS_PIPELINE_CREATE_INFO; - -typedef struct _VK_SAMPLER_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO - const void* pNext; // Pointer to next structure - 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; - VK_COMPARE_FUNC compareFunc; - float minLod; - float maxLod; - VK_BORDER_COLOR_TYPE borderColorType; -} VK_SAMPLER_CREATE_INFO; - -typedef struct _VK_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 VK_VIEWPORT* pViewports; - const VK_RECT* pScissors; -} VK_DYNAMIC_VP_STATE_CREATE_INFO; - -typedef struct _VK_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; - float slopeScaledDepthBias; - float pointSize; // optional (GL45) - Size of points - float pointFadeThreshold; // optional (GL45) - Size of point fade threshold - float lineWidth; // optional (GL45) - Width of lines -} VK_DYNAMIC_RS_STATE_CREATE_INFO; - -typedef struct _VK_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]; -} VK_DYNAMIC_CB_STATE_CREATE_INFO; - -typedef struct _VK_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) - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; -} VK_DYNAMIC_DS_STATE_CREATE_INFO; - -typedef struct _VK_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; - VK_FLAGS flags; -} VK_CMD_BUFFER_CREATE_INFO; - -typedef struct _VK_CMD_BUFFER_BEGIN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO - const void* pNext; // Pointer to next structure - - VK_FLAGS flags; // VK_CMD_BUFFER_BUILD_FLAGS -} VK_CMD_BUFFER_BEGIN_INFO; - -typedef struct _VK_RENDER_PASS_BEGIN -{ - VK_RENDER_PASS renderPass; - VK_FRAMEBUFFER framebuffer; -} VK_RENDER_PASS_BEGIN; - -typedef struct _VK_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 - - 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 _VK_CLEAR_COLOR_VALUE -{ - float floatColor[4]; - uint32_t rawColor[4]; -} VK_CLEAR_COLOR_VALUE; - -typedef struct _VK_CLEAR_COLOR -{ - VK_CLEAR_COLOR_VALUE color; - bool32_t useRawValue; -} VK_CLEAR_COLOR; - -typedef struct _VK_RENDER_PASS_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO - const void* pNext; // Pointer to next structure - - VK_RECT renderArea; - uint32_t colorAttachmentCount; - VK_EXTENT2D extent; - uint32_t sampleCount; - uint32_t layers; - 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; - VK_ATTACHMENT_STORE_OP depthStoreOp; - VK_ATTACHMENT_LOAD_OP stencilLoadOp; - uint32_t stencilLoadClearValue; - VK_ATTACHMENT_STORE_OP stencilStoreOp; -} VK_RENDER_PASS_CREATE_INFO; - -typedef struct _VK_EVENT_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS flags; // Reserved -} VK_EVENT_CREATE_INFO; - -typedef struct _VK_FENCE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FENCE_CREATE_FLAGS flags; // VK_FENCE_CREATE_FLAGS -} VK_FENCE_CREATE_INFO; - -typedef struct _VK_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; - VK_FLAGS flags; // VK_SEMAPHORE_CREATE_FLAGS -} VK_SEMAPHORE_CREATE_INFO; - -typedef struct _VK_SEMAPHORE_OPEN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_SEMAPHORE sharedSemaphore; -} VK_SEMAPHORE_OPEN_INFO; - -typedef struct _VK_PIPELINE_STATISTICS_DATA -{ - uint64_t fsInvocations; // Fragment shader invocations - uint64_t cPrimitives; // Clipper primitives - uint64_t cInvocations; // Clipper invocations - uint64_t vsInvocations; // Vertex shader invocations - uint64_t gsInvocations; // Geometry shader invocations - uint64_t gsPrimitives; // Geometry shader primitives - uint64_t iaPrimitives; // Input primitives - uint64_t iaVertices; // Input vertices - uint64_t tcsInvocations; // Tessellation control shader invocations - uint64_t tesInvocations; // Tessellation evaluation shader invocations - uint64_t csInvocations; // Compute shader invocations -} VK_PIPELINE_STATISTICS_DATA; - -typedef struct _VK_QUERY_POOL_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_QUERY_TYPE queryType; - uint32_t slots; -} VK_QUERY_POOL_CREATE_INFO; - -typedef struct _VK_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 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; -} VK_FRAMEBUFFER_CREATE_INFO; - -typedef struct _VK_DRAW_INDIRECT_CMD -{ - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VK_DRAW_INDIRECT_CMD; - -typedef struct _VK_DRAW_INDEXED_INDIRECT_CMD -{ - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VK_DRAW_INDEXED_INDIRECT_CMD; - -typedef struct _VK_DISPATCH_INDIRECT_CMD -{ - uint32_t x; - uint32_t y; - uint32_t z; -} VK_DISPATCH_INDIRECT_CMD; - -// ------------------------------------------------------------------------------------------------ -// API functions -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 - -VK_RESULT VKAPI vkCreateInstance( - const VK_INSTANCE_CREATE_INFO* pCreateInfo, - VK_INSTANCE* pInstance); - -VK_RESULT VKAPI vkDestroyInstance( - VK_INSTANCE instance); - -VK_RESULT VKAPI vkEnumerateGpus( - VK_INSTANCE instance, - uint32_t maxGpus, - uint32_t* pGpuCount, - VK_PHYSICAL_GPU* pGpus); - -VK_RESULT VKAPI vkGetGpuInfo( - VK_PHYSICAL_GPU gpu, - VK_PHYSICAL_GPU_INFO_TYPE infoType, - size_t* pDataSize, - void* pData); - -void * VKAPI vkGetProcAddr( - VK_PHYSICAL_GPU gpu, - const char* pName); - -// Device functions - -VK_RESULT VKAPI vkCreateDevice( - VK_PHYSICAL_GPU gpu, - const VK_DEVICE_CREATE_INFO* pCreateInfo, - VK_DEVICE* pDevice); - -VK_RESULT VKAPI vkDestroyDevice( - VK_DEVICE device); - -// Extension discovery functions - -VK_RESULT VKAPI vkGetExtensionSupport( - VK_PHYSICAL_GPU gpu, - const char* pExtName); - -// Layer discovery functions - -VK_RESULT VKAPI vkEnumerateLayers( - VK_PHYSICAL_GPU gpu, - size_t maxLayerCount, - size_t maxStringSize, - size_t* pOutLayerCount, - char* const* pOutLayers, - void* pReserved); - -// Queue functions - -VK_RESULT VKAPI vkGetDeviceQueue( - VK_DEVICE device, - uint32_t queueNodeIndex, - uint32_t queueIndex, - VK_QUEUE* pQueue); - -VK_RESULT VKAPI vkQueueSubmit( - VK_QUEUE queue, - uint32_t cmdBufferCount, - const VK_CMD_BUFFER* pCmdBuffers, - VK_FENCE fence); - -VK_RESULT VKAPI vkQueueAddMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkQueueRemoveMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkQueueWaitIdle( - VK_QUEUE queue); - -VK_RESULT VKAPI vkDeviceWaitIdle( - VK_DEVICE device); - -// Memory functions - -VK_RESULT VKAPI vkAllocMemory( - VK_DEVICE device, - const VK_MEMORY_ALLOC_INFO* pAllocInfo, - VK_GPU_MEMORY* pMem); - -VK_RESULT VKAPI vkFreeMemory( - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkSetMemoryPriority( - VK_GPU_MEMORY mem, - VK_MEMORY_PRIORITY priority); - -VK_RESULT VKAPI vkMapMemory( - VK_GPU_MEMORY mem, - VK_FLAGS flags, // Reserved - void** ppData); - -VK_RESULT VKAPI vkUnmapMemory( - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkPinSystemMemory( - VK_DEVICE device, - const void* pSysMem, - size_t memSize, - VK_GPU_MEMORY* pMem); - -// Multi-device functions - -VK_RESULT VKAPI vkGetMultiGpuCompatibility( - VK_PHYSICAL_GPU gpu0, - VK_PHYSICAL_GPU gpu1, - VK_GPU_COMPATIBILITY_INFO* pInfo); - -VK_RESULT VKAPI vkOpenSharedMemory( - VK_DEVICE device, - const VK_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem); - -VK_RESULT VKAPI vkOpenSharedSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, - VK_SEMAPHORE* pSemaphore); - -VK_RESULT VKAPI vkOpenPeerMemory( - VK_DEVICE device, - const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, - VK_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 - -VK_RESULT VKAPI vkDestroyObject( - VK_OBJECT object); - -VK_RESULT VKAPI vkGetObjectInfo( - VK_BASE_OBJECT object, - VK_OBJECT_INFO_TYPE infoType, - size_t* pDataSize, - void* pData); - -VK_RESULT VKAPI vkBindObjectMemory( - VK_OBJECT object, - uint32_t allocationIdx, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); - -VK_RESULT VKAPI vkBindObjectMemoryRange( - VK_OBJECT object, - uint32_t allocationIdx, - VK_GPU_SIZE rangeOffset, - VK_GPU_SIZE rangeSize, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); - -VK_RESULT VKAPI vkBindImageMemoryRange( - VK_IMAGE image, - uint32_t allocationIdx, - const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); - -// Fence functions - -VK_RESULT VKAPI vkCreateFence( - VK_DEVICE device, - const VK_FENCE_CREATE_INFO* pCreateInfo, - VK_FENCE* pFence); - -VK_RESULT VKAPI vkResetFences( - VK_DEVICE device, - uint32_t fenceCount, - VK_FENCE* pFences); - -VK_RESULT VKAPI vkGetFenceStatus( - VK_FENCE fence); - -VK_RESULT VKAPI vkWaitForFences( - VK_DEVICE device, - uint32_t fenceCount, - const VK_FENCE* pFences, - bool32_t waitAll, - uint64_t timeout); // timeout in nanoseconds - -// Queue semaphore functions - -VK_RESULT VKAPI vkCreateSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, - VK_SEMAPHORE* pSemaphore); - -VK_RESULT VKAPI vkQueueSignalSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); - -VK_RESULT VKAPI vkQueueWaitSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); - -// Event functions - -VK_RESULT VKAPI vkCreateEvent( - VK_DEVICE device, - const VK_EVENT_CREATE_INFO* pCreateInfo, - VK_EVENT* pEvent); - -VK_RESULT VKAPI vkGetEventStatus( - VK_EVENT event); - -VK_RESULT VKAPI vkSetEvent( - VK_EVENT event); - -VK_RESULT VKAPI vkResetEvent( - VK_EVENT event); - -// Query functions - -VK_RESULT VKAPI vkCreateQueryPool( - VK_DEVICE device, - const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, - VK_QUERY_POOL* pQueryPool); - -VK_RESULT VKAPI vkGetQueryPoolResults( - VK_QUERY_POOL queryPool, - uint32_t startQuery, - uint32_t queryCount, - size_t* pDataSize, - void* pData); - -// Format capabilities - -VK_RESULT VKAPI vkGetFormatInfo( - VK_DEVICE device, - VK_FORMAT format, - VK_FORMAT_INFO_TYPE infoType, - size_t* pDataSize, - void* pData); - -// Buffer functions - -VK_RESULT VKAPI vkCreateBuffer( - VK_DEVICE device, - const VK_BUFFER_CREATE_INFO* pCreateInfo, - VK_BUFFER* pBuffer); - -// Buffer view functions - -VK_RESULT VKAPI vkCreateBufferView( - VK_DEVICE device, - const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, - VK_BUFFER_VIEW* pView); - -// Image functions - -VK_RESULT VKAPI vkCreateImage( - VK_DEVICE device, - const VK_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage); - -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 - -VK_RESULT VKAPI vkCreateImageView( - VK_DEVICE device, - const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, - VK_IMAGE_VIEW* pView); - -VK_RESULT VKAPI vkCreateColorAttachmentView( - VK_DEVICE device, - const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - VK_COLOR_ATTACHMENT_VIEW* pView); - -VK_RESULT VKAPI vkCreateDepthStencilView( - VK_DEVICE device, - const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, - VK_DEPTH_STENCIL_VIEW* pView); - -// Shader functions - -VK_RESULT VKAPI vkCreateShader( - VK_DEVICE device, - const VK_SHADER_CREATE_INFO* pCreateInfo, - VK_SHADER* pShader); - -// Pipeline functions - -VK_RESULT VKAPI vkCreateGraphicsPipeline( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkCreateComputePipeline( - VK_DEVICE device, - const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkStorePipeline( - VK_PIPELINE pipeline, - size_t* pDataSize, - void* pData); - -VK_RESULT VKAPI vkLoadPipeline( - VK_DEVICE device, - size_t dataSize, - const void* pData, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkLoadPipelineDerivative( - VK_DEVICE device, - size_t dataSize, - const void* pData, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); - -// Sampler functions - -VK_RESULT VKAPI vkCreateSampler( - VK_DEVICE device, - const VK_SAMPLER_CREATE_INFO* pCreateInfo, - VK_SAMPLER* pSampler); - -// Descriptor set functions - -VK_RESULT VKAPI vkCreateDescriptorSetLayout( - VK_DEVICE device, - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); - -VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain( - VK_DEVICE device, - uint32_t setLayoutArrayCount, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); - -VK_RESULT VKAPI vkBeginDescriptorPoolUpdate( - VK_DEVICE device, - VK_DESCRIPTOR_UPDATE_MODE updateMode); - -VK_RESULT VKAPI vkEndDescriptorPoolUpdate( - VK_DEVICE device, - VK_CMD_BUFFER cmd); - -VK_RESULT VKAPI vkCreateDescriptorPool( - VK_DEVICE device, - VK_DESCRIPTOR_POOL_USAGE poolUsage, - uint32_t maxSets, - const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_POOL* pDescriptorPool); - -VK_RESULT VKAPI vkResetDescriptorPool( - VK_DESCRIPTOR_POOL descriptorPool); - -VK_RESULT VKAPI vkAllocDescriptorSets( - 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); - -void VKAPI vkClearDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, - uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets); - -void VKAPI vkUpdateDescriptors( - VK_DESCRIPTOR_SET descriptorSet, - uint32_t updateCount, - const void** ppUpdateArray); - -// State object functions - -VK_RESULT VKAPI vkCreateDynamicViewportState( - VK_DEVICE device, - const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_VP_STATE_OBJECT* pState); - -VK_RESULT VKAPI vkCreateDynamicRasterState( - VK_DEVICE device, - const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_RS_STATE_OBJECT* pState); - -VK_RESULT VKAPI vkCreateDynamicColorBlendState( - VK_DEVICE device, - const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_CB_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 - -VK_RESULT VKAPI vkCreateCommandBuffer( - VK_DEVICE device, - const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, - VK_CMD_BUFFER* pCmdBuffer); - -VK_RESULT VKAPI vkBeginCommandBuffer( - VK_CMD_BUFFER cmdBuffer, - const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); - -VK_RESULT VKAPI vkEndCommandBuffer( - VK_CMD_BUFFER cmdBuffer); - -VK_RESULT VKAPI vkResetCommandBuffer( - VK_CMD_BUFFER cmdBuffer); - -// Command buffer building functions - -void VKAPI vkCmdBindPipeline( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_PIPELINE pipeline); - -void VKAPI vkCmdBindDynamicStateObject( - VK_CMD_BUFFER cmdBuffer, - VK_STATE_BIND_POINT stateBindPoint, - VK_DYNAMIC_STATE_OBJECT dynamicState); - -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 VK_DESCRIPTOR_SET* pDescriptorSets, - const uint32_t* pUserData); - -void VKAPI vkCmdBindIndexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - VK_INDEX_TYPE indexType); - -void VKAPI vkCmdBindVertexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - uint32_t binding); - -void VKAPI vkCmdDraw( - VK_CMD_BUFFER cmdBuffer, - uint32_t firstVertex, - uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndexed( - VK_CMD_BUFFER cmdBuffer, - uint32_t firstIndex, - uint32_t indexCount, - int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDrawIndexedIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDispatch( - VK_CMD_BUFFER cmdBuffer, - uint32_t x, - uint32_t y, - uint32_t z); - -void VKAPI vkCmdDispatchIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset); - -void VKAPI vkCmdCopyBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_BUFFER destBuffer, - uint32_t regionCount, - 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 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 VK_IMAGE_BLIT* pRegions); - -void VKAPI vkCmdCopyBufferToImage( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions); - -void VKAPI vkCmdCopyImageToBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, - uint32_t regionCount, - 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 VKAPI vkCmdFillBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset, - VK_GPU_SIZE fillSize, - uint32_t data); - -void VKAPI vkCmdClearColorImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, - uint32_t rangeCount, - const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); - -void VKAPI vkCmdClearDepthStencil( - 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); - -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 VK_IMAGE_RESOLVE* pRects); - -void VKAPI vkCmdSetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); - -void VKAPI vkCmdResetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); - -void VKAPI vkCmdWaitEvents( - VK_CMD_BUFFER cmdBuffer, - const VK_EVENT_WAIT_INFO* pWaitInfo); - -void VKAPI vkCmdPipelineBarrier( - VK_CMD_BUFFER cmdBuffer, - const VK_PIPELINE_BARRIER* pBarrier); - -void VKAPI vkCmdBeginQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, - uint32_t slot, - VK_FLAGS flags); - -void VKAPI vkCmdEndQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, - uint32_t slot); - -void VKAPI vkCmdResetQueryPool( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, - uint32_t startQuery, - uint32_t queryCount); - -void VKAPI vkCmdWriteTimestamp( - VK_CMD_BUFFER cmdBuffer, - VK_TIMESTAMP_TYPE timestampType, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); - -void VKAPI vkCmdInitAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - uint32_t startCounter, - uint32_t counterCount, - const uint32_t* pData); - -void VKAPI vkCmdLoadAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - uint32_t startCounter, - uint32_t counterCount, - VK_BUFFER srcBuffer, - VK_GPU_SIZE srcOffset); - -void VKAPI vkCmdSaveAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - uint32_t startCounter, - uint32_t counterCount, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); - -VK_RESULT VKAPI vkCreateFramebuffer( - VK_DEVICE device, - const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, - VK_FRAMEBUFFER* pFramebuffer); - -VK_RESULT VKAPI vkCreateRenderPass( - VK_DEVICE device, - const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, - VK_RENDER_PASS* pRenderPass); - -void VKAPI vkCmdBeginRenderPass( - VK_CMD_BUFFER cmdBuffer, - const VK_RENDER_PASS_BEGIN* pRenderPassBegin); - -void VKAPI vkCmdEndRenderPass( - VK_CMD_BUFFER cmdBuffer, - VK_RENDER_PASS renderPass); - -#endif // VK_PROTOTYPES - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // __VULKAN_H__ - -/****************************************************************************************** - - Open Issues + Missing Features - ------------------------------ - - Here are a few higher level issues that we'd like to fix given time. A feature missing - from this header (or the following list) isn't necessarily an indication that we want - to drop that feature. Only that we either haven't thought of it or haven't had time - to add it yet. - - 1) Transform Feedback (XFB) - - OpenGL supports transform feedback (XFB). That is not included in this header, but - we feel there is likely value in including it. - - 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 _VK_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 - } 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: - - vkCmdBindTransformFeedbackMemoryView( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS - uint32_t index, - const VK_MEMORY_VIEW_ATTACH_INFO* pMemView); - - 2) "Bindless" + support for non-bindless hardware. - - 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 - a resource descriptor set, and can modify the set asynchronously to GPU work. - Therefore, we can still have "unlimited textures". An application hoping to use - bindless can use an index into a large table of textures and achieve the same effect. - - For non-bindless hardware, with fixed (but potentially large) register files for - resource bindings, the table approach should still work if a limited size can be - reported somehow. - - 3) Clean up some remaining Mantle'isms. - - Queue types: It's a bit hand wavey. In Mantle, we have a "universal" queue type that - supports compute and graphics and a "compute" queue that only supports compute. Devices - must support at least one universal queue and DMA queues are an extension. I would like - to do the following (and have attempted to do that here, but am only half done): - - a) Separate out the queue capabilities (compute, DMA, graphics) and allow support - for any number of queues with any combination of capabilities each. - - b) Allow compute-only or even DMA-only (like video capture or SDI) devices to - be supported. - - c) Allow new queue types to be supported by extensions without having to allocate - bits in the bitfield until they're promoted to core. - - Terminology: There are still some references to "targets" (render targets) and other - terminology that has been changed from Mantle. Need to do a clean-up pass. - - 4) The window system interface is an extension in Mantle. We have not tried to fold - any of it into core here. There is no mention of SwapBuffers, presentation, default - framebuffers or anything like that. In the extension, presentation is queued up into - the graphics queue just like any other command. - -*******************************************************************************************/ diff --git a/include/vulkan.h b/include/vulkan.h index b78a56cd..8f13f9ab 100644 --- a/include/vulkan.h +++ b/include/vulkan.h @@ -32,8 +32,8 @@ #include "vkPlatform.h" -// VK API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 67, 0) +// Vulkan API version supported by this file +#define VK_API_VERSION VK_MAKE_VERSION(0, 69, 0) #ifdef __cplusplus extern "C" @@ -42,7 +42,7 @@ extern "C" /* *************************************************************************************************** -* Core VK API +* Core Vulkan API *************************************************************************************************** */ @@ -110,613 +110,613 @@ VK_DEFINE_SUBCLASS_HANDLE(VK_RENDER_PASS, VK_OBJECT) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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, - - 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_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, + + 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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; @@ -726,341 +726,343 @@ typedef enum _VK_VALIDATION_LEVEL typedef enum _VK_RESULT { - // Return codes for successful operation execution (>= 0) - VK_SUCCESS = 0x0000000, - VK_UNSUPPORTED = 0x0000001, - VK_NOT_READY = 0x0000002, - VK_TIMEOUT = 0x0000003, - VK_EVENT_SET = 0x0000004, - VK_EVENT_RESET = 0x0000005, + // Return codes for successful operation execution (> = 0) + 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) - 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_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; // ------------------------------------------------------------------------------------------------ -// VK format definitions +// Vulkan 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_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_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_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 _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_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_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_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_SHADER_STAGE_FLAGS_ALL = 0x7FFFFFFF, VK_MAX_ENUM(_VK_SHADER_STAGE_FLAGS) } VK_SHADER_STAGE_FLAGS; // Structure type enumerant 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_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; @@ -1070,81 +1072,81 @@ typedef enum _VK_STRUCTURE_TYPE // Device creation flags typedef enum _VK_DEVICE_CREATE_FLAGS { - VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, - VK_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002, + 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 _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_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_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_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_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 _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_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 _VK_BUFFER_CREATE_FLAGS { - VK_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_BIT = 0x00000002, + 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 _VK_BUFFER_VIEW_TYPE { - 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) + 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) - 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_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; @@ -1152,713 +1154,713 @@ typedef enum _VK_BUFFER_VIEW_TYPE // Images memory allocations can be used for resources of a given 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_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 _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_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 _VK_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_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 _VK_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_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 _VK_PIPELINE_CREATE_FLAGS { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + 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 _VK_FENCE_CREATE_FLAGS { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, VK_MAX_ENUM(_VK_FENCE_CREATE_FLAGS) } VK_FENCE_CREATE_FLAGS; // Semaphore creation flags typedef enum _VK_SEMAPHORE_CREATE_FLAGS { - VK_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001, + VK_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001, VK_MAX_ENUM(_VK_SEMAPHORE_CREATE_FLAGS) } VK_SEMAPHORE_CREATE_FLAGS; // Format capability 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_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 _VK_QUERY_CONTROL_FLAGS { - VK_QUERY_IMPRECISE_DATA_BIT = 0x00000001, + VK_QUERY_IMPRECISE_DATA_BIT = 0x00000001, VK_MAX_ENUM(_VK_QUERY_CONTROL_FLAGS) } VK_QUERY_CONTROL_FLAGS; // 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_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 _VK_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_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; // ------------------------------------------------------------------------------------------------ -// VK structures +// Vulkan structures typedef struct _VK_OFFSET2D { - int32_t x; - int32_t y; + int32_t x; + int32_t y; } VK_OFFSET2D; typedef struct _VK_OFFSET3D { - int32_t x; - int32_t y; - int32_t z; + int32_t x; + int32_t y; + int32_t z; } VK_OFFSET3D; typedef struct _VK_EXTENT2D { - int32_t width; - int32_t height; + int32_t width; + int32_t height; } VK_EXTENT2D; typedef struct _VK_EXTENT3D { - int32_t width; - int32_t height; - int32_t depth; + int32_t width; + int32_t height; + int32_t depth; } VK_EXTENT3D; typedef struct _VK_VIEWPORT { - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; + float originX; + float originY; + float width; + float height; + float minDepth; + float maxDepth; } VK_VIEWPORT; typedef struct _VK_RECT { - VK_OFFSET2D offset; - VK_EXTENT2D extent; + VK_OFFSET2D offset; + VK_EXTENT2D extent; } VK_RECT; typedef struct _VK_CHANNEL_MAPPING { - VK_CHANNEL_SWIZZLE r; - VK_CHANNEL_SWIZZLE g; - VK_CHANNEL_SWIZZLE b; - VK_CHANNEL_SWIZZLE a; + VK_CHANNEL_SWIZZLE r; + VK_CHANNEL_SWIZZLE g; + VK_CHANNEL_SWIZZLE b; + VK_CHANNEL_SWIZZLE a; } VK_CHANNEL_MAPPING; typedef struct _VK_PHYSICAL_GPU_PROPERTIES { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorId; - uint32_t deviceId; - 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; - bool32_t multiColorAttachmentClears; - uint32_t maxDescriptorSets; // at least 2? - uint32_t maxViewports; // at least 16? - uint32_t maxColorAttachments; // at least 8? + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorId; + uint32_t deviceId; + 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; + bool32_t multiColorAttachmentClears; + uint32_t maxDescriptorSets; // at least 2? + uint32_t maxViewports; // at least 16? + uint32_t maxColorAttachments; // at least 8? } VK_PHYSICAL_GPU_PROPERTIES; typedef struct _VK_PHYSICAL_GPU_PERFORMANCE { - float maxGpuClock; - float aluPerClock; - float texPerClock; - float primsPerClock; - float pixelsPerClock; + float maxGpuClock; + float aluPerClock; + float texPerClock; + float primsPerClock; + float pixelsPerClock; } VK_PHYSICAL_GPU_PERFORMANCE; typedef struct _VK_GPU_COMPATIBILITY_INFO { - VK_FLAGS compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS + VK_FLAGS compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS } VK_GPU_COMPATIBILITY_INFO; typedef struct _VK_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; + 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; } VK_APPLICATION_INFO; typedef void* (VKAPI *VK_ALLOC_FUNCTION)( - void* pUserData, - size_t size, - size_t alignment, - VK_SYSTEM_ALLOC_TYPE allocType); + void* pUserData, + size_t size, + size_t alignment, + VK_SYSTEM_ALLOC_TYPE allocType); typedef void (VKAPI *VK_FREE_FUNCTION)( - void* pUserData, - void* pMem); + void* pUserData, + void* pMem); typedef struct _VK_ALLOC_CALLBACKS { - void* pUserData; - VK_ALLOC_FUNCTION pfnAlloc; - VK_FREE_FUNCTION pfnFree; + void* pUserData; + VK_ALLOC_FUNCTION pfnAlloc; + VK_FREE_FUNCTION pfnFree; } VK_ALLOC_CALLBACKS; typedef struct _VK_DEVICE_QUEUE_CREATE_INFO { - uint32_t queueNodeIndex; - uint32_t queueCount; + uint32_t queueNodeIndex; + uint32_t queueCount; } VK_DEVICE_QUEUE_CREATE_INFO; typedef struct _VK_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 VK_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; - VK_VALIDATION_LEVEL maxValidationLevel; - VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS + VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO + const void* pNext; // Pointer to next structure + uint32_t queueRecordCount; + const VK_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; + VK_VALIDATION_LEVEL maxValidationLevel; + VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS } VK_DEVICE_CREATE_INFO; typedef struct _VK_INSTANCE_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO - const void* pNext; // Pointer to next structure - const VK_APPLICATION_INFO* pAppInfo; - const VK_ALLOC_CALLBACKS* pAllocCb; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled + VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO + const void* pNext; // Pointer to next structure + const VK_APPLICATION_INFO* pAppInfo; + const VK_ALLOC_CALLBACKS* pAllocCb; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled } VK_INSTANCE_CREATE_INFO; // can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext typedef struct _VK_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 vkEnumerateLayers()) + 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 vkEnumerateLayers()) } VK_LAYER_CREATE_INFO; typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES { - 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 + 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 } VK_PHYSICAL_GPU_QUEUE_PROPERTIES; typedef struct _VK_PHYSICAL_GPU_MEMORY_PROPERTIES { - bool32_t supportsMigration; - bool32_t supportsPinning; + bool32_t supportsMigration; + bool32_t supportsPinning; } VK_PHYSICAL_GPU_MEMORY_PROPERTIES; typedef struct _VK_MEMORY_ALLOC_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO - const void* pNext; // Pointer to next structure - VK_GPU_SIZE allocationSize; // Size of memory allocation - VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS - VK_MEMORY_TYPE memType; - VK_MEMORY_PRIORITY memPriority; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO + const void* pNext; // Pointer to next structure + 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 VK_MEMORY_ALLOC_INFO chain // for memory regions allocated for buffer usage. typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO + const void* pNext; // Pointer to next structure + VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS } VK_MEMORY_ALLOC_BUFFER_INFO; // This structure is included in the VK_MEMORY_ALLOC_INFO chain // for memory regions allocated for image usage. typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; - uint32_t samples; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO + const void* pNext; // Pointer to next structure + VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS + VK_IMAGE_FORMAT_CLASS formatClass; + uint32_t samples; } VK_MEMORY_ALLOC_IMAGE_INFO; typedef struct _VK_MEMORY_OPEN_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_GPU_MEMORY sharedMem; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO + const void* pNext; // Pointer to next structure + VK_GPU_MEMORY sharedMem; } VK_MEMORY_OPEN_INFO; typedef struct _VK_PEER_MEMORY_OPEN_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_GPU_MEMORY originalMem; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO + const void* pNext; // Pointer to next structure + VK_GPU_MEMORY originalMem; } VK_PEER_MEMORY_OPEN_INFO; typedef struct _VK_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_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 _VK_BUFFER_MEMORY_REQUIREMENTS { - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS + VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS } VK_BUFFER_MEMORY_REQUIREMENTS; typedef struct _VK_IMAGE_MEMORY_REQUIREMENTS { - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; - uint32_t samples; + VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS + VK_IMAGE_FORMAT_CLASS formatClass; + uint32_t samples; } VK_IMAGE_MEMORY_REQUIREMENTS; typedef struct _VK_FORMAT_PROPERTIES { - VK_FLAGS linearTilingFeatures; // VK_FORMAT_FEATURE_FLAGS - VK_FLAGS optimalTilingFeatures; // VK_FORMAT_FEATURE_FLAGS + VK_FLAGS linearTilingFeatures; // VK_FORMAT_FEATURE_FLAGS + VK_FLAGS optimalTilingFeatures; // VK_FORMAT_FEATURE_FLAGS } VK_FORMAT_PROPERTIES; typedef struct _VK_BUFFER_VIEW_ATTACH_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VK_BUFFER_VIEW view; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO + const void* pNext; // Pointer to next structure + VK_BUFFER_VIEW view; } VK_BUFFER_VIEW_ATTACH_INFO; typedef struct _VK_IMAGE_VIEW_ATTACH_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VK_IMAGE_VIEW view; - VK_IMAGE_LAYOUT layout; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO + const void* pNext; // Pointer to next structure + VK_IMAGE_VIEW view; + VK_IMAGE_LAYOUT layout; } VK_IMAGE_VIEW_ATTACH_INFO; typedef struct _VK_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 VK_SAMPLER* pSamplers; + 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 VK_SAMPLER* pSamplers; } VK_UPDATE_SAMPLERS; typedef struct _VK_SAMPLER_IMAGE_VIEW_INFO { - VK_SAMPLER sampler; - const VK_IMAGE_VIEW_ATTACH_INFO* pImageView; + VK_SAMPLER pSampler; + const VK_IMAGE_VIEW_ATTACH_INFO* pImageView; } VK_SAMPLER_IMAGE_VIEW_INFO; typedef struct _VK_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 VK_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews; + 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 VK_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews; } VK_UPDATE_SAMPLER_TEXTURES; typedef struct _VK_UPDATE_IMAGES { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES - const void* pNext; // Pointer to next structure - 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 VK_IMAGE_VIEW_ATTACH_INFO* pImageViews; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES + const void* pNext; // Pointer to next structure + 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 VK_IMAGE_VIEW_ATTACH_INFO* pImageViews; } VK_UPDATE_IMAGES; typedef struct _VK_UPDATE_BUFFERS { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS - const void* pNext; // Pointer to next structure - 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 VK_BUFFER_VIEW_ATTACH_INFO* pBufferViews; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS + const void* pNext; // Pointer to next structure + 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 VK_BUFFER_VIEW_ATTACH_INFO* pBufferViews; } VK_UPDATE_BUFFERS; typedef struct _VK_UPDATE_AS_COPY { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY - const void* pNext; // Pointer to next structure - VK_DESCRIPTOR_TYPE descriptorType; - VK_DESCRIPTOR_SET descriptorSet; - uint32_t binding; - uint32_t arrayElement; - uint32_t count; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY + const void* pNext; // Pointer to next structure + VK_DESCRIPTOR_TYPE descriptorType; + VK_DESCRIPTOR_SET descriptorSet; + uint32_t binding; + uint32_t arrayElement; + uint32_t count; } VK_UPDATE_AS_COPY; typedef struct _VK_BUFFER_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO - const void* pNext; // Pointer to next structure. - VK_GPU_SIZE size; // Specified in bytes - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS - VK_FLAGS flags; // VK_BUFFER_CREATE_FLAGS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO + const void* pNext; // Pointer to next structure. + 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 _VK_BUFFER_VIEW_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure. - 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_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO + const void* pNext; // Pointer to next structure. + 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 _VK_IMAGE_SUBRESOURCE { - VK_IMAGE_ASPECT aspect; - uint32_t mipLevel; - uint32_t arraySlice; + VK_IMAGE_ASPECT aspect; + uint32_t mipLevel; + uint32_t arraySlice; } VK_IMAGE_SUBRESOURCE; typedef struct _VK_IMAGE_SUBRESOURCE_RANGE { - VK_IMAGE_ASPECT aspect; - uint32_t baseMipLevel; - uint32_t mipLevels; - uint32_t baseArraySlice; - uint32_t arraySize; + VK_IMAGE_ASPECT aspect; + uint32_t baseMipLevel; + uint32_t mipLevels; + uint32_t baseArraySlice; + uint32_t arraySize; } VK_IMAGE_SUBRESOURCE_RANGE; typedef struct _VK_EVENT_WAIT_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_WAIT_INFO - const void* pNext; // Pointer to next structure. + 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 VK_EVENT* pEvents; // Array of event objects to wait on + uint32_t eventCount; // Number of events to wait on + const VK_EVENT* pEvents; // Array of event objects to wait on - VK_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 VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) + uint32_t memBarrierCount; // Number of memory barriers + 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 _VK_PIPELINE_BARRIER { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_BARRIER - const void* pNext; // Pointer to next structure. + 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 VK_PIPE_EVENT* pEvents; // Array of pipeline events to wait on + uint32_t eventCount; // Number of events to wait on + const VK_PIPE_EVENT* pEvents; // Array of pipeline events to wait on - VK_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 VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) + uint32_t memBarrierCount; // Number of memory barriers + 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 _VK_MEMORY_BARRIER { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER + const void* pNext; // Pointer to next structure. - 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_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 _VK_BUFFER_MEMORY_BARRIER { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER + const void* pNext; // Pointer to next structure. - 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_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_BUFFER buffer; // Buffer to sync + VK_BUFFER buffer; // Buffer to sync - VK_GPU_SIZE offset; // Offset within the buffer to sync - VK_GPU_SIZE size; // Amount of bytes to sync + 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 _VK_IMAGE_MEMORY_BARRIER { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER + const void* pNext; // Pointer to next structure. - 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_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_IMAGE_LAYOUT oldLayout; // Current layout of the image - VK_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 - VK_IMAGE image; // Image to sync + VK_IMAGE image; // Image to sync - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync + VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync } VK_IMAGE_MEMORY_BARRIER; typedef struct _VK_IMAGE_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO - const void* pNext; // Pointer to next structure. - VK_IMAGE_TYPE imageType; - VK_FORMAT format; - VK_EXTENT3D extent; - uint32_t mipLevels; - uint32_t arraySize; - uint32_t samples; - VK_IMAGE_TILING tiling; - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO + const void* pNext; // Pointer to next structure. + VK_IMAGE_TYPE imageType; + VK_FORMAT format; + VK_EXTENT3D extent; + uint32_t mipLevels; + uint32_t arraySize; + uint32_t samples; + VK_IMAGE_TILING tiling; + VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS + VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS } VK_IMAGE_CREATE_INFO; typedef struct _VK_PEER_IMAGE_OPEN_INFO { - VK_IMAGE originalImage; + VK_IMAGE originalImage; } VK_PEER_IMAGE_OPEN_INFO; typedef struct _VK_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_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 _VK_IMAGE_VIEW_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_IMAGE image; - VK_IMAGE_VIEW_TYPE viewType; - VK_FORMAT format; - VK_CHANNEL_MAPPING channels; - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; - float minLod; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_IMAGE image; + VK_IMAGE_VIEW_TYPE viewType; + VK_FORMAT format; + VK_CHANNEL_MAPPING channels; + VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; + float minLod; } VK_IMAGE_VIEW_CREATE_INFO; typedef struct _VK_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 - VK_IMAGE image; - VK_FORMAT format; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VK_IMAGE msaaResolveImage; - VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_IMAGE image; + VK_FORMAT format; + uint32_t mipLevel; + uint32_t baseArraySlice; + uint32_t arraySize; + VK_IMAGE msaaResolveImage; + VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; } VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO; typedef struct _VK_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 - VK_IMAGE image; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VK_IMAGE msaaResolveImage; - VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; - VK_FLAGS flags; // VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_IMAGE image; + uint32_t mipLevel; + uint32_t baseArraySlice; + uint32_t arraySize; + 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 _VK_COLOR_ATTACHMENT_BIND_INFO { - VK_COLOR_ATTACHMENT_VIEW view; - VK_IMAGE_LAYOUT layout; + VK_COLOR_ATTACHMENT_VIEW view; + VK_IMAGE_LAYOUT layout; } VK_COLOR_ATTACHMENT_BIND_INFO; typedef struct _VK_DEPTH_STENCIL_BIND_INFO { - VK_DEPTH_STENCIL_VIEW view; - VK_IMAGE_LAYOUT layout; + VK_DEPTH_STENCIL_VIEW view; + VK_IMAGE_LAYOUT layout; } VK_DEPTH_STENCIL_BIND_INFO; typedef struct _VK_BUFFER_COPY { - VK_GPU_SIZE srcOffset; // Specified in bytes - VK_GPU_SIZE destOffset; // Specified in bytes - VK_GPU_SIZE copySize; // Specified in bytes + 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 _VK_IMAGE_MEMORY_BIND_INFO { - VK_IMAGE_SUBRESOURCE subresource; - VK_OFFSET3D offset; - VK_EXTENT3D extent; + VK_IMAGE_SUBRESOURCE subresource; + VK_OFFSET3D offset; + VK_EXTENT3D extent; } VK_IMAGE_MEMORY_BIND_INFO; typedef struct _VK_IMAGE_COPY { - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET3D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET3D destOffset; - VK_EXTENT3D extent; + VK_IMAGE_SUBRESOURCE srcSubresource; + VK_OFFSET3D srcOffset; + VK_IMAGE_SUBRESOURCE destSubresource; + VK_OFFSET3D destOffset; + VK_EXTENT3D extent; } VK_IMAGE_COPY; typedef struct _VK_IMAGE_BLIT { - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET3D srcOffset; - VK_EXTENT3D srcExtent; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET3D destOffset; - VK_EXTENT3D destExtent; + 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 _VK_BUFFER_IMAGE_COPY { - VK_GPU_SIZE bufferOffset; // Specified in bytes - VK_IMAGE_SUBRESOURCE imageSubresource; - VK_OFFSET3D imageOffset; - VK_EXTENT3D imageExtent; + VK_GPU_SIZE bufferOffset; // Specified in bytes + VK_IMAGE_SUBRESOURCE imageSubresource; + VK_OFFSET3D imageOffset; + VK_EXTENT3D imageExtent; } VK_BUFFER_IMAGE_COPY; typedef struct _VK_IMAGE_RESOLVE { - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET2D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET2D destOffset; - VK_EXTENT2D extent; + VK_IMAGE_SUBRESOURCE srcSubresource; + VK_OFFSET2D srcOffset; + VK_IMAGE_SUBRESOURCE destSubresource; + VK_OFFSET2D destOffset; + VK_EXTENT2D extent; } VK_IMAGE_RESOLVE; typedef struct _VK_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; - VK_FLAGS flags; // Reserved + 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; + VK_FLAGS flags; // Reserved } VK_SHADER_CREATE_INFO; typedef struct _VK_DESCRIPTOR_SET_LAYOUT_BINDING { - VK_DESCRIPTOR_TYPE descriptorType; - uint32_t count; - VK_FLAGS stageFlags; // VK_SHADER_STAGE_FLAGS - const VK_SAMPLER* pImmutableSamplers; + VK_DESCRIPTOR_TYPE descriptorType; + uint32_t count; + VK_FLAGS stageFlags; // VK_SHADER_STAGE_FLAGS + const VK_SAMPLER* pImmutableSamplers; } VK_DESCRIPTOR_SET_LAYOUT_BINDING; typedef struct _VK_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 VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings + 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 VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings } VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; typedef struct _VK_DESCRIPTOR_TYPE_COUNT { - VK_DESCRIPTOR_TYPE type; - uint32_t count; + VK_DESCRIPTOR_TYPE type; + uint32_t count; } VK_DESCRIPTOR_TYPE_COUNT; typedef struct _VK_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 VK_DESCRIPTOR_TYPE_COUNT* pTypeCount; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO + const void* pNext; // Pointer to next structure + uint32_t count; + const VK_DESCRIPTOR_TYPE_COUNT* pTypeCount; } VK_DESCRIPTOR_POOL_CREATE_INFO; typedef struct _VK_LINK_CONST_BUFFER @@ -1870,396 +1872,396 @@ typedef struct _VK_LINK_CONST_BUFFER 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 + uint32_t constantId; // The SpecConstant ID specified in the BIL + uint32_t offset; // Offset of the value in the data block } VK_SPECIALIZATION_MAP_ENTRY; typedef struct _VK_SPECIALIZATION_INFO { - uint32_t mapEntryCount; - const VK_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries - const void* pData; + uint32_t mapEntryCount; + const VK_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries + const void* pData; } VK_SPECIALIZATION_INFO; typedef struct _VK_PIPELINE_SHADER { - VK_PIPELINE_SHADER_STAGE stage; - VK_SHADER shader; - uint32_t linkConstBufferCount; - const VK_LINK_CONST_BUFFER* pLinkConstBufferInfo; - const VK_SPECIALIZATION_INFO* pSpecializationInfo; + VK_PIPELINE_SHADER_STAGE stage; + VK_SHADER shader; + uint32_t linkConstBufferCount; + const VK_LINK_CONST_BUFFER* pLinkConstBufferInfo; + const VK_SPECIALIZATION_INFO* pSpecializationInfo; } VK_PIPELINE_SHADER; typedef struct _VK_COMPUTE_PIPELINE_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - 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; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_PIPELINE_SHADER cs; + VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS + VK_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; + uint32_t localSizeX; + uint32_t localSizeY; + uint32_t localSizeZ; } VK_COMPUTE_PIPELINE_CREATE_INFO; 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) + uint32_t binding; // Vertex buffer binding id + uint32_t strideInBytes; // Distance between vertices in bytes (0 = no advancement) - VK_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented + VK_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented } VK_VERTEX_INPUT_BINDING_DESCRIPTION; typedef struct _VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION { - uint32_t location; // location of the shader vertex attrib - uint32_t binding; // Vertex buffer binding id + uint32_t location; // location of the shader vertex attrib + uint32_t binding; // Vertex buffer binding id - VK_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 + uint32_t offsetInBytes; // Offset of first element in bytes from base of vertex } VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION; typedef struct _VK_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 + 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 VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; + uint32_t bindingCount; // number of bindings + const VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; - uint32_t attributeCount; // number of attributes + uint32_t attributeCount; // number of attributes const VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; } VK_PIPELINE_VERTEX_INPUT_CREATE_INFO; typedef struct _VK_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 - VK_PRIMITIVE_TOPOLOGY topology; - bool32_t disableVertexReuse; // optional - bool32_t primitiveRestartEnable; - uint32_t primitiveRestartIndex; // optional (GL45) + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_PRIMITIVE_TOPOLOGY topology; + bool32_t disableVertexReuse; // optional + bool32_t primitiveRestartEnable; + uint32_t primitiveRestartIndex; // optional (GL45) } VK_PIPELINE_IA_STATE_CREATE_INFO; typedef struct _VK_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; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO + const void* pNext; // Pointer to next structure + uint32_t patchControlPoints; } VK_PIPELINE_TESS_STATE_CREATE_INFO; typedef struct _VK_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; - VK_COORDINATE_ORIGIN clipOrigin; // optional (GL45) - VK_DEPTH_MODE depthMode; // optional (GL45) + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO + const void* pNext; // Pointer to next structure + uint32_t numViewports; + VK_COORDINATE_ORIGIN clipOrigin; // optional (GL45) + VK_DEPTH_MODE depthMode; // optional (GL45) } VK_PIPELINE_VP_STATE_CREATE_INFO; typedef struct _VK_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) - 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_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) + 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 _VK_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) - VK_SAMPLE_MASK sampleMask; + 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) + VK_SAMPLE_MASK sampleMask; } VK_PIPELINE_MS_STATE_CREATE_INFO; typedef struct _VK_PIPELINE_CB_ATTACHMENT_STATE { - bool32_t blendEnable; - 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; + bool32_t blendEnable; + 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; } VK_PIPELINE_CB_ATTACHMENT_STATE; typedef struct _VK_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; - VK_LOGIC_OP logicOp; - uint32_t attachmentCount; // # of pAttachments - const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; + 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; + VK_LOGIC_OP logicOp; + uint32_t attachmentCount; // # of pAttachments + const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; } VK_PIPELINE_CB_STATE_CREATE_INFO; typedef struct _VK_STENCIL_OP_STATE { - VK_STENCIL_OP stencilFailOp; - VK_STENCIL_OP stencilPassOp; - VK_STENCIL_OP stencilDepthFailOp; - VK_COMPARE_FUNC stencilFunc; + VK_STENCIL_OP stencilFailOp; + VK_STENCIL_OP stencilPassOp; + VK_STENCIL_OP stencilDepthFailOp; + VK_COMPARE_FUNC stencilFunc; } VK_STENCIL_OP_STATE; typedef struct _VK_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 - VK_FORMAT format; - bool32_t depthTestEnable; - bool32_t depthWriteEnable; - VK_COMPARE_FUNC depthFunc; - bool32_t depthBoundsEnable; // optional (depth_bounds_test) - bool32_t stencilTestEnable; - VK_STENCIL_OP_STATE front; - VK_STENCIL_OP_STATE back; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_FORMAT format; + bool32_t depthTestEnable; + bool32_t depthWriteEnable; + VK_COMPARE_FUNC depthFunc; + bool32_t depthBoundsEnable; // optional (depth_bounds_test) + bool32_t stencilTestEnable; + VK_STENCIL_OP_STATE front; + VK_STENCIL_OP_STATE back; } VK_PIPELINE_DS_STATE_CREATE_INFO; typedef struct _VK_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 - VK_PIPELINE_SHADER shader; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_PIPELINE_SHADER shader; } VK_PIPELINE_SHADER_STAGE_CREATE_INFO; typedef struct _VK_GRAPHICS_PIPELINE_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS - VK_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS + VK_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain; } VK_GRAPHICS_PIPELINE_CREATE_INFO; typedef struct _VK_SAMPLER_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO - const void* pNext; // Pointer to next structure - 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; - VK_COMPARE_FUNC compareFunc; - float minLod; - float maxLod; - VK_BORDER_COLOR_TYPE borderColorType; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO + const void* pNext; // Pointer to next structure + 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; + VK_COMPARE_FUNC compareFunc; + float minLod; + float maxLod; + VK_BORDER_COLOR_TYPE borderColorType; } VK_SAMPLER_CREATE_INFO; typedef struct _VK_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 VK_VIEWPORT* pViewports; - const VK_RECT* pScissors; + 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 VK_VIEWPORT* pViewports; + const VK_RECT* pScissors; } VK_DYNAMIC_VP_STATE_CREATE_INFO; typedef struct _VK_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; - float slopeScaledDepthBias; - float pointSize; // optional (GL45) - Size of points - float pointFadeThreshold; // optional (GL45) - Size of point fade threshold - float lineWidth; // optional (GL45) - Width of lines + 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; + float slopeScaledDepthBias; + float pointSize; // optional (GL45) - Size of points + float pointFadeThreshold; // optional (GL45) - Size of point fade threshold + float lineWidth; // optional (GL45) - Width of lines } VK_DYNAMIC_RS_STATE_CREATE_INFO; typedef struct _VK_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]; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO + const void* pNext; // Pointer to next structure + float blendConst[4]; } VK_DYNAMIC_CB_STATE_CREATE_INFO; typedef struct _VK_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) - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; + 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) + uint32_t stencilReadMask; + uint32_t stencilWriteMask; + uint32_t stencilFrontRef; + uint32_t stencilBackRef; } VK_DYNAMIC_DS_STATE_CREATE_INFO; typedef struct _VK_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; - VK_FLAGS flags; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO + const void* pNext; // Pointer to next structure + uint32_t queueNodeIndex; + VK_FLAGS flags; } VK_CMD_BUFFER_CREATE_INFO; typedef struct _VK_CMD_BUFFER_BEGIN_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO - const void* pNext; // Pointer to next structure + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO + const void* pNext; // Pointer to next structure - VK_FLAGS flags; // VK_CMD_BUFFER_BUILD_FLAGS + VK_FLAGS flags; // VK_CMD_BUFFER_BUILD_FLAGS } VK_CMD_BUFFER_BEGIN_INFO; typedef struct _VK_RENDER_PASS_BEGIN { - VK_RENDER_PASS renderPass; - VK_FRAMEBUFFER framebuffer; + VK_RENDER_PASS renderPass; + VK_FRAMEBUFFER framebuffer; } VK_RENDER_PASS_BEGIN; typedef struct _VK_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 + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO + const void* pNext; // Pointer to next structure - VK_RENDER_PASS_BEGIN renderPassContinue; // Only needed when a render pass is split across two command buffers + 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 _VK_CLEAR_COLOR_VALUE { - float floatColor[4]; - uint32_t rawColor[4]; + float floatColor[4]; + uint32_t rawColor[4]; } VK_CLEAR_COLOR_VALUE; typedef struct _VK_CLEAR_COLOR { - VK_CLEAR_COLOR_VALUE color; - bool32_t useRawValue; + VK_CLEAR_COLOR_VALUE color; + bool32_t useRawValue; } VK_CLEAR_COLOR; typedef struct _VK_RENDER_PASS_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO - const void* pNext; // Pointer to next structure - - VK_RECT renderArea; - uint32_t colorAttachmentCount; - VK_EXTENT2D extent; - uint32_t sampleCount; - uint32_t layers; - 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; - VK_ATTACHMENT_STORE_OP depthStoreOp; - VK_ATTACHMENT_LOAD_OP stencilLoadOp; - uint32_t stencilLoadClearValue; - VK_ATTACHMENT_STORE_OP stencilStoreOp; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO + const void* pNext; // Pointer to next structure + + VK_RECT renderArea; + uint32_t colorAttachmentCount; + VK_EXTENT2D extent; + uint32_t sampleCount; + uint32_t layers; + 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; + VK_ATTACHMENT_STORE_OP depthStoreOp; + VK_ATTACHMENT_LOAD_OP stencilLoadOp; + uint32_t stencilLoadClearValue; + VK_ATTACHMENT_STORE_OP stencilStoreOp; } VK_RENDER_PASS_CREATE_INFO; typedef struct _VK_EVENT_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS flags; // Reserved + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_FLAGS flags; // Reserved } VK_EVENT_CREATE_INFO; typedef struct _VK_FENCE_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FENCE_CREATE_FLAGS flags; // VK_FENCE_CREATE_FLAGS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_FENCE_CREATE_FLAGS flags; // VK_FENCE_CREATE_FLAGS } VK_FENCE_CREATE_INFO; typedef struct _VK_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; - VK_FLAGS flags; // VK_SEMAPHORE_CREATE_FLAGS + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO + const void* pNext; // Pointer to next structure + uint32_t initialCount; + VK_FLAGS flags; // VK_SEMAPHORE_CREATE_FLAGS } VK_SEMAPHORE_CREATE_INFO; typedef struct _VK_SEMAPHORE_OPEN_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_SEMAPHORE sharedSemaphore; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO + const void* pNext; // Pointer to next structure + VK_SEMAPHORE sharedSemaphore; } VK_SEMAPHORE_OPEN_INFO; typedef struct _VK_PIPELINE_STATISTICS_DATA { - uint64_t fsInvocations; // Fragment shader invocations - uint64_t cPrimitives; // Clipper primitives - uint64_t cInvocations; // Clipper invocations - uint64_t vsInvocations; // Vertex shader invocations - uint64_t gsInvocations; // Geometry shader invocations - uint64_t gsPrimitives; // Geometry shader primitives - uint64_t iaPrimitives; // Input primitives - uint64_t iaVertices; // Input vertices - uint64_t tcsInvocations; // Tessellation control shader invocations - uint64_t tesInvocations; // Tessellation evaluation shader invocations - uint64_t csInvocations; // Compute shader invocations + uint64_t fsInvocations; // Fragment shader invocations + uint64_t cPrimitives; // Clipper primitives + uint64_t cInvocations; // Clipper invocations + uint64_t vsInvocations; // Vertex shader invocations + uint64_t gsInvocations; // Geometry shader invocations + uint64_t gsPrimitives; // Geometry shader primitives + uint64_t iaPrimitives; // Input primitives + uint64_t iaVertices; // Input vertices + uint64_t tcsInvocations; // Tessellation control shader invocations + uint64_t tesInvocations; // Tessellation evaluation shader invocations + uint64_t csInvocations; // Compute shader invocations } VK_PIPELINE_STATISTICS_DATA; typedef struct _VK_QUERY_POOL_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_QUERY_TYPE queryType; - uint32_t slots; + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO + const void* pNext; // Pointer to next structure + VK_QUERY_TYPE queryType; + uint32_t slots; } VK_QUERY_POOL_CREATE_INFO; typedef struct _VK_FRAMEBUFFER_CREATE_INFO { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO - const void* pNext; // Pointer to next structure + VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO + const void* pNext; // Pointer to next structure - uint32_t colorAttachmentCount; - const VK_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments; - const VK_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment; + uint32_t colorAttachmentCount; + 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; + uint32_t sampleCount; + uint32_t width; + uint32_t height; + uint32_t layers; } VK_FRAMEBUFFER_CREATE_INFO; typedef struct _VK_DRAW_INDIRECT_CMD { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; } VK_DRAW_INDIRECT_CMD; typedef struct _VK_DRAW_INDEXED_INDIRECT_CMD { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; } VK_DRAW_INDEXED_INDIRECT_CMD; typedef struct _VK_DISPATCH_INDIRECT_CMD { - uint32_t x; - uint32_t y; - uint32_t z; + uint32_t x; + uint32_t y; + uint32_t z; } VK_DISPATCH_INDIRECT_CMD; // ------------------------------------------------------------------------------------------------ @@ -2268,7 +2270,7 @@ typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VK_INSTANCE_CREATE_INFO* p 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 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); @@ -2331,8 +2333,8 @@ typedef VK_RESULT (VKAPI *vkEndDescriptorPoolUpdateType)(VK_DEVICE device, VK_CM 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 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** pUpdateArray); 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); @@ -2341,43 +2343,43 @@ typedef VK_RESULT (VKAPI *vkCreateCommandBufferType)(VK_DEVICE device, const VK_ 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 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); +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 @@ -2388,44 +2390,44 @@ VK_RESULT VKAPI vkCreateInstance( VK_INSTANCE* pInstance); VK_RESULT VKAPI vkDestroyInstance( - VK_INSTANCE instance); + VK_INSTANCE instance); VK_RESULT VKAPI vkEnumerateGpus( - VK_INSTANCE instance, + VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, - VK_PHYSICAL_GPU* pGpus); + VK_PHYSICAL_GPU* pGpus); VK_RESULT VKAPI vkGetGpuInfo( - VK_PHYSICAL_GPU gpu, - VK_PHYSICAL_GPU_INFO_TYPE infoType, + VK_PHYSICAL_GPU gpu, + VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData); void * VKAPI vkGetProcAddr( - VK_PHYSICAL_GPU gpu, + VK_PHYSICAL_GPU gpu, const char* pName); // Device functions VK_RESULT VKAPI vkCreateDevice( - VK_PHYSICAL_GPU gpu, - const VK_DEVICE_CREATE_INFO* pCreateInfo, - VK_DEVICE* pDevice); + VK_PHYSICAL_GPU gpu, + const VK_DEVICE_CREATE_INFO* pCreateInfo, + VK_DEVICE* pDevice); VK_RESULT VKAPI vkDestroyDevice( - VK_DEVICE device); + VK_DEVICE device); // Extension discovery functions VK_RESULT VKAPI vkGetExtensionSupport( - VK_PHYSICAL_GPU gpu, + VK_PHYSICAL_GPU gpu, const char* pExtName); // Layer discovery functions VK_RESULT VKAPI vkEnumerateLayers( - VK_PHYSICAL_GPU gpu, + VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, @@ -2435,181 +2437,181 @@ VK_RESULT VKAPI vkEnumerateLayers( // Queue functions VK_RESULT VKAPI vkGetDeviceQueue( - VK_DEVICE device, + VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, - VK_QUEUE* pQueue); + VK_QUEUE* pQueue); VK_RESULT VKAPI vkQueueSubmit( - VK_QUEUE queue, + VK_QUEUE queue, uint32_t cmdBufferCount, - const VK_CMD_BUFFER* pCmdBuffers, - VK_FENCE fence); + const VK_CMD_BUFFER* pCmdBuffers, + VK_FENCE fence); VK_RESULT VKAPI vkQueueAddMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); + VK_QUEUE queue, + VK_GPU_MEMORY mem); VK_RESULT VKAPI vkQueueRemoveMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); + VK_QUEUE queue, + VK_GPU_MEMORY mem); VK_RESULT VKAPI vkQueueWaitIdle( - VK_QUEUE queue); + VK_QUEUE queue); VK_RESULT VKAPI vkDeviceWaitIdle( - VK_DEVICE device); + VK_DEVICE device); // Memory functions VK_RESULT VKAPI vkAllocMemory( - VK_DEVICE device, - const VK_MEMORY_ALLOC_INFO* pAllocInfo, - VK_GPU_MEMORY* pMem); + VK_DEVICE device, + const VK_MEMORY_ALLOC_INFO* pAllocInfo, + VK_GPU_MEMORY* pMem); VK_RESULT VKAPI vkFreeMemory( - VK_GPU_MEMORY mem); + VK_GPU_MEMORY mem); VK_RESULT VKAPI vkSetMemoryPriority( - VK_GPU_MEMORY mem, - VK_MEMORY_PRIORITY priority); + VK_GPU_MEMORY mem, + VK_MEMORY_PRIORITY priority); VK_RESULT VKAPI vkMapMemory( - VK_GPU_MEMORY mem, - VK_FLAGS flags, // Reserved + VK_GPU_MEMORY mem, + VK_FLAGS flags, // Reserved void** ppData); VK_RESULT VKAPI vkUnmapMemory( - VK_GPU_MEMORY mem); + VK_GPU_MEMORY mem); VK_RESULT VKAPI vkPinSystemMemory( - VK_DEVICE device, + VK_DEVICE device, const void* pSysMem, size_t memSize, - VK_GPU_MEMORY* pMem); + VK_GPU_MEMORY* pMem); // Multi-device functions VK_RESULT VKAPI vkGetMultiGpuCompatibility( - VK_PHYSICAL_GPU gpu0, - VK_PHYSICAL_GPU gpu1, - VK_GPU_COMPATIBILITY_INFO* pInfo); + VK_PHYSICAL_GPU gpu0, + VK_PHYSICAL_GPU gpu1, + VK_GPU_COMPATIBILITY_INFO* pInfo); VK_RESULT VKAPI vkOpenSharedMemory( - VK_DEVICE device, - const VK_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem); + VK_DEVICE device, + const VK_MEMORY_OPEN_INFO* pOpenInfo, + VK_GPU_MEMORY* pMem); VK_RESULT VKAPI vkOpenSharedSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, - VK_SEMAPHORE* pSemaphore); + VK_DEVICE device, + const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, + VK_SEMAPHORE* pSemaphore); VK_RESULT VKAPI vkOpenPeerMemory( - VK_DEVICE device, - const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem); + VK_DEVICE device, + const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, + VK_GPU_MEMORY* pMem); VK_RESULT VKAPI vkOpenPeerImage( - VK_DEVICE device, - const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, - VK_IMAGE* pImage, - VK_GPU_MEMORY* pMem); + VK_DEVICE device, + const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, + VK_IMAGE* pImage, + VK_GPU_MEMORY* pMem); // Generic API object functions VK_RESULT VKAPI vkDestroyObject( - VK_OBJECT object); + VK_OBJECT object); VK_RESULT VKAPI vkGetObjectInfo( - VK_BASE_OBJECT object, - VK_OBJECT_INFO_TYPE infoType, + VK_BASE_OBJECT object, + VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData); VK_RESULT VKAPI vkBindObjectMemory( - VK_OBJECT object, + VK_OBJECT object, uint32_t allocationIdx, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); + VK_GPU_MEMORY mem, + VK_GPU_SIZE memOffset); VK_RESULT VKAPI vkBindObjectMemoryRange( - VK_OBJECT object, + VK_OBJECT object, uint32_t allocationIdx, - VK_GPU_SIZE rangeOffset, - VK_GPU_SIZE rangeSize, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); + VK_GPU_SIZE rangeOffset, + VK_GPU_SIZE rangeSize, + VK_GPU_MEMORY mem, + VK_GPU_SIZE memOffset); VK_RESULT VKAPI vkBindImageMemoryRange( - VK_IMAGE image, + VK_IMAGE image, uint32_t allocationIdx, - const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); + const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, + VK_GPU_MEMORY mem, + VK_GPU_SIZE memOffset); // Fence functions VK_RESULT VKAPI vkCreateFence( - VK_DEVICE device, - const VK_FENCE_CREATE_INFO* pCreateInfo, - VK_FENCE* pFence); + VK_DEVICE device, + const VK_FENCE_CREATE_INFO* pCreateInfo, + VK_FENCE* pFence); VK_RESULT VKAPI vkResetFences( - VK_DEVICE device, + VK_DEVICE device, uint32_t fenceCount, - VK_FENCE* pFences); + VK_FENCE* pFences); VK_RESULT VKAPI vkGetFenceStatus( VK_FENCE fence); VK_RESULT VKAPI vkWaitForFences( - VK_DEVICE device, + VK_DEVICE device, uint32_t fenceCount, - const VK_FENCE* pFences, + const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout); // timeout in nanoseconds // Queue semaphore functions VK_RESULT VKAPI vkCreateSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, - VK_SEMAPHORE* pSemaphore); + VK_DEVICE device, + const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, + VK_SEMAPHORE* pSemaphore); VK_RESULT VKAPI vkQueueSignalSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); + VK_QUEUE queue, + VK_SEMAPHORE semaphore); VK_RESULT VKAPI vkQueueWaitSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); + VK_QUEUE queue, + VK_SEMAPHORE semaphore); // Event functions VK_RESULT VKAPI vkCreateEvent( - VK_DEVICE device, - const VK_EVENT_CREATE_INFO* pCreateInfo, - VK_EVENT* pEvent); + VK_DEVICE device, + const VK_EVENT_CREATE_INFO* pCreateInfo, + VK_EVENT* pEvent); VK_RESULT VKAPI vkGetEventStatus( - VK_EVENT event); + VK_EVENT event); VK_RESULT VKAPI vkSetEvent( - VK_EVENT event); + VK_EVENT event); VK_RESULT VKAPI vkResetEvent( - VK_EVENT event); + VK_EVENT event); // Query functions VK_RESULT VKAPI vkCreateQueryPool( - VK_DEVICE device, - const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, - VK_QUERY_POOL* pQueryPool); + VK_DEVICE device, + const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, + VK_QUERY_POOL* pQueryPool); VK_RESULT VKAPI vkGetQueryPoolResults( - VK_QUERY_POOL queryPool, + VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, @@ -2618,237 +2620,237 @@ VK_RESULT VKAPI vkGetQueryPoolResults( // Format capabilities VK_RESULT VKAPI vkGetFormatInfo( - VK_DEVICE device, - VK_FORMAT format, - VK_FORMAT_INFO_TYPE infoType, + VK_DEVICE device, + VK_FORMAT format, + VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData); // Buffer functions VK_RESULT VKAPI vkCreateBuffer( - VK_DEVICE device, - const VK_BUFFER_CREATE_INFO* pCreateInfo, - VK_BUFFER* pBuffer); + VK_DEVICE device, + const VK_BUFFER_CREATE_INFO* pCreateInfo, + VK_BUFFER* pBuffer); // Buffer view functions VK_RESULT VKAPI vkCreateBufferView( - VK_DEVICE device, - const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, - VK_BUFFER_VIEW* pView); + VK_DEVICE device, + const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, + VK_BUFFER_VIEW* pView); // Image functions VK_RESULT VKAPI vkCreateImage( - VK_DEVICE device, - const VK_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage); + VK_DEVICE device, + const VK_IMAGE_CREATE_INFO* pCreateInfo, + VK_IMAGE* pImage); VK_RESULT VKAPI vkGetImageSubresourceInfo( - VK_IMAGE image, - const VK_IMAGE_SUBRESOURCE* pSubresource, - VK_SUBRESOURCE_INFO_TYPE infoType, + VK_IMAGE image, + const VK_IMAGE_SUBRESOURCE* pSubresource, + VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData); // Image view functions VK_RESULT VKAPI vkCreateImageView( - VK_DEVICE device, - const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, - VK_IMAGE_VIEW* pView); + VK_DEVICE device, + const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, + VK_IMAGE_VIEW* pView); VK_RESULT VKAPI vkCreateColorAttachmentView( - VK_DEVICE device, + VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - VK_COLOR_ATTACHMENT_VIEW* pView); + VK_COLOR_ATTACHMENT_VIEW* pView); VK_RESULT VKAPI vkCreateDepthStencilView( - VK_DEVICE device, - const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, - VK_DEPTH_STENCIL_VIEW* pView); + VK_DEVICE device, + const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, + VK_DEPTH_STENCIL_VIEW* pView); // Shader functions VK_RESULT VKAPI vkCreateShader( - VK_DEVICE device, - const VK_SHADER_CREATE_INFO* pCreateInfo, - VK_SHADER* pShader); + VK_DEVICE device, + const VK_SHADER_CREATE_INFO* pCreateInfo, + VK_SHADER* pShader); // Pipeline functions VK_RESULT VKAPI vkCreateGraphicsPipeline( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); + VK_DEVICE device, + const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, + VK_PIPELINE* pPipeline); VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); + VK_DEVICE device, + const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, + VK_PIPELINE basePipeline, + VK_PIPELINE* pPipeline); VK_RESULT VKAPI vkCreateComputePipeline( - VK_DEVICE device, - const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); + VK_DEVICE device, + const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, + VK_PIPELINE* pPipeline); VK_RESULT VKAPI vkStorePipeline( - VK_PIPELINE pipeline, + VK_PIPELINE pipeline, size_t* pDataSize, void* pData); VK_RESULT VKAPI vkLoadPipeline( - VK_DEVICE device, + VK_DEVICE device, size_t dataSize, const void* pData, - VK_PIPELINE* pPipeline); + VK_PIPELINE* pPipeline); VK_RESULT VKAPI vkLoadPipelineDerivative( - VK_DEVICE device, + VK_DEVICE device, size_t dataSize, const void* pData, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); + VK_PIPELINE basePipeline, + VK_PIPELINE* pPipeline); // Sampler functions VK_RESULT VKAPI vkCreateSampler( - VK_DEVICE device, - const VK_SAMPLER_CREATE_INFO* pCreateInfo, - VK_SAMPLER* pSampler); + VK_DEVICE device, + const VK_SAMPLER_CREATE_INFO* pCreateInfo, + VK_SAMPLER* pSampler); // Descriptor set functions VK_RESULT VKAPI vkCreateDescriptorSetLayout( - VK_DEVICE device, - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); + VK_DEVICE device, + const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, + VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain( - VK_DEVICE device, + VK_DEVICE device, uint32_t setLayoutArrayCount, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); + const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, + VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); VK_RESULT VKAPI vkBeginDescriptorPoolUpdate( - VK_DEVICE device, - VK_DESCRIPTOR_UPDATE_MODE updateMode); + VK_DEVICE device, + VK_DESCRIPTOR_UPDATE_MODE updateMode); VK_RESULT VKAPI vkEndDescriptorPoolUpdate( - VK_DEVICE device, - VK_CMD_BUFFER cmd); + VK_DEVICE device, + VK_CMD_BUFFER cmd); VK_RESULT VKAPI vkCreateDescriptorPool( - VK_DEVICE device, - VK_DESCRIPTOR_POOL_USAGE poolUsage, + VK_DEVICE device, + VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, - const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_POOL* pDescriptorPool); + const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, + VK_DESCRIPTOR_POOL* pDescriptorPool); VK_RESULT VKAPI vkResetDescriptorPool( - VK_DESCRIPTOR_POOL descriptorPool); + VK_DESCRIPTOR_POOL descriptorPool); VK_RESULT VKAPI vkAllocDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, - VK_DESCRIPTOR_SET_USAGE setUsage, + VK_DESCRIPTOR_POOL descriptorPool, + VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, - VK_DESCRIPTOR_SET* pDescriptorSets, + const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, + VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount); void VKAPI vkClearDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, + VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets); + const VK_DESCRIPTOR_SET* pDescriptorSets); void VKAPI vkUpdateDescriptors( - VK_DESCRIPTOR_SET descriptorSet, + VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, - const void** ppUpdateArray); + const void** pUpdateArray); // State object functions VK_RESULT VKAPI vkCreateDynamicViewportState( - VK_DEVICE device, - const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_VP_STATE_OBJECT* pState); + VK_DEVICE device, + const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_VP_STATE_OBJECT* pState); VK_RESULT VKAPI vkCreateDynamicRasterState( - VK_DEVICE device, - const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_RS_STATE_OBJECT* pState); + VK_DEVICE device, + const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_RS_STATE_OBJECT* pState); VK_RESULT VKAPI vkCreateDynamicColorBlendState( - VK_DEVICE device, - const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_CB_STATE_OBJECT* pState); + VK_DEVICE device, + const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_CB_STATE_OBJECT* pState); VK_RESULT VKAPI vkCreateDynamicDepthStencilState( - VK_DEVICE device, - const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_DS_STATE_OBJECT* pState); + VK_DEVICE device, + const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, + VK_DYNAMIC_DS_STATE_OBJECT* pState); // Command buffer functions VK_RESULT VKAPI vkCreateCommandBuffer( - VK_DEVICE device, - const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, - VK_CMD_BUFFER* pCmdBuffer); + VK_DEVICE device, + const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, + VK_CMD_BUFFER* pCmdBuffer); VK_RESULT VKAPI vkBeginCommandBuffer( - VK_CMD_BUFFER cmdBuffer, - const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); + VK_CMD_BUFFER cmdBuffer, + const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); VK_RESULT VKAPI vkEndCommandBuffer( - VK_CMD_BUFFER cmdBuffer); + VK_CMD_BUFFER cmdBuffer); VK_RESULT VKAPI vkResetCommandBuffer( - VK_CMD_BUFFER cmdBuffer); + VK_CMD_BUFFER cmdBuffer); // Command buffer building functions void VKAPI vkCmdBindPipeline( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_PIPELINE pipeline); + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, + VK_PIPELINE pipeline); void VKAPI vkCmdBindDynamicStateObject( - VK_CMD_BUFFER cmdBuffer, - VK_STATE_BIND_POINT stateBindPoint, - VK_DYNAMIC_STATE_OBJECT dynamicState); + VK_CMD_BUFFER cmdBuffer, + VK_STATE_BIND_POINT stateBindPoint, + VK_DYNAMIC_STATE_OBJECT dynamicState); void VKAPI vkCmdBindDescriptorSets( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, + 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); + const VK_DESCRIPTOR_SET* pDescriptorSets, + const uint32_t * pUserData); void VKAPI vkCmdBindIndexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - VK_INDEX_TYPE indexType); + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, + VK_INDEX_TYPE indexType); void VKAPI vkCmdBindVertexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, uint32_t binding); void VKAPI vkCmdDraw( - VK_CMD_BUFFER cmdBuffer, + VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); void VKAPI vkCmdDrawIndexed( - VK_CMD_BUFFER cmdBuffer, + VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, @@ -2856,199 +2858,198 @@ void VKAPI vkCmdDrawIndexed( uint32_t instanceCount); void VKAPI vkCmdDrawIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, uint32_t count, uint32_t stride); void VKAPI vkCmdDrawIndexedIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset, uint32_t count, uint32_t stride); void VKAPI vkCmdDispatch( - VK_CMD_BUFFER cmdBuffer, + VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z); - void VKAPI vkCmdDispatchIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset); + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER buffer, + VK_GPU_SIZE offset); void VKAPI vkCmdCopyBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_BUFFER destBuffer, + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER srcBuffer, + VK_BUFFER destBuffer, uint32_t regionCount, - const VK_BUFFER_COPY* pRegions); + 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, + 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); + 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, + 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); + const VK_IMAGE_BLIT* pRegions); void VKAPI vkCmdCopyBufferToImage( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER srcBuffer, + VK_IMAGE destImage, + VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions); + const VK_BUFFER_IMAGE_COPY* pRegions); void VKAPI vkCmdCopyImageToBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE srcImage, + VK_IMAGE_LAYOUT srcImageLayout, + VK_BUFFER destBuffer, uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions); + 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); + 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, + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset, + VK_GPU_SIZE dataSize, const uint32_t* pData); void VKAPI vkCmdFillBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset, - VK_GPU_SIZE fillSize, + VK_CMD_BUFFER cmdBuffer, + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset, + VK_GPU_SIZE fillSize, uint32_t data); void VKAPI vkCmdClearColorImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, + VK_CMD_BUFFER cmdBuffer, + VK_IMAGE image, + VK_IMAGE_LAYOUT imageLayout, + VK_CLEAR_COLOR color, uint32_t rangeCount, - const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); + const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); void VKAPI vkCmdClearDepthStencil( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, + 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); + 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, + 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); + const VK_IMAGE_RESOLVE* pRects); void VKAPI vkCmdSetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); + VK_CMD_BUFFER cmdBuffer, + VK_EVENT event, + VK_PIPE_EVENT pipeEvent); void VKAPI vkCmdResetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); + VK_CMD_BUFFER cmdBuffer, + VK_EVENT event, + VK_PIPE_EVENT pipeEvent); void VKAPI vkCmdWaitEvents( - VK_CMD_BUFFER cmdBuffer, - const VK_EVENT_WAIT_INFO* pWaitInfo); + VK_CMD_BUFFER cmdBuffer, + const VK_EVENT_WAIT_INFO* pWaitInfo); void VKAPI vkCmdPipelineBarrier( - VK_CMD_BUFFER cmdBuffer, - const VK_PIPELINE_BARRIER* pBarrier); + VK_CMD_BUFFER cmdBuffer, + const VK_PIPELINE_BARRIER* pBarrier); void VKAPI vkCmdBeginQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VK_CMD_BUFFER cmdBuffer, + VK_QUERY_POOL queryPool, uint32_t slot, - VK_FLAGS flags); + VK_FLAGS flags); void VKAPI vkCmdEndQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VK_CMD_BUFFER cmdBuffer, + VK_QUERY_POOL queryPool, uint32_t slot); void VKAPI vkCmdResetQueryPool( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VK_CMD_BUFFER cmdBuffer, + VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount); void VKAPI vkCmdWriteTimestamp( - VK_CMD_BUFFER cmdBuffer, - VK_TIMESTAMP_TYPE timestampType, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); + VK_CMD_BUFFER cmdBuffer, + VK_TIMESTAMP_TYPE timestampType, + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset); void VKAPI vkCmdInitAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); void VKAPI vkCmdLoadAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - VK_BUFFER srcBuffer, - VK_GPU_SIZE srcOffset); + VK_BUFFER srcBuffer, + VK_GPU_SIZE srcOffset); void VKAPI vkCmdSaveAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VK_CMD_BUFFER cmdBuffer, + VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); + VK_BUFFER destBuffer, + VK_GPU_SIZE destOffset); VK_RESULT VKAPI vkCreateFramebuffer( - VK_DEVICE device, - const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, - VK_FRAMEBUFFER* pFramebuffer); + VK_DEVICE device, + const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, + VK_FRAMEBUFFER* pFramebuffer); VK_RESULT VKAPI vkCreateRenderPass( - VK_DEVICE device, - const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, - VK_RENDER_PASS* pRenderPass); + VK_DEVICE device, + const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, + VK_RENDER_PASS* pRenderPass); void VKAPI vkCmdBeginRenderPass( - VK_CMD_BUFFER cmdBuffer, - const VK_RENDER_PASS_BEGIN* pRenderPassBegin); + VK_CMD_BUFFER cmdBuffer, + const VK_RENDER_PASS_BEGIN* pRenderPassBegin); void VKAPI vkCmdEndRenderPass( - VK_CMD_BUFFER cmdBuffer, - VK_RENDER_PASS renderPass); + VK_CMD_BUFFER cmdBuffer, + VK_RENDER_PASS renderPass); #endif // VK_PROTOTYPES @@ -3057,79 +3058,3 @@ void VKAPI vkCmdEndRenderPass( #endif // __cplusplus #endif // __VULKAN_H__ - -/****************************************************************************************** - - Open Issues + Missing Features - ------------------------------ - - Here are a few higher level issues that we'd like to fix given time. A feature missing - from this header (or the following list) isn't necessarily an indication that we want - to drop that feature. Only that we either haven't thought of it or haven't had time - to add it yet. - - 1) Transform Feedback (XFB) - - OpenGL supports transform feedback (XFB). That is not included in this header, but - we feel there is likely value in including it. - - 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 _VK_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 - } 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: - - vkCmdBindTransformFeedbackMemoryView( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS - uint32_t index, - const VK_MEMORY_VIEW_ATTACH_INFO* pMemView); - - 2) "Bindless" + support for non-bindless hardware. - - 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 - a resource descriptor set, and can modify the set asynchronously to GPU work. - Therefore, we can still have "unlimited textures". An application hoping to use - bindless can use an index into a large table of textures and achieve the same effect. - - For non-bindless hardware, with fixed (but potentially large) register files for - resource bindings, the table approach should still work if a limited size can be - reported somehow. - - 3) Clean up some remaining Mantle'isms. - - Queue types: It's a bit hand wavey. In Mantle, we have a "universal" queue type that - supports compute and graphics and a "compute" queue that only supports compute. Devices - must support at least one universal queue and DMA queues are an extension. I would like - to do the following (and have attempted to do that here, but am only half done): - - a) Separate out the queue capabilities (compute, DMA, graphics) and allow support - for any number of queues with any combination of capabilities each. - - b) Allow compute-only or even DMA-only (like video capture or SDI) devices to - be supported. - - c) Allow new queue types to be supported by extensions without having to allocate - bits in the bitfield until they're promoted to core. - - Terminology: There are still some references to "targets" (render targets) and other - terminology that has been changed from Mantle. Need to do a clean-up pass. - - 4) The window system interface is an extension in Mantle. We have not tried to fold - any of it into core here. There is no mention of SwapBuffers, presentation, default - framebuffers or anything like that. In the extension, presentation is queued up into - the graphics queue just like any other command. - -*******************************************************************************************/ diff --git a/include/xgl.h b/include/xgl.h deleted file mode 100644 index 0b116674..00000000 --- a/include/xgl.h +++ /dev/null @@ -1,3060 +0,0 @@ -// -// File: vulkan.h -// -/* -** Copyright (c) 2014 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - -#ifndef __VULKAN_H__ -#define __VULKAN_H__ - -#define VK_MAKE_VERSION(major, minor, patch) \ - ((major << 22) | (minor << 12) | patch) - -#include "vkPlatform.h" - -// Vulkan API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 69, 0) - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -/* -*************************************************************************************************** -* Core Vulkan API -*************************************************************************************************** -*/ - -#ifdef __cplusplus - #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 VK_DEFINE_HANDLE(_obj) typedef void* _obj; - #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj; -#endif // __cplusplus - -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 VK_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF - -// ------------------------------------------------------------------------------------------------ -// Enumerations - - -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, - - 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 _VK_RESULT -{ - // Return codes for successful operation execution (> = 0) - 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) - 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; - -// ------------------------------------------------------------------------------------------------ -// Vulkan 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 _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 _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 _VK_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 _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 _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 _VK_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 _VK_BUFFER_VIEW_TYPE -{ - 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) - - 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 _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 _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 _VK_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 _VK_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 _VK_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 _VK_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 _VK_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 _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 _VK_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 _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 _VK_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; - -// ------------------------------------------------------------------------------------------------ -// Vulkan structures - -typedef struct _VK_OFFSET2D -{ - int32_t x; - int32_t y; -} VK_OFFSET2D; - -typedef struct _VK_OFFSET3D -{ - int32_t x; - int32_t y; - int32_t z; -} VK_OFFSET3D; - -typedef struct _VK_EXTENT2D -{ - int32_t width; - int32_t height; -} VK_EXTENT2D; - -typedef struct _VK_EXTENT3D -{ - int32_t width; - int32_t height; - int32_t depth; -} VK_EXTENT3D; - -typedef struct _VK_VIEWPORT -{ - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; -} VK_VIEWPORT; - -typedef struct _VK_RECT -{ - VK_OFFSET2D offset; - VK_EXTENT2D extent; -} VK_RECT; - -typedef struct _VK_CHANNEL_MAPPING -{ - VK_CHANNEL_SWIZZLE r; - VK_CHANNEL_SWIZZLE g; - VK_CHANNEL_SWIZZLE b; - VK_CHANNEL_SWIZZLE a; -} VK_CHANNEL_MAPPING; - -typedef struct _VK_PHYSICAL_GPU_PROPERTIES -{ - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorId; - uint32_t deviceId; - 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; - bool32_t multiColorAttachmentClears; - uint32_t maxDescriptorSets; // at least 2? - uint32_t maxViewports; // at least 16? - uint32_t maxColorAttachments; // at least 8? -} VK_PHYSICAL_GPU_PROPERTIES; - -typedef struct _VK_PHYSICAL_GPU_PERFORMANCE -{ - float maxGpuClock; - float aluPerClock; - float texPerClock; - float primsPerClock; - float pixelsPerClock; -} VK_PHYSICAL_GPU_PERFORMANCE; - -typedef struct _VK_GPU_COMPATIBILITY_INFO -{ - VK_FLAGS compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS -} VK_GPU_COMPATIBILITY_INFO; - -typedef struct _VK_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; -} VK_APPLICATION_INFO; - -typedef void* (VKAPI *VK_ALLOC_FUNCTION)( - void* pUserData, - size_t size, - size_t alignment, - VK_SYSTEM_ALLOC_TYPE allocType); - -typedef void (VKAPI *VK_FREE_FUNCTION)( - void* pUserData, - void* pMem); - -typedef struct _VK_ALLOC_CALLBACKS -{ - void* pUserData; - VK_ALLOC_FUNCTION pfnAlloc; - VK_FREE_FUNCTION pfnFree; -} VK_ALLOC_CALLBACKS; - -typedef struct _VK_DEVICE_QUEUE_CREATE_INFO -{ - uint32_t queueNodeIndex; - uint32_t queueCount; -} VK_DEVICE_QUEUE_CREATE_INFO; - -typedef struct _VK_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 VK_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; - VK_VALIDATION_LEVEL maxValidationLevel; - VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS -} VK_DEVICE_CREATE_INFO; - -typedef struct _VK_INSTANCE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO - const void* pNext; // Pointer to next structure - const VK_APPLICATION_INFO* pAppInfo; - const VK_ALLOC_CALLBACKS* pAllocCb; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled -} VK_INSTANCE_CREATE_INFO; - -// can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext -typedef struct _VK_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 vkEnumerateLayers()) -} VK_LAYER_CREATE_INFO; - -typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES -{ - 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 -} VK_PHYSICAL_GPU_QUEUE_PROPERTIES; - -typedef struct _VK_PHYSICAL_GPU_MEMORY_PROPERTIES -{ - bool32_t supportsMigration; - bool32_t supportsPinning; -} VK_PHYSICAL_GPU_MEMORY_PROPERTIES; - -typedef struct _VK_MEMORY_ALLOC_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO - const void* pNext; // Pointer to next structure - 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 VK_MEMORY_ALLOC_INFO chain -// for memory regions allocated for buffer usage. -typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS -} VK_MEMORY_ALLOC_BUFFER_INFO; - -// This structure is included in the VK_MEMORY_ALLOC_INFO chain -// for memory regions allocated for image usage. -typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; - uint32_t samples; -} VK_MEMORY_ALLOC_IMAGE_INFO; - -typedef struct _VK_MEMORY_OPEN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_GPU_MEMORY sharedMem; -} VK_MEMORY_OPEN_INFO; - -typedef struct _VK_PEER_MEMORY_OPEN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_GPU_MEMORY originalMem; -} VK_PEER_MEMORY_OPEN_INFO; - -typedef struct _VK_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 _VK_BUFFER_MEMORY_REQUIREMENTS -{ - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS -} VK_BUFFER_MEMORY_REQUIREMENTS; - -typedef struct _VK_IMAGE_MEMORY_REQUIREMENTS -{ - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; - uint32_t samples; -} VK_IMAGE_MEMORY_REQUIREMENTS; - -typedef struct _VK_FORMAT_PROPERTIES -{ - VK_FLAGS linearTilingFeatures; // VK_FORMAT_FEATURE_FLAGS - VK_FLAGS optimalTilingFeatures; // VK_FORMAT_FEATURE_FLAGS -} VK_FORMAT_PROPERTIES; - -typedef struct _VK_BUFFER_VIEW_ATTACH_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VK_BUFFER_VIEW view; -} VK_BUFFER_VIEW_ATTACH_INFO; - -typedef struct _VK_IMAGE_VIEW_ATTACH_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VK_IMAGE_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_IMAGE_VIEW_ATTACH_INFO; - -typedef struct _VK_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 VK_SAMPLER* pSamplers; -} VK_UPDATE_SAMPLERS; - -typedef struct _VK_SAMPLER_IMAGE_VIEW_INFO -{ - VK_SAMPLER pSampler; - const VK_IMAGE_VIEW_ATTACH_INFO* pImageView; -} VK_SAMPLER_IMAGE_VIEW_INFO; - -typedef struct _VK_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 VK_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews; -} VK_UPDATE_SAMPLER_TEXTURES; - -typedef struct _VK_UPDATE_IMAGES -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES - const void* pNext; // Pointer to next structure - 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 VK_IMAGE_VIEW_ATTACH_INFO* const* pImageViews; -} VK_UPDATE_IMAGES; - -typedef struct _VK_UPDATE_BUFFERS -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS - const void* pNext; // Pointer to next structure - 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 VK_BUFFER_VIEW_ATTACH_INFO* const* pBufferViews; -} VK_UPDATE_BUFFERS; - -typedef struct _VK_UPDATE_AS_COPY -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY - const void* pNext; // Pointer to next structure - VK_DESCRIPTOR_TYPE descriptorType; - VK_DESCRIPTOR_SET descriptorSet; - uint32_t binding; - uint32_t arrayElement; - uint32_t count; -} VK_UPDATE_AS_COPY; - -typedef struct _VK_BUFFER_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO - const void* pNext; // Pointer to next structure. - 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 _VK_BUFFER_VIEW_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure. - 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 _VK_IMAGE_SUBRESOURCE -{ - VK_IMAGE_ASPECT aspect; - uint32_t mipLevel; - uint32_t arraySlice; -} VK_IMAGE_SUBRESOURCE; - -typedef struct _VK_IMAGE_SUBRESOURCE_RANGE -{ - VK_IMAGE_ASPECT aspect; - uint32_t baseMipLevel; - uint32_t mipLevels; - uint32_t baseArraySlice; - uint32_t arraySize; -} VK_IMAGE_SUBRESOURCE_RANGE; - -typedef struct _VK_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 VK_EVENT* pEvents; // Array of event objects to wait on - - 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 VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) -} VK_EVENT_WAIT_INFO; - -typedef struct _VK_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 VK_PIPE_EVENT* pEvents; // Array of pipeline events to wait on - - 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 VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) -} VK_PIPELINE_BARRIER; - -typedef struct _VK_MEMORY_BARRIER -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - 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 _VK_BUFFER_MEMORY_BARRIER -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - 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_BUFFER buffer; // Buffer to sync - - 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 _VK_IMAGE_MEMORY_BARRIER -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - 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_IMAGE_LAYOUT oldLayout; // Current layout of the image - VK_IMAGE_LAYOUT newLayout; // New layout to transition the image to - - VK_IMAGE image; // Image to sync - - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync -} VK_IMAGE_MEMORY_BARRIER; - -typedef struct _VK_IMAGE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO - const void* pNext; // Pointer to next structure. - VK_IMAGE_TYPE imageType; - VK_FORMAT format; - VK_EXTENT3D extent; - uint32_t mipLevels; - uint32_t arraySize; - uint32_t samples; - VK_IMAGE_TILING tiling; - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS -} VK_IMAGE_CREATE_INFO; - -typedef struct _VK_PEER_IMAGE_OPEN_INFO -{ - VK_IMAGE originalImage; -} VK_PEER_IMAGE_OPEN_INFO; - -typedef struct _VK_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 _VK_IMAGE_VIEW_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_IMAGE image; - VK_IMAGE_VIEW_TYPE viewType; - VK_FORMAT format; - VK_CHANNEL_MAPPING channels; - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; - float minLod; -} VK_IMAGE_VIEW_CREATE_INFO; - -typedef struct _VK_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 - VK_IMAGE image; - VK_FORMAT format; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VK_IMAGE msaaResolveImage; - VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; -} VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO; - -typedef struct _VK_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 - VK_IMAGE image; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - 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 _VK_COLOR_ATTACHMENT_BIND_INFO -{ - VK_COLOR_ATTACHMENT_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_COLOR_ATTACHMENT_BIND_INFO; - -typedef struct _VK_DEPTH_STENCIL_BIND_INFO -{ - VK_DEPTH_STENCIL_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_DEPTH_STENCIL_BIND_INFO; - -typedef struct _VK_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 _VK_IMAGE_MEMORY_BIND_INFO -{ - VK_IMAGE_SUBRESOURCE subresource; - VK_OFFSET3D offset; - VK_EXTENT3D extent; -} VK_IMAGE_MEMORY_BIND_INFO; - -typedef struct _VK_IMAGE_COPY -{ - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET3D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET3D destOffset; - VK_EXTENT3D extent; -} VK_IMAGE_COPY; - -typedef struct _VK_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 _VK_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 _VK_IMAGE_RESOLVE -{ - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET2D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET2D destOffset; - VK_EXTENT2D extent; -} VK_IMAGE_RESOLVE; - -typedef struct _VK_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; - VK_FLAGS flags; // Reserved -} VK_SHADER_CREATE_INFO; - -typedef struct _VK_DESCRIPTOR_SET_LAYOUT_BINDING -{ - VK_DESCRIPTOR_TYPE descriptorType; - uint32_t count; - VK_FLAGS stageFlags; // VK_SHADER_STAGE_FLAGS - const VK_SAMPLER* pImmutableSamplers; -} VK_DESCRIPTOR_SET_LAYOUT_BINDING; - -typedef struct _VK_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 VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings -} VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; - -typedef struct _VK_DESCRIPTOR_TYPE_COUNT -{ - VK_DESCRIPTOR_TYPE type; - uint32_t count; -} VK_DESCRIPTOR_TYPE_COUNT; - -typedef struct _VK_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 VK_DESCRIPTOR_TYPE_COUNT* pTypeCount; -} VK_DESCRIPTOR_POOL_CREATE_INFO; - -typedef struct _VK_LINK_CONST_BUFFER -{ - uint32_t bufferId; - size_t bufferSize; - const void* pBufferData; -} VK_LINK_CONST_BUFFER; - -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 -} VK_SPECIALIZATION_MAP_ENTRY; - -typedef struct _VK_SPECIALIZATION_INFO -{ - uint32_t mapEntryCount; - const VK_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries - const void* pData; -} VK_SPECIALIZATION_INFO; - -typedef struct _VK_PIPELINE_SHADER -{ - VK_PIPELINE_SHADER_STAGE stage; - VK_SHADER shader; - uint32_t linkConstBufferCount; - const VK_LINK_CONST_BUFFER* pLinkConstBufferInfo; - const VK_SPECIALIZATION_INFO* pSpecializationInfo; -} VK_PIPELINE_SHADER; - -typedef struct _VK_COMPUTE_PIPELINE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_PIPELINE_SHADER cs; - VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS - VK_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; - uint32_t localSizeX; - uint32_t localSizeY; - uint32_t localSizeZ; - -} VK_COMPUTE_PIPELINE_CREATE_INFO; - -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) - - VK_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented -} VK_VERTEX_INPUT_BINDING_DESCRIPTION; - -typedef struct _VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION -{ - uint32_t location; // location of the shader vertex attrib - uint32_t binding; // Vertex buffer binding id - - VK_FORMAT format; // format of source data - - uint32_t offsetInBytes; // Offset of first element in bytes from base of vertex -} VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION; - -typedef struct _VK_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 VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; - - uint32_t attributeCount; // number of attributes - const VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; -} VK_PIPELINE_VERTEX_INPUT_CREATE_INFO; - -typedef struct _VK_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 - VK_PRIMITIVE_TOPOLOGY topology; - bool32_t disableVertexReuse; // optional - bool32_t primitiveRestartEnable; - uint32_t primitiveRestartIndex; // optional (GL45) -} VK_PIPELINE_IA_STATE_CREATE_INFO; - -typedef struct _VK_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; -} VK_PIPELINE_TESS_STATE_CREATE_INFO; - -typedef struct _VK_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; - VK_COORDINATE_ORIGIN clipOrigin; // optional (GL45) - VK_DEPTH_MODE depthMode; // optional (GL45) -} VK_PIPELINE_VP_STATE_CREATE_INFO; - -typedef struct _VK_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) - 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 _VK_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) - VK_SAMPLE_MASK sampleMask; -} VK_PIPELINE_MS_STATE_CREATE_INFO; - -typedef struct _VK_PIPELINE_CB_ATTACHMENT_STATE -{ - bool32_t blendEnable; - 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; -} VK_PIPELINE_CB_ATTACHMENT_STATE; - -typedef struct _VK_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; - VK_LOGIC_OP logicOp; - uint32_t attachmentCount; // # of pAttachments - const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; -} VK_PIPELINE_CB_STATE_CREATE_INFO; - -typedef struct _VK_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 _VK_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 - VK_FORMAT format; - bool32_t depthTestEnable; - bool32_t depthWriteEnable; - VK_COMPARE_FUNC depthFunc; - bool32_t depthBoundsEnable; // optional (depth_bounds_test) - bool32_t stencilTestEnable; - VK_STENCIL_OP_STATE front; - VK_STENCIL_OP_STATE back; -} VK_PIPELINE_DS_STATE_CREATE_INFO; - -typedef struct _VK_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 - VK_PIPELINE_SHADER shader; -} VK_PIPELINE_SHADER_STAGE_CREATE_INFO; - -typedef struct _VK_GRAPHICS_PIPELINE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS - VK_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain; -} VK_GRAPHICS_PIPELINE_CREATE_INFO; - -typedef struct _VK_SAMPLER_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO - const void* pNext; // Pointer to next structure - 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; - VK_COMPARE_FUNC compareFunc; - float minLod; - float maxLod; - VK_BORDER_COLOR_TYPE borderColorType; -} VK_SAMPLER_CREATE_INFO; - -typedef struct _VK_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 VK_VIEWPORT* pViewports; - const VK_RECT* pScissors; -} VK_DYNAMIC_VP_STATE_CREATE_INFO; - -typedef struct _VK_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; - float slopeScaledDepthBias; - float pointSize; // optional (GL45) - Size of points - float pointFadeThreshold; // optional (GL45) - Size of point fade threshold - float lineWidth; // optional (GL45) - Width of lines -} VK_DYNAMIC_RS_STATE_CREATE_INFO; - -typedef struct _VK_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]; -} VK_DYNAMIC_CB_STATE_CREATE_INFO; - -typedef struct _VK_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) - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; -} VK_DYNAMIC_DS_STATE_CREATE_INFO; - -typedef struct _VK_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; - VK_FLAGS flags; -} VK_CMD_BUFFER_CREATE_INFO; - -typedef struct _VK_CMD_BUFFER_BEGIN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO - const void* pNext; // Pointer to next structure - - VK_FLAGS flags; // VK_CMD_BUFFER_BUILD_FLAGS -} VK_CMD_BUFFER_BEGIN_INFO; - -typedef struct _VK_RENDER_PASS_BEGIN -{ - VK_RENDER_PASS renderPass; - VK_FRAMEBUFFER framebuffer; -} VK_RENDER_PASS_BEGIN; - -typedef struct _VK_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 - - 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 _VK_CLEAR_COLOR_VALUE -{ - float floatColor[4]; - uint32_t rawColor[4]; -} VK_CLEAR_COLOR_VALUE; - -typedef struct _VK_CLEAR_COLOR -{ - VK_CLEAR_COLOR_VALUE color; - bool32_t useRawValue; -} VK_CLEAR_COLOR; - -typedef struct _VK_RENDER_PASS_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO - const void* pNext; // Pointer to next structure - - VK_RECT renderArea; - uint32_t colorAttachmentCount; - VK_EXTENT2D extent; - uint32_t sampleCount; - uint32_t layers; - 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; - VK_ATTACHMENT_STORE_OP depthStoreOp; - VK_ATTACHMENT_LOAD_OP stencilLoadOp; - uint32_t stencilLoadClearValue; - VK_ATTACHMENT_STORE_OP stencilStoreOp; -} VK_RENDER_PASS_CREATE_INFO; - -typedef struct _VK_EVENT_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FLAGS flags; // Reserved -} VK_EVENT_CREATE_INFO; - -typedef struct _VK_FENCE_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_FENCE_CREATE_FLAGS flags; // VK_FENCE_CREATE_FLAGS -} VK_FENCE_CREATE_INFO; - -typedef struct _VK_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; - VK_FLAGS flags; // VK_SEMAPHORE_CREATE_FLAGS -} VK_SEMAPHORE_CREATE_INFO; - -typedef struct _VK_SEMAPHORE_OPEN_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO - const void* pNext; // Pointer to next structure - VK_SEMAPHORE sharedSemaphore; -} VK_SEMAPHORE_OPEN_INFO; - -typedef struct _VK_PIPELINE_STATISTICS_DATA -{ - uint64_t fsInvocations; // Fragment shader invocations - uint64_t cPrimitives; // Clipper primitives - uint64_t cInvocations; // Clipper invocations - uint64_t vsInvocations; // Vertex shader invocations - uint64_t gsInvocations; // Geometry shader invocations - uint64_t gsPrimitives; // Geometry shader primitives - uint64_t iaPrimitives; // Input primitives - uint64_t iaVertices; // Input vertices - uint64_t tcsInvocations; // Tessellation control shader invocations - uint64_t tesInvocations; // Tessellation evaluation shader invocations - uint64_t csInvocations; // Compute shader invocations -} VK_PIPELINE_STATISTICS_DATA; - -typedef struct _VK_QUERY_POOL_CREATE_INFO -{ - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO - const void* pNext; // Pointer to next structure - VK_QUERY_TYPE queryType; - uint32_t slots; -} VK_QUERY_POOL_CREATE_INFO; - -typedef struct _VK_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 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; -} VK_FRAMEBUFFER_CREATE_INFO; - -typedef struct _VK_DRAW_INDIRECT_CMD -{ - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VK_DRAW_INDIRECT_CMD; - -typedef struct _VK_DRAW_INDEXED_INDIRECT_CMD -{ - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VK_DRAW_INDEXED_INDIRECT_CMD; - -typedef struct _VK_DISPATCH_INDIRECT_CMD -{ - uint32_t x; - uint32_t y; - uint32_t z; -} VK_DISPATCH_INDIRECT_CMD; - -// ------------------------------------------------------------------------------------------------ -// API functions -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** pUpdateArray); -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 - -VK_RESULT VKAPI vkCreateInstance( - const VK_INSTANCE_CREATE_INFO* pCreateInfo, - VK_INSTANCE* pInstance); - -VK_RESULT VKAPI vkDestroyInstance( - VK_INSTANCE instance); - -VK_RESULT VKAPI vkEnumerateGpus( - VK_INSTANCE instance, - uint32_t maxGpus, - uint32_t* pGpuCount, - VK_PHYSICAL_GPU* pGpus); - -VK_RESULT VKAPI vkGetGpuInfo( - VK_PHYSICAL_GPU gpu, - VK_PHYSICAL_GPU_INFO_TYPE infoType, - size_t* pDataSize, - void* pData); - -void * VKAPI vkGetProcAddr( - VK_PHYSICAL_GPU gpu, - const char* pName); - -// Device functions - -VK_RESULT VKAPI vkCreateDevice( - VK_PHYSICAL_GPU gpu, - const VK_DEVICE_CREATE_INFO* pCreateInfo, - VK_DEVICE* pDevice); - -VK_RESULT VKAPI vkDestroyDevice( - VK_DEVICE device); - -// Extension discovery functions - -VK_RESULT VKAPI vkGetExtensionSupport( - VK_PHYSICAL_GPU gpu, - const char* pExtName); - -// Layer discovery functions - -VK_RESULT VKAPI vkEnumerateLayers( - VK_PHYSICAL_GPU gpu, - size_t maxLayerCount, - size_t maxStringSize, - size_t* pOutLayerCount, - char* const* pOutLayers, - void* pReserved); - -// Queue functions - -VK_RESULT VKAPI vkGetDeviceQueue( - VK_DEVICE device, - uint32_t queueNodeIndex, - uint32_t queueIndex, - VK_QUEUE* pQueue); - -VK_RESULT VKAPI vkQueueSubmit( - VK_QUEUE queue, - uint32_t cmdBufferCount, - const VK_CMD_BUFFER* pCmdBuffers, - VK_FENCE fence); - -VK_RESULT VKAPI vkQueueAddMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkQueueRemoveMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkQueueWaitIdle( - VK_QUEUE queue); - -VK_RESULT VKAPI vkDeviceWaitIdle( - VK_DEVICE device); - -// Memory functions - -VK_RESULT VKAPI vkAllocMemory( - VK_DEVICE device, - const VK_MEMORY_ALLOC_INFO* pAllocInfo, - VK_GPU_MEMORY* pMem); - -VK_RESULT VKAPI vkFreeMemory( - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkSetMemoryPriority( - VK_GPU_MEMORY mem, - VK_MEMORY_PRIORITY priority); - -VK_RESULT VKAPI vkMapMemory( - VK_GPU_MEMORY mem, - VK_FLAGS flags, // Reserved - void** ppData); - -VK_RESULT VKAPI vkUnmapMemory( - VK_GPU_MEMORY mem); - -VK_RESULT VKAPI vkPinSystemMemory( - VK_DEVICE device, - const void* pSysMem, - size_t memSize, - VK_GPU_MEMORY* pMem); - -// Multi-device functions - -VK_RESULT VKAPI vkGetMultiGpuCompatibility( - VK_PHYSICAL_GPU gpu0, - VK_PHYSICAL_GPU gpu1, - VK_GPU_COMPATIBILITY_INFO* pInfo); - -VK_RESULT VKAPI vkOpenSharedMemory( - VK_DEVICE device, - const VK_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem); - -VK_RESULT VKAPI vkOpenSharedSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, - VK_SEMAPHORE* pSemaphore); - -VK_RESULT VKAPI vkOpenPeerMemory( - VK_DEVICE device, - const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, - VK_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 - -VK_RESULT VKAPI vkDestroyObject( - VK_OBJECT object); - -VK_RESULT VKAPI vkGetObjectInfo( - VK_BASE_OBJECT object, - VK_OBJECT_INFO_TYPE infoType, - size_t* pDataSize, - void* pData); - -VK_RESULT VKAPI vkBindObjectMemory( - VK_OBJECT object, - uint32_t allocationIdx, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); - -VK_RESULT VKAPI vkBindObjectMemoryRange( - VK_OBJECT object, - uint32_t allocationIdx, - VK_GPU_SIZE rangeOffset, - VK_GPU_SIZE rangeSize, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); - -VK_RESULT VKAPI vkBindImageMemoryRange( - VK_IMAGE image, - uint32_t allocationIdx, - const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); - -// Fence functions - -VK_RESULT VKAPI vkCreateFence( - VK_DEVICE device, - const VK_FENCE_CREATE_INFO* pCreateInfo, - VK_FENCE* pFence); - -VK_RESULT VKAPI vkResetFences( - VK_DEVICE device, - uint32_t fenceCount, - VK_FENCE* pFences); - -VK_RESULT VKAPI vkGetFenceStatus( - VK_FENCE fence); - -VK_RESULT VKAPI vkWaitForFences( - VK_DEVICE device, - uint32_t fenceCount, - const VK_FENCE* pFences, - bool32_t waitAll, - uint64_t timeout); // timeout in nanoseconds - -// Queue semaphore functions - -VK_RESULT VKAPI vkCreateSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, - VK_SEMAPHORE* pSemaphore); - -VK_RESULT VKAPI vkQueueSignalSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); - -VK_RESULT VKAPI vkQueueWaitSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); - -// Event functions - -VK_RESULT VKAPI vkCreateEvent( - VK_DEVICE device, - const VK_EVENT_CREATE_INFO* pCreateInfo, - VK_EVENT* pEvent); - -VK_RESULT VKAPI vkGetEventStatus( - VK_EVENT event); - -VK_RESULT VKAPI vkSetEvent( - VK_EVENT event); - -VK_RESULT VKAPI vkResetEvent( - VK_EVENT event); - -// Query functions - -VK_RESULT VKAPI vkCreateQueryPool( - VK_DEVICE device, - const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, - VK_QUERY_POOL* pQueryPool); - -VK_RESULT VKAPI vkGetQueryPoolResults( - VK_QUERY_POOL queryPool, - uint32_t startQuery, - uint32_t queryCount, - size_t* pDataSize, - void* pData); - -// Format capabilities - -VK_RESULT VKAPI vkGetFormatInfo( - VK_DEVICE device, - VK_FORMAT format, - VK_FORMAT_INFO_TYPE infoType, - size_t* pDataSize, - void* pData); - -// Buffer functions - -VK_RESULT VKAPI vkCreateBuffer( - VK_DEVICE device, - const VK_BUFFER_CREATE_INFO* pCreateInfo, - VK_BUFFER* pBuffer); - -// Buffer view functions - -VK_RESULT VKAPI vkCreateBufferView( - VK_DEVICE device, - const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, - VK_BUFFER_VIEW* pView); - -// Image functions - -VK_RESULT VKAPI vkCreateImage( - VK_DEVICE device, - const VK_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage); - -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 - -VK_RESULT VKAPI vkCreateImageView( - VK_DEVICE device, - const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, - VK_IMAGE_VIEW* pView); - -VK_RESULT VKAPI vkCreateColorAttachmentView( - VK_DEVICE device, - const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - VK_COLOR_ATTACHMENT_VIEW* pView); - -VK_RESULT VKAPI vkCreateDepthStencilView( - VK_DEVICE device, - const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, - VK_DEPTH_STENCIL_VIEW* pView); - -// Shader functions - -VK_RESULT VKAPI vkCreateShader( - VK_DEVICE device, - const VK_SHADER_CREATE_INFO* pCreateInfo, - VK_SHADER* pShader); - -// Pipeline functions - -VK_RESULT VKAPI vkCreateGraphicsPipeline( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkCreateComputePipeline( - VK_DEVICE device, - const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkStorePipeline( - VK_PIPELINE pipeline, - size_t* pDataSize, - void* pData); - -VK_RESULT VKAPI vkLoadPipeline( - VK_DEVICE device, - size_t dataSize, - const void* pData, - VK_PIPELINE* pPipeline); - -VK_RESULT VKAPI vkLoadPipelineDerivative( - VK_DEVICE device, - size_t dataSize, - const void* pData, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); - -// Sampler functions - -VK_RESULT VKAPI vkCreateSampler( - VK_DEVICE device, - const VK_SAMPLER_CREATE_INFO* pCreateInfo, - VK_SAMPLER* pSampler); - -// Descriptor set functions - -VK_RESULT VKAPI vkCreateDescriptorSetLayout( - VK_DEVICE device, - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); - -VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain( - VK_DEVICE device, - uint32_t setLayoutArrayCount, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); - -VK_RESULT VKAPI vkBeginDescriptorPoolUpdate( - VK_DEVICE device, - VK_DESCRIPTOR_UPDATE_MODE updateMode); - -VK_RESULT VKAPI vkEndDescriptorPoolUpdate( - VK_DEVICE device, - VK_CMD_BUFFER cmd); - -VK_RESULT VKAPI vkCreateDescriptorPool( - VK_DEVICE device, - VK_DESCRIPTOR_POOL_USAGE poolUsage, - uint32_t maxSets, - const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_POOL* pDescriptorPool); - -VK_RESULT VKAPI vkResetDescriptorPool( - VK_DESCRIPTOR_POOL descriptorPool); - -VK_RESULT VKAPI vkAllocDescriptorSets( - 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); - -void VKAPI vkClearDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, - uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets); - -void VKAPI vkUpdateDescriptors( - VK_DESCRIPTOR_SET descriptorSet, - uint32_t updateCount, - const void** pUpdateArray); - -// State object functions - -VK_RESULT VKAPI vkCreateDynamicViewportState( - VK_DEVICE device, - const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_VP_STATE_OBJECT* pState); - -VK_RESULT VKAPI vkCreateDynamicRasterState( - VK_DEVICE device, - const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_RS_STATE_OBJECT* pState); - -VK_RESULT VKAPI vkCreateDynamicColorBlendState( - VK_DEVICE device, - const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_CB_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 - -VK_RESULT VKAPI vkCreateCommandBuffer( - VK_DEVICE device, - const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, - VK_CMD_BUFFER* pCmdBuffer); - -VK_RESULT VKAPI vkBeginCommandBuffer( - VK_CMD_BUFFER cmdBuffer, - const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); - -VK_RESULT VKAPI vkEndCommandBuffer( - VK_CMD_BUFFER cmdBuffer); - -VK_RESULT VKAPI vkResetCommandBuffer( - VK_CMD_BUFFER cmdBuffer); - -// Command buffer building functions - -void VKAPI vkCmdBindPipeline( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_PIPELINE pipeline); - -void VKAPI vkCmdBindDynamicStateObject( - VK_CMD_BUFFER cmdBuffer, - VK_STATE_BIND_POINT stateBindPoint, - VK_DYNAMIC_STATE_OBJECT dynamicState); - -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 VK_DESCRIPTOR_SET* pDescriptorSets, - const uint32_t * pUserData); - -void VKAPI vkCmdBindIndexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - VK_INDEX_TYPE indexType); - -void VKAPI vkCmdBindVertexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - uint32_t binding); - -void VKAPI vkCmdDraw( - VK_CMD_BUFFER cmdBuffer, - uint32_t firstVertex, - uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndexed( - VK_CMD_BUFFER cmdBuffer, - uint32_t firstIndex, - uint32_t indexCount, - int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDrawIndexedIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDispatch( - VK_CMD_BUFFER cmdBuffer, - uint32_t x, - uint32_t y, - uint32_t z); -void VKAPI vkCmdDispatchIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset); - -void VKAPI vkCmdCopyBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_BUFFER destBuffer, - uint32_t regionCount, - 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 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 VK_IMAGE_BLIT* pRegions); - -void VKAPI vkCmdCopyBufferToImage( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions); - -void VKAPI vkCmdCopyImageToBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, - uint32_t regionCount, - 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 VKAPI vkCmdFillBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset, - VK_GPU_SIZE fillSize, - uint32_t data); - -void VKAPI vkCmdClearColorImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, - uint32_t rangeCount, - const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); - -void VKAPI vkCmdClearDepthStencil( - 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); - -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 VK_IMAGE_RESOLVE* pRects); - -void VKAPI vkCmdSetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); - -void VKAPI vkCmdResetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); - -void VKAPI vkCmdWaitEvents( - VK_CMD_BUFFER cmdBuffer, - const VK_EVENT_WAIT_INFO* pWaitInfo); - -void VKAPI vkCmdPipelineBarrier( - VK_CMD_BUFFER cmdBuffer, - const VK_PIPELINE_BARRIER* pBarrier); - -void VKAPI vkCmdBeginQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, - uint32_t slot, - VK_FLAGS flags); - -void VKAPI vkCmdEndQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, - uint32_t slot); - -void VKAPI vkCmdResetQueryPool( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, - uint32_t startQuery, - uint32_t queryCount); - -void VKAPI vkCmdWriteTimestamp( - VK_CMD_BUFFER cmdBuffer, - VK_TIMESTAMP_TYPE timestampType, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); - -void VKAPI vkCmdInitAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - uint32_t startCounter, - uint32_t counterCount, - const uint32_t* pData); - -void VKAPI vkCmdLoadAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - uint32_t startCounter, - uint32_t counterCount, - VK_BUFFER srcBuffer, - VK_GPU_SIZE srcOffset); - -void VKAPI vkCmdSaveAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - uint32_t startCounter, - uint32_t counterCount, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); - -VK_RESULT VKAPI vkCreateFramebuffer( - VK_DEVICE device, - const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, - VK_FRAMEBUFFER* pFramebuffer); - -VK_RESULT VKAPI vkCreateRenderPass( - VK_DEVICE device, - const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, - VK_RENDER_PASS* pRenderPass); - -void VKAPI vkCmdBeginRenderPass( - VK_CMD_BUFFER cmdBuffer, - const VK_RENDER_PASS_BEGIN* pRenderPassBegin); - -void VKAPI vkCmdEndRenderPass( - VK_CMD_BUFFER cmdBuffer, - VK_RENDER_PASS renderPass); - -#endif // VK_PROTOTYPES - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // __VULKAN_H__ diff --git a/include/xglDbg.h b/include/xglDbg.h deleted file mode 100644 index fb224829..00000000 --- a/include/xglDbg.h +++ /dev/null @@ -1,171 +0,0 @@ -#ifndef __VKDBG_H__ -#define __VKDBG_H__ - -#include - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -typedef enum _VK_DBG_MSG_TYPE -{ - VK_DBG_MSG_UNKNOWN = 0x0, - VK_DBG_MSG_ERROR = 0x1, - VK_DBG_MSG_WARNING = 0x2, - VK_DBG_MSG_PERF_WARNING = 0x3, - - 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 _VK_DBG_MSG_FILTER -{ - VK_DBG_MSG_FILTER_NONE = 0x0, - VK_DBG_MSG_FILTER_REPEATED = 0x1, - VK_DBG_MSG_FILTER_ALL = 0x2, - - 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 _VK_DBG_GLOBAL_OPTION -{ - VK_DBG_OPTION_DEBUG_ECHO_ENABLE = 0x0, - VK_DBG_OPTION_BREAK_ON_ERROR = 0x1, - VK_DBG_OPTION_BREAK_ON_WARNING = 0x2, - - 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 _VK_DBG_DEVICE_OPTION -{ - VK_DBG_OPTION_DISABLE_PIPELINE_LOADS = 0x0, - VK_DBG_OPTION_FORCE_OBJECT_MEMORY_REQS = 0x1, - VK_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT = 0x2, - - 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 _VK_DBG_OBJECT_TYPE -{ - 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 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); - -VK_RESULT VKAPI vkDbgUnregisterMsgCallback( - VK_INSTANCE instance, - VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); - -VK_RESULT VKAPI vkDbgSetMessageFilter( - VK_DEVICE device, - int32_t msgCode, - VK_DBG_MSG_FILTER filter); - -VK_RESULT VKAPI vkDbgSetObjectTag( - VK_BASE_OBJECT object, - size_t tagSize, - const void* pTag); - -VK_RESULT VKAPI vkDbgSetGlobalOption( - VK_INSTANCE instance, - VK_DBG_GLOBAL_OPTION dbgOption, - size_t dataSize, - const void* pData); - -VK_RESULT VKAPI vkDbgSetDeviceOption( - VK_DEVICE device, - VK_DBG_DEVICE_OPTION dbgOption, - size_t dataSize, - const void* pData); - -void VKAPI vkCmdDbgMarkerBegin( - VK_CMD_BUFFER cmdBuffer, - const char* pMarker); - -void VKAPI vkCmdDbgMarkerEnd( - VK_CMD_BUFFER cmdBuffer); - -#endif // VK_PROTOTYPES - -#ifdef __cplusplus -}; // extern "C" -#endif // __cplusplus - -#endif // __VKDBG_H__ diff --git a/include/xglIcd.h b/include/xglIcd.h deleted file mode 100644 index b7916a86..00000000 --- a/include/xglIcd.h +++ /dev/null @@ -1,32 +0,0 @@ -#ifndef VKICD_H -#define VKICD_H - -#include -#include -#include "vkPlatform.h" - -/* - * The ICD must reserve space for a pointer for the loader's dispatch - * table, at the start of . - * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. - */ - -#define ICD_LOADER_MAGIC 0x01CDC0DE - -typedef union _VK_LOADER_DATA { - uint32_t loaderMagic; - void *loaderData; -} VK_LOADER_DATA; - -static inline void set_loader_magic_value(void *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 VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *) pNewObject; - return loader_info->loaderMagic == ICD_LOADER_MAGIC; -} - -#endif // VKICD_H - diff --git a/include/xglLayer.h b/include/xglLayer.h deleted file mode 100644 index c3679a00..00000000 --- a/include/xglLayer.h +++ /dev/null @@ -1,187 +0,0 @@ -/* Need to define dispatch table - * Core struct can then have ptr to dispatch table at the top - * Along with object ptrs for current and next OBJ - */ -#pragma once - -#include "vulkan.h" -#include "vkDbg.h" -#if defined(__linux__) || defined(XCB_NVIDIA) -#include "vkWsiX11Ext.h" -#endif -#if defined(__GNUC__) && __GNUC__ >= 4 -# define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -# define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#else -# define VK_LAYER_EXPORT -#endif - - -typedef struct _VK_BASE_LAYER_OBJECT -{ - vkGetProcAddrType pGPA; - VK_BASE_OBJECT nextObject; - VK_BASE_OBJECT baseObject; -} VK_BASE_LAYER_OBJECT; - -typedef struct _VK_LAYER_DISPATCH_TABLE -{ - 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) - vkWsiX11AssociateConnectionType WsiX11AssociateConnection; - vkWsiX11GetMSCType WsiX11GetMSC; - vkWsiX11CreatePresentableImageType WsiX11CreatePresentableImage; - vkWsiX11QueuePresentType WsiX11QueuePresent; -#endif // WIN32 -} VK_LAYER_DISPATCH_TABLE; - -// LL node for tree of dbg callback functions -typedef struct _VK_LAYER_DBG_FUNCTION_NODE -{ - VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback; - void *pUserData; - struct _VK_LAYER_DBG_FUNCTION_NODE *pNext; -} VK_LAYER_DBG_FUNCTION_NODE; - -typedef enum _VK_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 _VK_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 deleted file mode 100644 index 526a1de8..00000000 --- a/include/xglPlatform.h +++ /dev/null @@ -1,90 +0,0 @@ -// -// File: vkPlatform.h -// -/* -** Copyright (c) 2014 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - - -#ifndef __VKPLATFORM_H__ -#define __VKPLATFORM_H__ - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -/* -*************************************************************************************************** -* Platform-specific directives and type declarations -*************************************************************************************************** -*/ - -#if defined(_WIN32) - // Ensure we don't pick up min/max macros from Winddef.h - #define NOMINMAX - - // On Windows, VKAPI should equate to the __stdcall convention - #define VKAPI __stdcall - - // C99: -#ifndef __cplusplus - #undef inline - #define inline __inline -#endif // __cplusplus -#elif defined(__GNUC__) - // On other platforms using GCC, VKAPI stays undefined - #define VKAPI -#else - // Unsupported Platform! - #error "Unsupported OS Platform detected!" -#endif - -#include - -#if !defined(VK_NO_STDINT_H) - #if defined(_MSC_VER) && (_MSC_VER < 1600) - typedef signed __int8 int8_t; - typedef unsigned __int8 uint8_t; - typedef signed __int16 int16_t; - typedef unsigned __int16 uint16_t; - typedef signed __int32 int32_t; - typedef unsigned __int32 uint32_t; - typedef signed __int64 int64_t; - typedef unsigned __int64 uint64_t; - #else - #include - #endif -#endif // !defined(VK_NO_STDINT_H) - -typedef uint64_t VK_GPU_SIZE; -typedef uint32_t bool32_t; - -typedef uint32_t VK_SAMPLE_MASK; -typedef uint32_t VK_FLAGS; -typedef int32_t VK_ENUM; - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // __VKPLATFORM_H__ diff --git a/include/xglWsiWinExt.h b/include/xglWsiWinExt.h deleted file mode 100644 index f3ee0f33..00000000 --- a/include/xglWsiWinExt.h +++ /dev/null @@ -1,14 +0,0 @@ -/* IN DEVELOPMENT. DO NOT SHIP. */ - -#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 VK_WSI_X11_CONNECTION_INFO; -typedef unsigned int xcb_window_t; -typedef unsigned int xcb_randr_crtc_t; -typedef void VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO; -typedef void VK_WSI_X11_PRESENT_INFO; - -#endif // __VKWSIWINEXT_H__ diff --git a/include/xglWsiX11Ext.h b/include/xglWsiX11Ext.h deleted file mode 100644 index f7046375..00000000 --- a/include/xglWsiX11Ext.h +++ /dev/null @@ -1,143 +0,0 @@ -/* IN DEVELOPMENT. DO NOT SHIP. */ - -#ifndef __VKWSIX11EXT_H__ -#define __VKWSIX11EXT_H__ - -#include -#include -#include "vulkan.h" - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -typedef struct _VK_WSI_X11_CONNECTION_INFO { - xcb_connection_t* pConnection; - xcb_window_t root; - xcb_randr_provider_t provider; -} VK_WSI_X11_CONNECTION_INFO; - -typedef struct _VK_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 _VK_WSI_X11_PRESENT_INFO -{ - /* which window to present to */ - xcb_window_t destWindow; - VK_IMAGE srcImage; - - /** - * After the command buffers in the queue have been completed, if the MSC - * of \p crtc is less than or equal to \p target_msc, wait until it - * reaches \p target_msc. - * - * If the current MSC of \p crtc is greater than \p target_msc, adjust - * \p target_msc as following: - * - * if (divisor) { - * target_msc = crtc_msc - (crtc_msc % divisor) + remainder; - * if (target_msc < crtc_msc) - * target_msc += divisor; - * } else { - * target_msc = crtc_msc; - * } - * - * In other words, either set \p target_msc to an absolute value (require - * 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". - * - * \p crtc can be XCB_NONE. In that case, a suitable CRTC is picked based - * on \p destWindow. - */ - xcb_randr_crtc_t crtc; - uint64_t target_msc; - uint64_t divisor; - uint64_t remainder; - - /** - * After waiting for the current and target MSCs to match, the - * presentation is scheduled. When \p async is false, it will occur the - * next time current MSC is incremented. When \p async is true, it will - * occur as soon as possible. - */ - bool32_t async; - - /** - * When \p flip is false, the contents of \p srcImage are copied to - * \p destWindow when the presentation occurs. When \p flip is true, - * \p srcImage is made the front buffer of \p destWindow. - * - * An error may be returned if \p flip is true but \p destWindow can not - * be flipped to. - */ - bool32_t flip; -} VK_WSI_X11_PRESENT_INFO; - -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, - * 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 vkGetExtensionSupport says "VK_WSI_X11" - * is supported. - */ -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. - */ -VK_RESULT VKAPI vkWsiX11GetMSC( - VK_DEVICE device, - xcb_window_t window, - xcb_randr_crtc_t crtc, - uint64_t* pMsc); - -/** - * 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 - * vkQueue[Add|Remove]MemReference. Destroying the memory or binding another memory to the - * image is not allowed. - */ -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 VK_WSI_X11_PRESENT_INFO. - * - * Fence is reached when the presentation occurs. - */ -VK_RESULT VKAPI vkWsiX11QueuePresent( - VK_QUEUE queue, - const VK_WSI_X11_PRESENT_INFO* pPresentInfo, - VK_FENCE fence); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // __VKWSIX11EXT_H__ diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt index 7e3bf593..0819fe61 100644 --- a/layers/CMakeLists.txt +++ b/layers/CMakeLists.txt @@ -9,8 +9,8 @@ endmacro() macro(run_vk_layer_generate subcmd output) add_custom_command(OUTPUT ${output} - COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${subcmd} ${PROJECT_SOURCE_DIR}/include/vulkan.h > ${output} - DEPENDS ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${PROJECT_SOURCE_DIR}/include/vulkan.h ${PROJECT_SOURCE_DIR}/xgl.py + COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk-layer-generate.py ${subcmd} ${PROJECT_SOURCE_DIR}/include/vulkan.h > ${output} + DEPENDS ${PROJECT_SOURCE_DIR}/vk-layer-generate.py ${PROJECT_SOURCE_DIR}/include/vulkan.h ${PROJECT_SOURCE_DIR}/vulkan.py ) endmacro() @@ -52,12 +52,12 @@ if (NOT WIN32) endif() add_custom_command(OUTPUT vk_dispatch_table_helper.h - COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py dispatch-table-ops layer > vk_dispatch_table_helper.h - DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py) + COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk-generate.py dispatch-table-ops layer > vk_dispatch_table_helper.h + DEPENDS ${PROJECT_SOURCE_DIR}/vk-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py) add_custom_command(OUTPUT vk_generic_intercept_proc_helper.h - COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py layer-intercept-proc > vk_generic_intercept_proc_helper.h - DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py) + COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk-generate.py layer-intercept-proc > vk_generic_intercept_proc_helper.h + DEPENDS ${PROJECT_SOURCE_DIR}/vk-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py) run_vk_helper(gen_enum_string_helper vk_enum_string_helper.h) run_vk_helper(gen_struct_wrappers diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index 53ec6cd4..407a0903 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -1176,7 +1176,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) break; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pSet->ppDescriptors[i]; - pSCI = getSamplerCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].sampler); + pSCI = getSamplerCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].pSampler); if (pSCI) { sprintf(tmp_str, "SAMPLER%u", i); fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str)); diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h index 6e56b356..999736d5 100644 --- a/layers/glave_snapshot.h +++ b/layers/glave_snapshot.h @@ -22,7 +22,7 @@ * DEALINGS IN THE SOFTWARE. */ -#include "xglLayer.h" +#include "vkLayer.h" // Glave Snapshot ERROR codes typedef enum _GLAVE_SNAPSHOT_ERROR diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt index ef8907b0..d8039304 100644 --- a/loader/CMakeLists.txt +++ b/loader/CMakeLists.txt @@ -1,15 +1,15 @@ add_custom_command(OUTPUT dispatch.c - COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py loader-entrypoints > dispatch.c - DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py - ${PROJECT_SOURCE_DIR}/include/xglIcd.h) + COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk-generate.py loader-entrypoints > dispatch.c + DEPENDS ${PROJECT_SOURCE_DIR}/vk-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py + ${PROJECT_SOURCE_DIR}/include/vkIcd.h) add_custom_command(OUTPUT table_ops.h - COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py dispatch-table-ops loader > table_ops.h - DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py) + COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk-generate.py dispatch-table-ops loader > table_ops.h + DEPENDS ${PROJECT_SOURCE_DIR}/vk-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py) -add_custom_command(OUTPUT XGL.def - COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py win-def-file XGL all > XGL.def - DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py) +add_custom_command(OUTPUT vulkan.def + COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk-generate.py win-def-file vulkan all > vulkan.def + DEPENDS ${PROJECT_SOURCE_DIR}/vk-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py) include_directories( ${CMAKE_CURRENT_SOURCE_DIR} @@ -23,16 +23,16 @@ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG") if (WIN32) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS -DXCB_NVIDIA") - add_library(XGL SHARED loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h XGL.def) - set_target_properties(XGL PROPERTIES LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/loader/XGL.def") - add_library(XGLstatic STATIC loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h) - set_target_properties(XGLstatic PROPERTIES OUTPUT_NAME XGLstatic) - target_link_libraries(XGL) + add_library(vulkan SHARED loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h vulkan.def) + set_target_properties(vulkan PROPERTIES LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/loader/vulkan.def") + add_library(VKstatic STATIC loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h) + set_target_properties(VKstatic PROPERTIES OUTPUT_NAME VKstatic) + target_link_libraries(vulkan) endif() if (NOT WIN32) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -Wpointer-arith") - add_library(XGL SHARED loader.c dispatch.c table_ops.h) - set_target_properties(XGL PROPERTIES SOVERSION 0) - target_link_libraries(XGL -ldl -lpthread) + add_library(vulkan SHARED loader.c dispatch.c table_ops.h) + set_target_properties(vulkan PROPERTIES SOVERSION 0) + target_link_libraries(vulkan -ldl -lpthread) endif() diff --git a/vk-generate.py b/vk-generate.py new file mode 100755 index 00000000..6cccd0c9 --- /dev/null +++ b/vk-generate.py @@ -0,0 +1,484 @@ +#!/usr/bin/env python3 +# +# VK +# +# Copyright (C) 2014 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +# DEALINGS IN THE SOFTWARE. +# +# Authors: +# Chia-I Wu + +import sys + +import vulkan + +def generate_get_proc_addr_check(name): + return " if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \ + " return NULL;" % ((name,) * 3) + +class Subcommand(object): + def __init__(self, argv): + self.argv = argv + self.headers = vulkan.headers + self.protos = vulkan.protos + + def run(self): + print(self.generate()) + + def generate(self): + copyright = self.generate_copyright() + header = self.generate_header() + body = self.generate_body() + footer = self.generate_footer() + + contents = [] + if copyright: + contents.append(copyright) + if header: + contents.append(header) + if body: + contents.append(body) + if footer: + contents.append(footer) + + return "\n\n".join(contents) + + def generate_copyright(self): + return """/* THIS FILE IS GENERATED. DO NOT EDIT. */ + +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */""" + + def generate_header(self): + return "\n".join(["#include <" + h + ">" for h in self.headers]) + + def generate_body(self): + pass + + def generate_footer(self): + pass + +class LoaderEntrypointsSubcommand(Subcommand): + def generate_header(self): + return "#include \"loader.h\"" + + def _is_dispatchable(self, proto): + if proto.name in ["GetProcAddr", "DestroyInstance", "EnumerateGpus", + "EnumerateLayers", "DbgRegisterMsgCallback", "GetExtensionSupport", + "DbgUnregisterMsgCallback", "DbgSetGlobalOption"]: + return False + + in_objs = proto.object_in_params() + return in_objs and in_objs[0] == proto.params[0] + + def _generate_object_setup(self, proto): + method = "loader_init_data" + cond = "res == VK_SUCCESS" + + if "Get" in proto.name: + method = "loader_set_data" + + setup = [] + + if proto.name == "AllocDescriptorSets": + psets = proto.params[-2].name + pcount = proto.params[-1].name + setup.append("uint32_t i;") + setup.append("for (i = 0; i < *%s; i++)" % pcount) + setup.append(" %s(%s[i], disp);" % (method, psets)) + else: + obj_params = proto.object_out_params() + for param in obj_params: + setup.append("%s(*%s, disp);" % (method, param.name)) + + if setup: + joined = "\n ".join(setup) + setup = [] + setup.append(" if (%s) {" % cond) + setup.append(" " + joined) + setup.append(" }") + + return "\n".join(setup) + + def _generate_loader_dispatch_entrypoints(self, qual=""): + if qual: + qual += " " + + funcs = [] + for proto in self.protos: + if not self._is_dispatchable(proto): + continue + func = [] + + obj_setup = self._generate_object_setup(proto) + + func.append(qual + proto.c_func(prefix="vk", attr="VKAPI")) + func.append("{") + + # declare local variables + func.append(" const VK_LAYER_DISPATCH_TABLE *disp;") + if proto.ret != 'void' and obj_setup: + func.append(" VK_RESULT res;") + func.append("") + + # active layers before dispatching CreateDevice + if proto.name == "CreateDevice": + func.append(" loader_activate_layers(%s, %s);" % + (proto.params[0].name, proto.params[1].name)) + func.append("") + + # get dispatch table and unwrap GPUs + for param in proto.params: + stmt = "" + if param.ty == "VK_PHYSICAL_GPU": + stmt = "loader_unwrap_gpu(&%s);" % param.name + if param == proto.params[0]: + stmt = "disp = " + stmt + elif param == proto.params[0]: + stmt = "disp = loader_get_data(%s);" % param.name + + if stmt: + func.append(" " + stmt) + func.append("") + + # dispatch! + dispatch = "disp->%s;" % proto.c_call() + if proto.ret == 'void': + func.append(" " + dispatch) + elif not obj_setup: + func.append(" return " + dispatch) + else: + func.append(" res = " + dispatch) + func.append(obj_setup) + func.append("") + func.append(" return res;") + + func.append("}") + + if 'WsiX11AssociateConnection' == proto.name: + funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + + funcs.append("\n".join(func)) + + funcs.append("#endif") + return "\n\n".join(funcs) + + def generate_body(self): + body = [self._generate_loader_dispatch_entrypoints("LOADER_EXPORT")] + + return "\n\n".join(body) + +class DispatchTableOpsSubcommand(Subcommand): + def run(self): + if len(self.argv) != 1: + print("DispatchTableOpsSubcommand: unspecified") + return + + self.prefix = self.argv[0] + super().run() + + def generate_header(self): + return "\n".join(["#include ", + "#include ", + "#include ", + "#include \"loader_platform.h\""]) + + def _generate_init(self): + stmts = [] + for proto in self.protos: + if 'WsiX11AssociateConnection' == proto.name: + stmts.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + if proto.name == "GetProcAddr": + stmts.append("table->%s = gpa; /* direct assignment */" % + proto.name) + else: + stmts.append("table->%s = (vk%sType) gpa(gpu, \"vk%s\");" % + (proto.name, proto.name, proto.name)) + stmts.append("#endif") + + func = [] + func.append("static inline void %s_initialize_dispatch_table(VK_LAYER_DISPATCH_TABLE *table," + % self.prefix) + func.append("%s vkGetProcAddrType gpa," + % (" " * len(self.prefix))) + func.append("%s VK_PHYSICAL_GPU gpu)" + % (" " * len(self.prefix))) + func.append("{") + func.append(" %s" % "\n ".join(stmts)) + func.append("}") + + return "\n".join(func) + + def _generate_lookup(self): + lookups = [] + for proto in self.protos: + if 'WsiX11AssociateConnection' == proto.name: + lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + lookups.append("if (!strcmp(name, \"%s\"))" % (proto.name)) + lookups.append(" return (void *) table->%s;" + % (proto.name)) + lookups.append("#endif") + + func = [] + func.append("static inline void *%s_lookup_dispatch_table(const VK_LAYER_DISPATCH_TABLE *table," + % self.prefix) + func.append("%s const char *name)" + % (" " * len(self.prefix))) + func.append("{") + func.append(generate_get_proc_addr_check("name")) + func.append("") + func.append(" name += 2;") + func.append(" %s" % "\n ".join(lookups)) + func.append("") + func.append(" return NULL;") + func.append("}") + + return "\n".join(func) + + def generate_body(self): + body = [self._generate_init(), + self._generate_lookup()] + + return "\n\n".join(body) + +class IcdDummyEntrypointsSubcommand(Subcommand): + def run(self): + if len(self.argv) == 1: + self.prefix = self.argv[0] + self.qual = "static" + else: + self.prefix = "vk" + self.qual = "ICD_EXPORT" + + super().run() + + def generate_header(self): + return "#include \"icd.h\"" + + def _generate_stub_decl(self, proto): + return proto.c_pretty_decl(self.prefix + proto.name, attr="VKAPI") + + def _generate_stubs(self): + stubs = [] + for proto in self.protos: + decl = self._generate_stub_decl(proto) + if proto.ret != "void": + stmt = " return VK_ERROR_UNKNOWN;\n" + else: + stmt = "" + + stubs.append("%s %s\n{\n%s}" % (self.qual, decl, stmt)) + + return "\n\n".join(stubs) + + def generate_body(self): + return self._generate_stubs() + +class IcdGetProcAddrSubcommand(IcdDummyEntrypointsSubcommand): + def generate_header(self): + return "\n".join(["#include ", "#include \"icd.h\""]) + + def generate_body(self): + for proto in self.protos: + if proto.name == "GetProcAddr": + gpa_proto = proto + + gpa_decl = self._generate_stub_decl(gpa_proto) + gpa_pname = gpa_proto.params[-1].name + + lookups = [] + for proto in self.protos: + if 'WsiX11AssociateConnection' == proto.name: + lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + lookups.append("if (!strcmp(%s, \"%s\"))" % + (gpa_pname, proto.name)) + lookups.append(" return (%s) %s%s;" % + (gpa_proto.ret, self.prefix, proto.name)) + lookups.append("#endif") + + body = [] + body.append("%s %s" % (self.qual, gpa_decl)) + body.append("{") + body.append(generate_get_proc_addr_check(gpa_pname)) + body.append("") + body.append(" %s += 2;" % gpa_pname) + body.append(" %s" % "\n ".join(lookups)) + body.append("") + body.append(" return NULL;") + body.append("}") + + return "\n".join(body) + +class LayerInterceptProcSubcommand(Subcommand): + def run(self): + self.prefix = "vk" + + # we could get the list from argv if wanted + self.intercepted = [proto.name for proto in self.protos + if proto.name not in ["EnumerateGpus"]] + + for proto in self.protos: + if proto.name == "GetProcAddr": + self.gpa = proto + + super().run() + + def generate_header(self): + return "\n".join(["#include ", "#include \"vkLayer.h\""]) + + def generate_body(self): + lookups = [] + for proto in self.protos: + if proto.name not in self.intercepted: + lookups.append("/* no %s%s */" % (self.prefix, proto.name)) + continue + + if 'WsiX11AssociateConnection' == proto.name: + lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + lookups.append("if (!strcmp(name, \"%s\"))" % proto.name) + lookups.append(" return (%s) %s%s;" % + (self.gpa.ret, self.prefix, proto.name)) + lookups.append("#endif") + + body = [] + body.append("static inline %s layer_intercept_proc(const char *name)" % + self.gpa.ret) + body.append("{") + body.append(generate_get_proc_addr_check("name")) + body.append("") + body.append(" name += 2;") + body.append(" %s" % "\n ".join(lookups)) + body.append("") + body.append(" return NULL;") + body.append("}") + + return "\n".join(body) + +class WinDefFileSubcommand(Subcommand): + def run(self): + library_exports = { + "all": [], + "icd": [ + "EnumerateGpus", + "CreateInstance", + "DestroyInstance", + "GetProcAddr", + ], + "layer": [ + "GetProcAddr", + "EnumerateLayers", + ], + } + + if len(self.argv) != 2 or self.argv[1] not in library_exports: + print("WinDefFileSubcommand: {%s}" % + "|".join(library_exports.keys())) + return + + self.library = self.argv[0] + self.exports = library_exports[self.argv[1]] + + super().run() + + def generate_copyright(self): + return """; THIS FILE IS GENERATED. DO NOT EDIT. + +;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Vulkan +; +; Copyright (C) 2015 LunarG, Inc. +; +; Permission is hereby granted, free of charge, to any person obtaining a +; copy of this software and associated documentation files (the "Software"), +; to deal in the Software without restriction, including without limitation +; the rights to use, copy, modify, merge, publish, distribute, sublicense, +; and/or sell copies of the Software, and to permit persons to whom the +; Software is furnished to do so, subject to the following conditions: +; +; The above copyright notice and this permission notice shall be included +; in all copies or substantial portions of the Software. +; +; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +; THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +; DEALINGS IN THE SOFTWARE. +;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;""" + + def generate_header(self): + return "; The following is required on Windows, for exporting symbols from the DLL" + + def generate_body(self): + body = [] + + body.append("LIBRARY " + self.library) + body.append("EXPORTS") + + for proto in self.protos: + if self.exports and proto.name not in self.exports: + continue + body.append(" vk" + proto.name) + + return "\n".join(body) + +def main(): + subcommands = { + "loader-entrypoints": LoaderEntrypointsSubcommand, + "dispatch-table-ops": DispatchTableOpsSubcommand, + "icd-dummy-entrypoints": IcdDummyEntrypointsSubcommand, + "icd-get-proc-addr": IcdGetProcAddrSubcommand, + "layer-intercept-proc": LayerInterceptProcSubcommand, + "win-def-file": WinDefFileSubcommand, + } + + if len(sys.argv) < 2 or sys.argv[1] not in subcommands: + print("Usage: %s [options]" % sys.argv[0]) + print + print("Available sucommands are: %s" % " ".join(subcommands)) + exit(1) + + subcmd = subcommands[sys.argv[1]](sys.argv[2:]) + subcmd.run() + +if __name__ == "__main__": + main() diff --git a/vk-layer-generate.py b/vk-layer-generate.py new file mode 100755 index 00000000..77b70a2b --- /dev/null +++ b/vk-layer-generate.py @@ -0,0 +1,1539 @@ +#!/usr/bin/env python3 +# +# VK +# +# Copyright (C) 2014 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +# DEALINGS IN THE SOFTWARE. +# +# Authors: +# Chia-I Wu + +import sys +import os + +import vulkan +import vk_helper + +def generate_get_proc_addr_check(name): + return " if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \ + " return NULL;" % ((name,) * 3) + +class Subcommand(object): + def __init__(self, argv): + self.argv = argv + self.headers = vulkan.headers + self.protos = vulkan.protos + self.no_addr = False + self.layer_name = "" + + def run(self): + print(self.generate()) + + def generate(self): + copyright = self.generate_copyright() + header = self.generate_header() + body = self.generate_body() + footer = self.generate_footer() + + contents = [] + if copyright: + contents.append(copyright) + if header: + contents.append(header) + if body: + contents.append(body) + if footer: + contents.append(footer) + + return "\n\n".join(contents) + + def generate_copyright(self): + return """/* THIS FILE IS GENERATED. DO NOT EDIT. */ + +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */""" + + def generate_header(self): + return "\n".join(["#include <" + h + ">" for h in self.headers]) + + def generate_body(self): + pass + + def generate_footer(self): + pass + + # Return set of printf '%' qualifier and input to that qualifier + def _get_printf_params(self, vk_type, name, output_param, cpp=False): + # TODO : Need ENUM and STRUCT checks here + if vk_helper.is_type(vk_type, 'enum'):#"_TYPE" in vk_type: # TODO : This should be generic ENUM check + return ("%s", "string_%s(%s)" % (vk_type.strip('const ').strip('*'), name)) + if "char*" == vk_type: + return ("%s", name) + if "uint64" in vk_type: + if '*' in vk_type: + return ("%lu", "*%s" % name) + return ("%lu", name) + if "size" in vk_type: + if '*' in vk_type: + return ("%zu", "*%s" % name) + return ("%zu", name) + if "float" in vk_type: + if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic) + if cpp: + return ("[%i, %i, %i, %i]", '"[" << %s[0] << "," << %s[1] << "," << %s[2] << "," << %s[3] << "]"' % (name, name, name, name)) + return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name)) + return ("%f", name) + if "bool" in vk_type or 'xcb_randr_crtc_t' in vk_type: + return ("%u", name) + if True in [t in vk_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]: + if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic) + if cpp: + return ("[%i, %i, %i, %i]", "%s[0] << %s[1] << %s[2] << %s[3]" % (name, name, name, name)) + return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name)) + if '*' in vk_type: + if 'pUserData' == name: + return ("%i", "((pUserData == 0) ? 0 : *(pUserData))") + return ("%i", "*(%s)" % name) + return ("%i", name) + # TODO : This is special-cased as there's only one "format" param currently and it's nice to expand it + if "VK_FORMAT" == vk_type: + if cpp: + return ("%p", "&%s" % name) + return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_CHANNEL_FORMAT(%s.channelFormat), string_VK_NUM_FORMAT(%s.numericFormat)" % (name, name)) + if output_param: + return ("%p", "(void*)*%s" % name) + if vk_helper.is_type(vk_type, 'struct') and '*' not in vk_type: + return ("%p", "(void*)(&%s)" % name) + return ("%p", "(void*)(%s)" % name) + + def _gen_layer_dbg_callback_register(self): + r_body = [] + r_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)') + r_body.append('{') + r_body.append(' // This layer intercepts callbacks') + r_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));') + r_body.append(' if (!pNewDbgFuncNode)') + r_body.append(' return VK_ERROR_OUT_OF_MEMORY;') + r_body.append(' pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;') + r_body.append(' pNewDbgFuncNode->pUserData = pUserData;') + r_body.append(' pNewDbgFuncNode->pNext = g_pDbgFunctionHead;') + r_body.append(' g_pDbgFunctionHead = pNewDbgFuncNode;') + r_body.append(' // force callbacks if DebugAction hasn\'t been set already other than initial value') + r_body.append(' if (g_actionIsDefault) {') + r_body.append(' g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;') + r_body.append(' }') + r_body.append(' VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);') + r_body.append(' return result;') + r_body.append('}') + return "\n".join(r_body) + + def _gen_layer_dbg_callback_unregister(self): + ur_body = [] + ur_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)') + ur_body.append('{') + ur_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;') + ur_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;') + ur_body.append(' while (pTrav) {') + ur_body.append(' if (pTrav->pfnMsgCallback == pfnMsgCallback) {') + ur_body.append(' pPrev->pNext = pTrav->pNext;') + ur_body.append(' if (g_pDbgFunctionHead == pTrav)') + ur_body.append(' g_pDbgFunctionHead = pTrav->pNext;') + ur_body.append(' free(pTrav);') + ur_body.append(' break;') + ur_body.append(' }') + ur_body.append(' pPrev = pTrav;') + ur_body.append(' pTrav = pTrav->pNext;') + ur_body.append(' }') + ur_body.append(' if (g_pDbgFunctionHead == NULL)') + ur_body.append(' {') + ur_body.append(' if (g_actionIsDefault)') + ur_body.append(' g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;') + ur_body.append(' else') + ur_body.append(' g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK;') + ur_body.append(' }') + ur_body.append(' VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);') + ur_body.append(' return result;') + ur_body.append('}') + return "\n".join(ur_body) + + def _gen_layer_get_extension_support(self, layer="Generic"): + ges_body = [] + ges_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)') + ges_body.append('{') + ges_body.append(' VK_RESULT result;') + ges_body.append(' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;') + ges_body.append('') + ges_body.append(' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */') + ges_body.append(' if (!strncmp(pExtName, "%s", strlen("%s")))' % (layer, layer)) + ges_body.append(' {') + ges_body.append(' result = VK_SUCCESS;') + ges_body.append(' } else if (nextTable.GetExtensionSupport != NULL)') + ges_body.append(' {') + ges_body.append(' result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);') + ges_body.append(' } else') + ges_body.append(' {') + ges_body.append(' result = VK_ERROR_INVALID_EXTENSION;') + ges_body.append(' }') + ges_body.append(' return result;') + ges_body.append('}') + return "\n".join(ges_body) + + def _generate_dispatch_entrypoints(self, qual=""): + if qual: + qual += " " + + funcs = [] + intercepted = [] + for proto in self.protos: + if proto.name != "GetProcAddr" and proto.name != "InitAndEnumerateGpus": + intercept = self.generate_intercept(proto, qual) + if intercept is None: + # fill in default intercept for certain entrypoints + if 'DbgRegisterMsgCallback' == proto.name: + intercept = self._gen_layer_dbg_callback_register() + elif 'DbgUnregisterMsgCallback' == proto.name: + intercept = self._gen_layer_dbg_callback_unregister() + elif 'GetExtensionSupport' == proto.name: + funcs.append(self._gen_layer_get_extension_support(self.layer_name)) + if intercept is not None: + funcs.append(intercept) + intercepted.append(proto) + + prefix="vk" + lookups = [] + for proto in intercepted: + if 'WsiX11' in proto.name: + lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + lookups.append("if (!strcmp(name, \"%s\"))" % proto.name) + lookups.append(" return (void*) %s%s;" % + (prefix, proto.name)) + if 'WsiX11' in proto.name: + lookups.append("#endif") + + # add customized layer_intercept_proc + body = [] + body.append("static inline void* layer_intercept_proc(const char *name)") + body.append("{") + body.append(generate_get_proc_addr_check("name")) + body.append("") + body.append(" name += 2;") + body.append(" %s" % "\n ".join(lookups)) + body.append("") + body.append(" return NULL;") + body.append("}") + funcs.append("\n".join(body)) + return "\n\n".join(funcs) + + + def _generate_extensions(self): + exts = [] + exts.append('uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type)') + exts.append('{') + exts.append(' return (type == VK_OBJECT_TYPE_ANY) ? numTotalObjs : numObjs[type];') + exts.append('}') + exts.append('') + exts.append('VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray)') + exts.append('{') + exts.append(" // This bool flags if we're pulling all objs or just a single class of objs") + exts.append(' bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY);') + exts.append(' // Check the count first thing') + exts.append(' uint64_t maxObjCount = (bAllObjs) ? numTotalObjs : numObjs[type];') + exts.append(' if (objCount > maxObjCount) {') + exts.append(' char str[1024];') + exts.append(' sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_VK_OBJECT_TYPE(type));') + exts.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_OBJCOUNT_MAX_EXCEEDED, "OBJTRACK", str);') + exts.append(' return VK_ERROR_INVALID_VALUE;') + exts.append(' }') + exts.append(' objNode* pTrav = (bAllObjs) ? pGlobalHead : pObjectHead[type];') + exts.append(' for (uint64_t i = 0; i < objCount; i++) {') + exts.append(' if (!pTrav) {') + exts.append(' char str[1024];') + exts.append(' sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_VK_OBJECT_TYPE(type), maxObjCount, i, objCount);') + exts.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);') + exts.append(' return VK_ERROR_UNKNOWN;') + exts.append(' }') + exts.append(' memcpy(&pObjNodeArray[i], pTrav, sizeof(OBJTRACK_NODE));') + exts.append(' pTrav = (bAllObjs) ? pTrav->pNextGlobal : pTrav->pNextObj;') + exts.append(' }') + exts.append(' return VK_SUCCESS;') + exts.append('}') + + return "\n".join(exts) + + def _generate_layer_gpa_function(self, extensions=[]): + func_body = [] + func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)\n" + "{\n" + " VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;\n" + " void* addr;\n" + " if (gpu == NULL)\n" + " return NULL;\n" + " pCurObj = gpuw;\n" + " loader_platform_thread_once(&tabOnce, init%s);\n\n" + " addr = layer_intercept_proc(funcName);\n" + " if (addr)\n" + " return addr;" % self.layer_name) + + if 0 != len(extensions): + for ext_name in extensions: + func_body.append(' else if (!strncmp("%s", funcName, sizeof("%s")))\n' + ' return %s;' % (ext_name, ext_name, ext_name)) + func_body.append(" else {\n" + " if (gpuw->pGPA == NULL)\n" + " return NULL;\n" + " return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);\n" + " }\n" + "}\n") + return "\n".join(func_body) + + def _generate_layer_initialization(self, init_opts=False, prefix='vk', lockname=None): + func_body = ["#include \"vk_dispatch_table_helper.h\""] + func_body.append('static void init%s(void)\n' + '{\n' % self.layer_name) + if init_opts: + func_body.append(' const char *strOpt;') + func_body.append(' // initialize %s options' % self.layer_name) + func_body.append(' getLayerOptionEnum("%sReportLevel", (uint32_t *) &g_reportingLevel);' % self.layer_name) + func_body.append(' g_actionIsDefault = getLayerOptionEnum("%sDebugAction", (uint32_t *) &g_debugAction);' % self.layer_name) + func_body.append('') + func_body.append(' if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)') + func_body.append(' {') + func_body.append(' strOpt = getLayerOption("%sLogFilename");' % self.layer_name) + func_body.append(' if (strOpt)') + func_body.append(' {') + func_body.append(' g_logFile = fopen(strOpt, "w");') + func_body.append(' }') + func_body.append(' if (g_logFile == NULL)') + func_body.append(' g_logFile = stdout;') + func_body.append(' }') + func_body.append('') + func_body.append(' vkGetProcAddrType fpNextGPA;\n' + ' fpNextGPA = pCurObj->pGPA;\n' + ' assert(fpNextGPA);\n') + + func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);") + if lockname is not None: + func_body.append(" if (!%sLockInitialized)" % lockname) + func_body.append(" {") + func_body.append(" // TODO/TBD: Need to delete this mutex sometime. How???") + func_body.append(" loader_platform_thread_create_mutex(&%sLock);" % lockname) + func_body.append(" %sLockInitialized = 1;" % lockname) + func_body.append(" }") + func_body.append("}\n") + return "\n".join(func_body) + + def _generate_layer_initialization_with_lock(self, prefix='vk'): + func_body = ["#include \"vk_dispatch_table_helper.h\""] + func_body.append('static void init%s(void)\n' + '{\n' + ' vkGetProcAddrType fpNextGPA;\n' + ' fpNextGPA = pCurObj->pGPA;\n' + ' assert(fpNextGPA);\n' % self.layer_name); + + func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);\n") + func_body.append(" if (!printLockInitialized)") + func_body.append(" {") + func_body.append(" // TODO/TBD: Need to delete this mutex sometime. How???") + func_body.append(" loader_platform_thread_create_mutex(&printLock);") + func_body.append(" printLockInitialized = 1;") + func_body.append(" }") + func_body.append("}\n") + return "\n".join(func_body) + +class LayerFuncsSubcommand(Subcommand): + def generate_header(self): + return '#include \n#include "loader.h"' + + def generate_body(self): + return self._generate_dispatch_entrypoints("static") + +class LayerDispatchSubcommand(Subcommand): + def generate_header(self): + return '#include "layer_wrappers.h"' + + def generate_body(self): + return self._generate_layer_initialization() + +class GenericLayerSubcommand(Subcommand): + def generate_header(self): + return '#include \n#include \n#include \n#include "loader_platform.h"\n#include "vkLayer.h"\n//The following is #included again to catch certain OS-specific functions being used:\n#include "loader_platform.h"\n\n#include "layers_config.h"\n#include "layers_msg.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;\n\nstatic LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);' + + def generate_intercept(self, proto, qual): + if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback' , 'GetExtensionSupport']: + # use default version + return None + decl = proto.c_func(prefix="vk", attr="VKAPI") + param0_name = proto.params[0].name + ret_val = '' + stmt = '' + funcs = [] + if proto.ret != "void": + ret_val = "VK_RESULT result = " + stmt = " return result;\n" + if 'WsiX11AssociateConnection' == proto.name: + funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + if proto.name == "EnumerateLayers": + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' char str[1024];\n' + ' if (gpu != NULL) {\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' sprintf(str, "At start of layered %s\\n");\n' + ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + ' sprintf(str, "Completed layered %s\\n");\n' + ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n' + ' fflush(stdout);\n' + ' %s' + ' } else {\n' + ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' + ' return VK_ERROR_INVALID_POINTER;\n' + ' // This layer compatible with all GPUs\n' + ' *pOutLayerCount = 1;\n' + ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' + ' return VK_SUCCESS;\n' + ' }\n' + '}' % (qual, decl, proto.params[0].name, proto.name, self.layer_name, ret_val, c_call, proto.name, stmt, self.layer_name)) + elif proto.params[0].ty != "VK_PHYSICAL_GPU": + funcs.append('%s%s\n' + '{\n' + ' %snextTable.%s;\n' + '%s' + '}' % (qual, decl, ret_val, proto.c_call(), stmt)) + else: + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' char str[1024];' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' sprintf(str, "At start of layered %s\\n");\n' + ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + ' sprintf(str, "Completed layered %s\\n");\n' + ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n' + ' fflush(stdout);\n' + '%s' + '}' % (qual, decl, proto.params[0].name, proto.name, self.layer_name, ret_val, c_call, proto.name, stmt)) + if 'WsiX11QueuePresent' == proto.name: + funcs.append("#endif") + return "\n\n".join(funcs) + + def generate_body(self): + self.layer_name = "Generic" + body = [self._generate_layer_initialization(True), + self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), + self._generate_layer_gpa_function()] + + return "\n\n".join(body) + +class ApiDumpSubcommand(Subcommand): + def generate_header(self): + header_txt = [] + header_txt.append('#include \n#include \n#include ') + header_txt.append('#include "loader_platform.h"') + header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper.h"\n') + header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') + header_txt.append('#include "loader_platform.h"') + header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') + header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') + header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') + header_txt.append('static int printLockInitialized = 0;') + header_txt.append('static loader_platform_thread_mutex printLock;\n') + header_txt.append('#define MAX_TID 513') + header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') + header_txt.append('static uint32_t maxTID = 0;') + header_txt.append('// Map actual TID to an index value and return that index') + header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') + header_txt.append('static uint32_t getTIDIndex() {') + header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') + header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') + header_txt.append(' if (tid == tidMapping[i])') + header_txt.append(' return i;') + header_txt.append(' }') + header_txt.append(" // Don't yet have mapping, set it and return newly set index") + header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') + header_txt.append(' tidMapping[maxTID++] = tid;') + header_txt.append(' assert(maxTID < MAX_TID);') + header_txt.append(' return retVal;') + header_txt.append('}') + return "\n".join(header_txt) + + def generate_intercept(self, proto, qual): + decl = proto.c_func(prefix="vk", attr="VKAPI") + param0_name = proto.params[0].name + ret_val = '' + stmt = '' + funcs = [] + sp_param_dict = {} # Store 'index' for struct param to print, or an name of binding "Count" param for array to print + create_params = 0 # Num of params at end of function that are created and returned as output values + if 'WsiX11CreatePresentableImage' in proto.name: + create_params = -2 + elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name: + create_params = -1 + if proto.ret != "void": + ret_val = "VK_RESULT result = " + stmt = " return result;\n" + f_open = '' + f_close = '' + if "File" in self.layer_name: + file_mode = "a" + if 'CreateDevice' in proto.name: + file_mode = "w" + f_open = 'loader_platform_thread_lock_mutex(&printLock);\n pOutFile = fopen(outFileName, "%s");\n ' % (file_mode) + log_func = 'fprintf(pOutFile, "t{%%u} vk%s(' % proto.name + f_close = '\n fclose(pOutFile);\n loader_platform_thread_unlock_mutex(&printLock);' + else: + f_open = 'loader_platform_thread_lock_mutex(&printLock);\n ' + log_func = 'printf("t{%%u} vk%s(' % proto.name + f_close = '\n loader_platform_thread_unlock_mutex(&printLock);' + print_vals = ', getTIDIndex()' + pindex = 0 + prev_count_name = '' + for p in proto.params: + cp = False + if 0 != create_params: + # If this is any of the N last params of the func, treat as output + for y in range(-1, create_params-1, -1): + if p.name == proto.params[y].name: + cp = True + (pft, pfi) = self._get_printf_params(p.ty, p.name, cp) + if self.no_addr and "%p" == pft: + (pft, pfi) = ("%s", '"addr"') + log_func += '%s = %s, ' % (p.name, pft) + print_vals += ', %s' % (pfi) + # Catch array inputs that are bound by a "Count" param + if prev_count_name != '' and (prev_count_name.strip('Count')[1:] in p.name or 'slotCount' == prev_count_name): + sp_param_dict[pindex] = prev_count_name + elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount': + sp_param_dict[pindex] = '*pCount' + elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').strip('const '), 'struct'): + sp_param_dict[pindex] = 'index' + pindex += 1 + if p.name.endswith('Count'): + if '*' in p.ty: + prev_count_name = "*%s" % p.name + else: + prev_count_name = p.name + else: + prev_count_name = '' + log_func = log_func.strip(', ') + if proto.ret != "void": + log_func += ') = %s\\n"' + print_vals += ', string_VK_RESULT(result)' + else: + log_func += ')\\n"' + log_func = '%s%s);' % (log_func, print_vals) + if len(sp_param_dict) > 0: + i_decl = False + log_func += '\n char *pTmpStr = "";' + for sp_index in sorted(sp_param_dict): + # TODO : Clean this if/else block up, too much duplicated code + if 'index' == sp_param_dict[sp_index]: + cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower()) + var_name = proto.params[sp_index].name + if proto.params[sp_index].name != 'color': + log_func += '\n if (%s) {' % (proto.params[sp_index].name) + else: + var_name = "&%s" % proto.params[sp_index].name + log_func += '\n pTmpStr = %s(%s, " ");' % (cis_print_func, var_name) + if "File" in self.layer_name: + if self.no_addr: + log_func += '\n fprintf(pOutFile, " %s (addr)\\n%%s\\n", pTmpStr);' % (var_name) + else: + log_func += '\n fprintf(pOutFile, " %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (var_name, var_name) + else: + if self.no_addr: + log_func += '\n printf(" %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) + else: + log_func += '\n printf(" %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, var_name) + log_func += '\n fflush(stdout);' + log_func += '\n free(pTmpStr);' + if proto.params[sp_index].name != 'color': + log_func += '\n }' + else: # should have a count value stored to iterate over array + if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'): + cis_print_func = 'pTmpStr = vk_print_%s(&%s[i], " ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name) + else: + cis_print_func = 'pTmpStr = (char*)malloc(32);\n sprintf(pTmpStr, " %%p", %s[i]);' % proto.params[sp_index].name + if not i_decl: + log_func += '\n uint32_t i;' + i_decl = True + log_func += '\n for (i = 0; i < %s; i++) {' % (sp_param_dict[sp_index]) + log_func += '\n %s' % (cis_print_func) + if "File" in self.layer_name: + if self.no_addr: + log_func += '\n fprintf(pOutFile, " %s[%%i] (addr)\\n%%s\\n", i, pTmpStr);' % (proto.params[sp_index].name) + else: + log_func += '\n fprintf(pOutFile, " %s[%%i] (%%p)\\n%%s\\n", i, (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) + else: + if self.no_addr: + log_func += '\n printf(" %s[%%i] (addr)\\n%%s\\n", i, pTmpStr);' % (proto.params[sp_index].name) + else: + log_func += '\n printf(" %s[%%i] (%%p)\\n%%s\\n", i, (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) + log_func += '\n fflush(stdout);' + log_func += '\n free(pTmpStr);\n }' + if 'WsiX11AssociateConnection' == proto.name: + funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + if proto.name == "EnumerateLayers": + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' if (gpu != NULL) {\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + ' %s %s %s\n' + ' %s' + ' } else {\n' + ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' + ' return VK_ERROR_INVALID_POINTER;\n' + ' // This layer compatible with all GPUs\n' + ' *pOutLayerCount = 1;\n' + ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' + ' return VK_SUCCESS;\n' + ' }\n' + '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call,f_open, log_func, f_close, stmt, self.layer_name)) + elif 'GetExtensionSupport' == proto.name: + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' VK_RESULT result;\n' + ' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n' + ' if (!strncmp(pExtName, "%s", strlen("%s")))\n' + ' {\n' + ' result = VK_SUCCESS;\n' + ' } else if (nextTable.GetExtensionSupport != NULL)\n' + ' {\n' + ' result = nextTable.%s;\n' + ' %s %s %s\n' + ' } else\n' + ' {\n' + ' result = VK_ERROR_INVALID_EXTENSION;\n' + ' }\n' + '%s' + '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, c_call, f_open, log_func, f_close, stmt)) + elif proto.params[0].ty != "VK_PHYSICAL_GPU": + funcs.append('%s%s\n' + '{\n' + ' %snextTable.%s;\n' + ' %s%s%s\n' + '%s' + '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt)) + else: + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + ' %s%s%s\n' + '%s' + '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call, f_open, log_func, f_close, stmt)) + if 'WsiX11QueuePresent' == proto.name: + funcs.append("#endif") + return "\n\n".join(funcs) + + def generate_body(self): + self.layer_name = "APIDump" + body = [self._generate_layer_initialization_with_lock(), + self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), + self._generate_layer_gpa_function()] + + return "\n\n".join(body) + +class ApiDumpCppSubcommand(Subcommand): + def generate_header(self): + header_txt = [] + header_txt.append('#include \n#include \n#include ') + header_txt.append('#include "loader_platform.h"') + header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_cpp.h"\n') + header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') + header_txt.append('#include "loader_platform.h"') + header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') + header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') + header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') + header_txt.append('static int printLockInitialized = 0;') + header_txt.append('static loader_platform_thread_mutex printLock;\n') + header_txt.append('#define MAX_TID 513') + header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') + header_txt.append('static uint32_t maxTID = 0;') + header_txt.append('// Map actual TID to an index value and return that index') + header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') + header_txt.append('static uint32_t getTIDIndex() {') + header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') + header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') + header_txt.append(' if (tid == tidMapping[i])') + header_txt.append(' return i;') + header_txt.append(' }') + header_txt.append(" // Don't yet have mapping, set it and return newly set index") + header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') + header_txt.append(' tidMapping[maxTID++] = tid;') + header_txt.append(' assert(maxTID < MAX_TID);') + header_txt.append(' return retVal;') + header_txt.append('}') + return "\n".join(header_txt) + + def generate_intercept(self, proto, qual): + decl = proto.c_func(prefix="vk", attr="VKAPI") + param0_name = proto.params[0].name + ret_val = '' + stmt = '' + funcs = [] + sp_param_dict = {} # Store 'index' for struct param to print, or an name of binding "Count" param for array to print + create_params = 0 # Num of params at end of function that are created and returned as output values + if 'WsiX11CreatePresentableImage' in proto.name or 'AllocDescriptorSets' in proto.name: + create_params = -2 + elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name: + create_params = -1 + if proto.ret != "void": + ret_val = "VK_RESULT result = " + stmt = " return result;\n" + f_open = '' + f_close = '' + if "File" in self.layer_name: + file_mode = "a" + if 'CreateDevice' in proto.name: + file_mode = "w" + f_open = 'loader_platform_thread_lock_mutex(&printLock);\n pOutFile = fopen(outFileName, "%s");\n ' % (file_mode) + log_func = 'fprintf(pOutFile, "t{%%u} vk%s(' % proto.name + f_close = '\n fclose(pOutFile);\n loader_platform_thread_unlock_mutex(&printLock);' + else: + f_open = 'loader_platform_thread_lock_mutex(&printLock);\n ' + log_func = 'cout << "t{" << getTIDIndex() << "} vk%s(' % proto.name + f_close = '\n loader_platform_thread_unlock_mutex(&printLock);' + pindex = 0 + prev_count_name = '' + for p in proto.params: + cp = False + if 0 != create_params: + # If this is any of the N last params of the func, treat as output + for y in range(-1, create_params-1, -1): + if p.name == proto.params[y].name: + cp = True + (pft, pfi) = self._get_printf_params(p.ty, p.name, cp, cpp=True) + if self.no_addr and "%p" == pft: + (pft, pfi) = ("%s", '"addr"') + log_func += '%s = " << %s << ", ' % (p.name, pfi) + #print_vals += ', %s' % (pfi) + if prev_count_name != '' and (prev_count_name.strip('Count')[1:] in p.name or 'slotCount' == prev_count_name): + sp_param_dict[pindex] = prev_count_name + elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount': + sp_param_dict[pindex] = '*pCount' + elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').strip('const '), 'struct'): + sp_param_dict[pindex] = 'index' + pindex += 1 + if p.name.endswith('Count'): + if '*' in p.ty: + prev_count_name = "*%s" % p.name + else: + prev_count_name = p.name + else: + prev_count_name = '' + log_func = log_func.strip(', ') + if proto.ret != "void": + log_func += ') = " << string_VK_RESULT((VK_RESULT)result) << endl' + #print_vals += ', string_VK_RESULT_CODE(result)' + else: + log_func += ')\\n"' + log_func += ';' + if len(sp_param_dict) > 0: + i_decl = False + log_func += '\n string tmp_str;' + for sp_index in sp_param_dict: + if 'index' == sp_param_dict[sp_index]: + cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower()) + var_name = proto.params[sp_index].name + if proto.params[sp_index].name != 'color': + log_func += '\n if (%s) {' % (proto.params[sp_index].name) + else: + var_name = '&%s' % (proto.params[sp_index].name) + log_func += '\n tmp_str = %s(%s, " ");' % (cis_print_func, var_name) + if "File" in self.layer_name: + if self.no_addr: + log_func += '\n fprintf(pOutFile, " %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) + else: + log_func += '\n fprintf(pOutFile, " %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, var_name) + else: + if self.no_addr: + #log_func += '\n printf(" %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) + log_func += '\n cout << " %s (addr)" << endl << tmp_str << endl;' % (proto.params[sp_index].name) + else: + #log_func += '\n printf(" %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) + log_func += '\n cout << " %s (" << %s << ")" << endl << tmp_str << endl;' % (proto.params[sp_index].name, var_name) + #log_func += '\n fflush(stdout);' + if proto.params[sp_index].name != 'color': + log_func += '\n }' + else: # We have a count value stored to iterate over an array + print_cast = '' + print_func = '' + if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'): + print_cast = '&' + print_func = 'vk_print_%s' % proto.params[sp_index].ty.strip('const ').strip('*').lower() + #cis_print_func = 'tmp_str = vk_print_%s(&%s[i], " ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name) +# TODO : Need to display this address as a string + else: + print_cast = '(void*)' + print_func = 'string_convert_helper' + #cis_print_func = 'tmp_str = string_convert_helper((void*)%s[i], " ");' % proto.params[sp_index].name + cis_print_func = 'tmp_str = %s(%s%s[i], " ");' % (print_func, print_cast, proto.params[sp_index].name) +# else: +# cis_print_func = '' + if not i_decl: + log_func += '\n uint32_t i;' + i_decl = True + log_func += '\n for (i = 0; i < %s; i++) {' % (sp_param_dict[sp_index]) + log_func += '\n %s' % (cis_print_func) + if "File" in self.layer_name: + if self.no_addr: + log_func += '\n fprintf(pOutFile, " %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) + else: + log_func += '\n fprintf(pOutFile, " %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) + else: + if self.no_addr: + #log_func += '\n printf(" %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) + log_func += '\n cout << " %s[" << (uint32_t)i << "] (addr)" << endl << tmp_str << endl;' % (proto.params[sp_index].name) + else: + #log_func += '\n printf(" %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) + #log_func += '\n cout << " %s[" << (uint32_t)i << "] (" << %s[i] << ")" << endl << tmp_str << endl;' % (proto.params[sp_index].name, proto.params[sp_index].name) + log_func += '\n cout << " %s[" << i << "] (" << %s%s[i] << ")" << endl << tmp_str << endl;' % (proto.params[sp_index].name, print_cast, proto.params[sp_index].name) + #log_func += '\n fflush(stdout);' + log_func += '\n }' + if 'WsiX11AssociateConnection' == proto.name: + funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + if proto.name == "EnumerateLayers": + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' if (gpu != NULL) {\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + ' %s %s %s\n' + ' %s' + ' } else {\n' + ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' + ' return VK_ERROR_INVALID_POINTER;\n' + ' // This layer compatible with all GPUs\n' + ' *pOutLayerCount = 1;\n' + ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' + ' return VK_SUCCESS;\n' + ' }\n' + '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call,f_open, log_func, f_close, stmt, self.layer_name)) + elif 'GetExtensionSupport' == proto.name: + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' VK_RESULT result;\n' + ' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n' + ' if (!strncmp(pExtName, "%s", strlen("%s")))\n' + ' {\n' + ' result = VK_SUCCESS;\n' + ' } else if (nextTable.GetExtensionSupport != NULL)\n' + ' {\n' + ' result = nextTable.%s;\n' + ' %s %s %s\n' + ' } else\n' + ' {\n' + ' result = VK_ERROR_INVALID_EXTENSION;\n' + ' }\n' + '%s' + '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, c_call, f_open, log_func, f_close, stmt)) + elif proto.params[0].ty != "VK_PHYSICAL_GPU": + funcs.append('%s%s\n' + '{\n' + ' %snextTable.%s;\n' + ' %s%s%s\n' + '%s' + '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt)) + else: + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + ' %s%s%s\n' + '%s' + '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call, f_open, log_func, f_close, stmt)) + if 'WsiX11QueuePresent' == proto.name: + funcs.append("#endif") + return "\n\n".join(funcs) + + def generate_body(self): + self.layer_name = "APIDumpCpp" + body = [self._generate_layer_initialization_with_lock(), + self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), + self._generate_layer_gpa_function()] + + return "\n\n".join(body) + +# subclass from ApiDumpSubcommand instead of Subcommand +class ApiDumpFileSubcommand(ApiDumpSubcommand): + def generate_header(self): + header_txt = [] + header_txt.append('#include \n#include \n#include ') + header_txt.append('#include "loader_platform.h"') + header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper.h"\n') + header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') + header_txt.append('#include "loader_platform.h"') + header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') + header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') + header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') + header_txt.append('static int printLockInitialized = 0;') + header_txt.append('static loader_platform_thread_mutex printLock;\n') + header_txt.append('#define MAX_TID 513') + header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') + header_txt.append('static uint32_t maxTID = 0;') + header_txt.append('// Map actual TID to an index value and return that index') + header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') + header_txt.append('static uint32_t getTIDIndex() {') + header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') + header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') + header_txt.append(' if (tid == tidMapping[i])') + header_txt.append(' return i;') + header_txt.append(' }') + header_txt.append(" // Don't yet have mapping, set it and return newly set index") + header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') + header_txt.append(' tidMapping[maxTID++] = tid;') + header_txt.append(' assert(maxTID < MAX_TID);') + header_txt.append(' return retVal;') + header_txt.append('}\n') + header_txt.append('static FILE* pOutFile;\nstatic char* outFileName = "vk_apidump.txt";') + return "\n".join(header_txt) + + def generate_body(self): + self.layer_name = "APIDumpFile" + body = [self._generate_layer_initialization_with_lock(), + self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), + self._generate_layer_gpa_function()] + + return "\n\n".join(body) + +# subclass from ApiDumpSubcommand instead of Subcommand +class ApiDumpNoAddrSubcommand(ApiDumpSubcommand): + def generate_header(self): + header_txt = [] + header_txt.append('#include \n#include \n#include ') + header_txt.append('#include "loader_platform.h"') + header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_no_addr.h"\n') + header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') + header_txt.append('#include "loader_platform.h"') + header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') + header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') + header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') + header_txt.append('static int printLockInitialized = 0;') + header_txt.append('static loader_platform_thread_mutex printLock;\n') + header_txt.append('#define MAX_TID 513') + header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') + header_txt.append('static uint32_t maxTID = 0;') + header_txt.append('// Map actual TID to an index value and return that index') + header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') + header_txt.append('static uint32_t getTIDIndex() {') + header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') + header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') + header_txt.append(' if (tid == tidMapping[i])') + header_txt.append(' return i;') + header_txt.append(' }') + header_txt.append(" // Don't yet have mapping, set it and return newly set index") + header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') + header_txt.append(' tidMapping[maxTID++] = tid;') + header_txt.append(' assert(maxTID < MAX_TID);') + header_txt.append(' return retVal;') + header_txt.append('}') + return "\n".join(header_txt) + + def generate_body(self): + self.layer_name = "APIDumpNoAddr" + self.no_addr = True + body = [self._generate_layer_initialization_with_lock(), + self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), + self._generate_layer_gpa_function()] + + return "\n\n".join(body) + +# subclass from ApiDumpCppSubcommand instead of Subcommand +class ApiDumpNoAddrCppSubcommand(ApiDumpCppSubcommand): + def generate_header(self): + header_txt = [] + header_txt.append('#include \n#include \n#include ') + header_txt.append('#include "loader_platform.h"') + header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_no_addr_cpp.h"\n') + header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') + header_txt.append('#include "loader_platform.h"') + header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') + header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') + header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') + header_txt.append('static int printLockInitialized = 0;') + header_txt.append('static loader_platform_thread_mutex printLock;\n') + header_txt.append('#define MAX_TID 513') + header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') + header_txt.append('static uint32_t maxTID = 0;') + header_txt.append('// Map actual TID to an index value and return that index') + header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') + header_txt.append('static uint32_t getTIDIndex() {') + header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') + header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') + header_txt.append(' if (tid == tidMapping[i])') + header_txt.append(' return i;') + header_txt.append(' }') + header_txt.append(" // Don't yet have mapping, set it and return newly set index") + header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') + header_txt.append(' tidMapping[maxTID++] = tid;') + header_txt.append(' assert(maxTID < MAX_TID);') + header_txt.append(' return retVal;') + header_txt.append('}') + return "\n".join(header_txt) + + def generate_body(self): + self.layer_name = "APIDumpNoAddrCpp" + self.no_addr = True + body = [self._generate_layer_initialization_with_lock(), + self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), + self._generate_layer_gpa_function()] + + return "\n\n".join(body) + +class ObjectTrackerSubcommand(Subcommand): + def generate_header(self): + header_txt = [] + header_txt.append('#include \n#include \n#include \n#include "loader_platform.h"') + header_txt.append('#include "object_track.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;') + header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') + header_txt.append('#include "loader_platform.h"') + header_txt.append('#include "layers_config.h"') + header_txt.append('#include "layers_msg.h"') + header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') + header_txt.append('static long long unsigned int object_track_index = 0;') + header_txt.append('static int objLockInitialized = 0;') + header_txt.append('static loader_platform_thread_mutex objLock;') + header_txt.append('') + header_txt.append('// We maintain a "Global" list which links every object and a') + header_txt.append('// per-Object list which just links objects of a given type') + header_txt.append('// The object node has both pointers so the actual nodes are shared between the two lists') + header_txt.append('typedef struct _objNode {') + header_txt.append(' OBJTRACK_NODE obj;') + header_txt.append(' struct _objNode *pNextObj;') + header_txt.append(' struct _objNode *pNextGlobal;') + header_txt.append('} objNode;') + header_txt.append('static objNode *pObjectHead[VK_NUM_OBJECT_TYPE] = {0};') + header_txt.append('static objNode *pGlobalHead = NULL;') + header_txt.append('static uint64_t numObjs[VK_NUM_OBJECT_TYPE] = {0};') + header_txt.append('static uint64_t numTotalObjs = 0;') + header_txt.append('static uint32_t maxMemReferences = 0;') + header_txt.append('// Debug function to print global list and each individual object list') + header_txt.append('static void ll_print_lists()') + header_txt.append('{') + header_txt.append(' objNode* pTrav = pGlobalHead;') + header_txt.append(' printf("=====GLOBAL OBJECT LIST (%lu total objs):\\n", numTotalObjs);') + header_txt.append(' while (pTrav) {') + header_txt.append(' printf(" ObjNode (%p) w/ %s obj %p has pNextGlobal %p\\n", (void*)pTrav, string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextGlobal);') + header_txt.append(' pTrav = pTrav->pNextGlobal;') + header_txt.append(' }') + header_txt.append(' for (uint32_t i = 0; i < VK_NUM_OBJECT_TYPE; i++) {') + header_txt.append(' pTrav = pObjectHead[i];') + header_txt.append(' if (pTrav) {') + header_txt.append(' printf("=====%s OBJECT LIST (%lu objs):\\n", string_VK_OBJECT_TYPE(pTrav->obj.objType), numObjs[i]);') + header_txt.append(' while (pTrav) {') + header_txt.append(' printf(" ObjNode (%p) w/ %s obj %p has pNextObj %p\\n", (void*)pTrav, string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextObj);') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' }') + header_txt.append(' }') + header_txt.append('}') + header_txt.append('static void ll_insert_obj(void* pObj, VK_OBJECT_TYPE objType) {') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "OBJ[%llu] : CREATE %s object %p", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj);') + header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') + header_txt.append(' objNode* pNewObjNode = (objNode*)malloc(sizeof(objNode));') + header_txt.append(' pNewObjNode->obj.pObj = pObj;') + header_txt.append(' pNewObjNode->obj.objType = objType;') + header_txt.append(' pNewObjNode->obj.status = OBJSTATUS_NONE;') + header_txt.append(' pNewObjNode->obj.numUses = 0;') + header_txt.append(' // insert at front of global list') + header_txt.append(' pNewObjNode->pNextGlobal = pGlobalHead;') + header_txt.append(' pGlobalHead = pNewObjNode;') + header_txt.append(' // insert at front of object list') + header_txt.append(' pNewObjNode->pNextObj = pObjectHead[objType];') + header_txt.append(' pObjectHead[objType] = pNewObjNode;') + header_txt.append(' // increment obj counts') + header_txt.append(' numObjs[objType]++;') + header_txt.append(' numTotalObjs++;') + header_txt.append(' //sprintf(str, "OBJ_STAT : %lu total objs & %lu %s objs.", numTotalObjs, numObjs[objType], string_VK_OBJECT_TYPE(objType));') + header_txt.append(' if (0) ll_print_lists();') + header_txt.append('}') + header_txt.append('// Traverse global list and return type for given object') + header_txt.append('static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) {') + header_txt.append(' objNode *pTrav = pGlobalHead;') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == object)') + header_txt.append(' return pTrav->obj.objType;') + header_txt.append(' pTrav = pTrav->pNextGlobal;') + header_txt.append(' }') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "Attempting look-up on obj %p but it is NOT in the global list!", (void*)object);') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, OBJTRACK_MISSING_OBJECT, "OBJTRACK", str);') + header_txt.append(' return VK_OBJECT_TYPE_UNKNOWN;') + header_txt.append('}') + header_txt.append('#if 0') + header_txt.append('static uint64_t ll_get_obj_uses(void* pObj, VK_OBJECT_TYPE objType) {') + header_txt.append(' objNode *pTrav = pObjectHead[objType];') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' return pTrav->obj.numUses;') + header_txt.append(' }') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' return 0;') + header_txt.append('}') + header_txt.append('#endif') + header_txt.append('static void ll_increment_use_count(void* pObj, VK_OBJECT_TYPE objType) {') + header_txt.append(' objNode *pTrav = pObjectHead[objType];') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' pTrav->obj.numUses++;') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "OBJ[%llu] : USING %s object %p (%lu total uses)", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj, pTrav->obj.numUses);') + header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') + header_txt.append(' return;') + header_txt.append(' }') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' // If we do not find obj, insert it and then increment count') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_VK_OBJECT_TYPE(objType));') + header_txt.append(' layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') + header_txt.append('') + header_txt.append(' ll_insert_obj(pObj, objType);') + header_txt.append(' ll_increment_use_count(pObj, objType);') + header_txt.append('}') + header_txt.append('// We usually do not know Obj type when we destroy it so have to fetch') + header_txt.append('// Type from global list w/ ll_destroy_obj()') + header_txt.append('// and then do the full removal from both lists w/ ll_remove_obj_type()') + header_txt.append('static void ll_remove_obj_type(void* pObj, VK_OBJECT_TYPE objType) {') + header_txt.append(' objNode *pTrav = pObjectHead[objType];') + header_txt.append(' objNode *pPrev = pObjectHead[objType];') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' pPrev->pNextObj = pTrav->pNextObj;') + header_txt.append(' // update HEAD of Obj list as needed') + header_txt.append(' if (pObjectHead[objType] == pTrav)') + header_txt.append(' pObjectHead[objType] = pTrav->pNextObj;') + header_txt.append(' assert(numObjs[objType] > 0);') + header_txt.append(' numObjs[objType]--;') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "OBJ[%llu] : DESTROY %s object %p", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj);') + header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') + header_txt.append(' return;') + header_txt.append(' }') + header_txt.append(' pPrev = pTrav;') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_VK_OBJECT_TYPE(objType));') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);') + header_txt.append('}') + header_txt.append('// Parse global list to find obj type, then remove obj from obj type list, finally') + header_txt.append('// remove obj from global list') + header_txt.append('static void ll_destroy_obj(void* pObj) {') + header_txt.append(' objNode *pTrav = pGlobalHead;') + header_txt.append(' objNode *pPrev = pGlobalHead;') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' ll_remove_obj_type(pObj, pTrav->obj.objType);') + header_txt.append(' pPrev->pNextGlobal = pTrav->pNextGlobal;') + header_txt.append(' // update HEAD of global list if needed') + header_txt.append(' if (pGlobalHead == pTrav)') + header_txt.append(' pGlobalHead = pTrav->pNextGlobal;') + header_txt.append(' assert(numTotalObjs > 0);') + header_txt.append(' numTotalObjs--;') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "OBJ_STAT Removed %s obj %p that was used %lu times (%lu total objs remain & %lu %s objs).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses, numTotalObjs, numObjs[pTrav->obj.objType], string_VK_OBJECT_TYPE(pTrav->obj.objType));') + header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') + header_txt.append(' free(pTrav);') + header_txt.append(' return;') + header_txt.append(' }') + header_txt.append(' pPrev = pTrav;') + header_txt.append(' pTrav = pTrav->pNextGlobal;') + header_txt.append(' }') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "Unable to remove obj %p. Was it created? Has it already been destroyed?", pObj);') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_DESTROY_OBJECT_FAILED, "OBJTRACK", str);') + header_txt.append('}') + header_txt.append('// Set selected flag state for an object node') + header_txt.append('static void set_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {') + header_txt.append(' if (pObj != NULL) {') + header_txt.append(' objNode *pTrav = pObjectHead[objType];') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' pTrav->obj.status |= status_flag;') + header_txt.append(' return;') + header_txt.append(' }') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' // If we do not find it print an error') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') + header_txt.append(' }'); + header_txt.append('}') + header_txt.append('') + header_txt.append('// Track selected state for an object node') + header_txt.append('static void track_object_status(void* pObj, VK_STATE_BIND_POINT stateBindPoint) {') + header_txt.append(' objNode *pTrav = pObjectHead[VK_OBJECT_TYPE_CMD_BUFFER];') + header_txt.append('') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' if (stateBindPoint == VK_STATE_BIND_VIEWPORT) {') + header_txt.append(' pTrav->obj.status |= OBJSTATUS_VIEWPORT_BOUND;') + header_txt.append(' } else if (stateBindPoint == VK_STATE_BIND_RASTER) {') + header_txt.append(' pTrav->obj.status |= OBJSTATUS_RASTER_BOUND;') + header_txt.append(' } else if (stateBindPoint == VK_STATE_BIND_COLOR_BLEND) {') + header_txt.append(' pTrav->obj.status |= OBJSTATUS_COLOR_BLEND_BOUND;') + header_txt.append(' } else if (stateBindPoint == VK_STATE_BIND_DEPTH_STENCIL) {') + header_txt.append(' pTrav->obj.status |= OBJSTATUS_DEPTH_STENCIL_BOUND;') + header_txt.append(' }') + header_txt.append(' return;') + header_txt.append(' }') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' // If we do not find it print an error') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "Unable to track status for non-existent Command Buffer object %p", pObj);') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') + header_txt.append('}') + header_txt.append('') + header_txt.append('// Reset selected flag state for an object node') + header_txt.append('static void reset_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {') + header_txt.append(' objNode *pTrav = pObjectHead[objType];') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' pTrav->obj.status &= ~status_flag;') + header_txt.append(' return;') + header_txt.append(' }') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' // If we do not find it print an error') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') + header_txt.append('}') + header_txt.append('') + header_txt.append('// Check object status for selected flag state') + header_txt.append('static bool32_t validate_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_mask, OBJECT_STATUS status_flag, VK_DBG_MSG_TYPE error_level, OBJECT_TRACK_ERROR error_code, char* fail_msg) {') + header_txt.append(' objNode *pTrav = pObjectHead[objType];') + header_txt.append(' while (pTrav) {') + header_txt.append(' if (pTrav->obj.pObj == pObj) {') + header_txt.append(' if ((pTrav->obj.status & status_mask) != status_flag) {') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "OBJECT VALIDATION WARNING: %s object %p: %s", string_VK_OBJECT_TYPE(objType), (void*)pObj, fail_msg);') + header_txt.append(' layerCbMsg(error_level, VK_VALIDATION_LEVEL_0, pObj, 0, error_code, "OBJTRACK", str);') + header_txt.append(' return VK_FALSE;') + header_txt.append(' }') + header_txt.append(' return VK_TRUE;') + header_txt.append(' }') + header_txt.append(' pTrav = pTrav->pNextObj;') + header_txt.append(' }') + header_txt.append(' if (objType != VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {') + header_txt.append(' // If we do not find it print an error') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "Unable to obtain status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') + header_txt.append(' }') + header_txt.append(' return VK_FALSE;') + header_txt.append('}') + header_txt.append('') + header_txt.append('static void validate_draw_state_flags(void* pObj) {') + header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_VIEWPORT_BOUND, OBJSTATUS_VIEWPORT_BOUND, VK_DBG_MSG_ERROR, OBJTRACK_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer");') + header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_RASTER_BOUND, OBJSTATUS_RASTER_BOUND, VK_DBG_MSG_ERROR, OBJTRACK_RASTER_NOT_BOUND, "Raster object not bound to this command buffer");') + header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_COLOR_BLEND_BOUND, OBJSTATUS_COLOR_BLEND_BOUND, VK_DBG_MSG_UNKNOWN, OBJTRACK_COLOR_BLEND_NOT_BOUND, "Color-blend object not bound to this command buffer");') + header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_DEPTH_STENCIL_BOUND, OBJSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_MSG_UNKNOWN, OBJTRACK_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");') + header_txt.append('}') + header_txt.append('') + header_txt.append('static void validate_memory_mapping_status(const VK_GPU_MEMORY* pMemRefs, uint32_t numRefs) {') + header_txt.append(' uint32_t i;') + header_txt.append(' for (i = 0; i < numRefs; i++) {') + header_txt.append(' if (pMemRefs[i]) {') + header_txt.append(' // If mem reference is in a presentable image memory list, skip the check of the GPU_MEMORY list') + header_txt.append(' if (!validate_status((void *)pMemRefs[i], VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY, OBJSTATUS_NONE, OBJSTATUS_NONE, VK_DBG_MSG_UNKNOWN, OBJTRACK_NONE, NULL) == VK_TRUE)') + header_txt.append(' {') + header_txt.append(' validate_status((void *)pMemRefs[i], VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED, OBJSTATUS_NONE, VK_DBG_MSG_ERROR, OBJTRACK_GPU_MEM_MAPPED, "A Mapped Memory Object was referenced in a command buffer");') + header_txt.append(' }') + header_txt.append(' }') + header_txt.append(' }') + header_txt.append('}') + header_txt.append('') + header_txt.append('static void validate_mem_ref_count(uint32_t numRefs) {') + header_txt.append(' if (maxMemReferences == 0) {') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "vkQueueSubmit called before calling vkGetGpuInfo");') + header_txt.append(' layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_GETGPUINFO_NOT_CALLED, "OBJTRACK", str);') + header_txt.append(' } else {') + header_txt.append(' if (numRefs > maxMemReferences) {') + header_txt.append(' char str[1024];') + header_txt.append(' sprintf(str, "vkQueueSubmit Memory reference count (%d) exceeds allowable GPU limit (%d)", numRefs, maxMemReferences);') + header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_MEMREFCOUNT_MAX_EXCEEDED, "OBJTRACK", str);') + header_txt.append(' }') + header_txt.append(' }') + header_txt.append('}') + header_txt.append('') + header_txt.append('static void setGpuQueueInfoState(void *pData) {') + header_txt.append(' maxMemReferences = ((VK_PHYSICAL_GPU_QUEUE_PROPERTIES *)pData)->maxMemReferences;') + header_txt.append('}') + return "\n".join(header_txt) + + def generate_intercept(self, proto, qual): + if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback' ]: + # use default version + return None + obj_type_mapping = {base_t : base_t.replace("VK_", "VK_OBJECT_TYPE_") for base_t in vulkan.object_type_list} + # For the various "super-types" we have to use function to distinguish sub type + for obj_type in ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT"]: + obj_type_mapping[obj_type] = "ll_get_obj_type(object)" + + decl = proto.c_func(prefix="vk", attr="VKAPI") + param0_name = proto.params[0].name + p0_type = proto.params[0].ty.strip('*').strip('const ') + create_line = '' + destroy_line = '' + funcs = [] + # Special cases for API funcs that don't use an object as first arg + if True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueAddMemReference', 'QueueRemoveMemReference', 'QueueWaitIdle', 'CreateDevice', 'GetGpuInfo', 'QueueSignalSemaphore', 'QueueWaitSemaphore', 'WsiX11QueuePresent']]: + using_line = '' + else: + using_line = ' loader_platform_thread_lock_mutex(&objLock);\n' + using_line += ' ll_increment_use_count((void*)%s, %s);\n' % (param0_name, obj_type_mapping[p0_type]) + using_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' + if 'QueueSubmit' in proto.name: + using_line += ' set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);\n' + using_line += ' // TODO: Fix for updated memory reference mechanism\n' + using_line += ' // validate_memory_mapping_status(pMemRefs, memRefCount);\n' + using_line += ' // validate_mem_ref_count(memRefCount);\n' + elif 'GetFenceStatus' in proto.name: + using_line += ' // Warn if submitted_flag is not set\n' + using_line += ' validate_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED, VK_DBG_MSG_ERROR, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");\n' + elif 'EndCommandBuffer' in proto.name: + using_line += ' reset_status((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND |\n' + using_line += ' OBJSTATUS_RASTER_BOUND |\n' + using_line += ' OBJSTATUS_COLOR_BLEND_BOUND |\n' + using_line += ' OBJSTATUS_DEPTH_STENCIL_BOUND));\n' + elif 'CmdBindDynamicStateObject' in proto.name: + using_line += ' track_object_status((void*)cmdBuffer, stateBindPoint);\n' + elif 'CmdDraw' in proto.name: + using_line += ' validate_draw_state_flags((void *)cmdBuffer);\n' + elif 'MapMemory' in proto.name: + using_line += ' set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n' + elif 'UnmapMemory' in proto.name: + using_line += ' reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n' + if 'AllocDescriptor' in proto.name: # Allocates array of DSs + create_line = ' for (uint32_t i = 0; i < *pCount; i++) {\n' + create_line += ' loader_platform_thread_lock_mutex(&objLock);\n' + create_line += ' ll_insert_obj((void*)pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);\n' + create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' + create_line += ' }\n' + elif 'CreatePresentableImage' in proto.name: + create_line = ' loader_platform_thread_lock_mutex(&objLock);\n' + create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-2].name, obj_type_mapping[proto.params[-2].ty.strip('*').strip('const ')]) + create_line += ' ll_insert_obj((void*)*pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' + # create_line += ' ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')]) + create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' + elif 'Create' in proto.name or 'Alloc' in proto.name: + create_line = ' loader_platform_thread_lock_mutex(&objLock);\n' + create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')]) + create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' + if 'DestroyObject' in proto.name: + destroy_line = ' loader_platform_thread_lock_mutex(&objLock);\n' + destroy_line += ' ll_destroy_obj((void*)%s);\n' % (param0_name) + destroy_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' + using_line = '' + else: + if 'Destroy' in proto.name or 'Free' in proto.name: + destroy_line = ' loader_platform_thread_lock_mutex(&objLock);\n' + destroy_line += ' ll_destroy_obj((void*)%s);\n' % (param0_name) + destroy_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' + using_line = '' + if 'DestroyDevice' in proto.name: + destroy_line += ' // Report any remaining objects in LL\n objNode *pTrav = pGlobalHead;\n while (pTrav) {\n' + destroy_line += ' if (pTrav->obj.objType == VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {\n' + destroy_line += ' objNode *pDel = pTrav;\n' + destroy_line += ' pTrav = pTrav->pNextGlobal;\n' + destroy_line += ' ll_destroy_obj((void*)(pDel->obj.pObj));\n' + destroy_line += ' } else {\n' + destroy_line += ' char str[1024];\n' + destroy_line += ' sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses);\n' + destroy_line += ' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK", str);\n' + destroy_line += ' pTrav = pTrav->pNextGlobal;\n' + destroy_line += ' }\n' + destroy_line += ' }\n' + ret_val = '' + stmt = '' + if proto.ret != "void": + ret_val = "VK_RESULT result = " + stmt = " return result;\n" + if 'WsiX11AssociateConnection' == proto.name: + funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") + if proto.name == "EnumerateLayers": + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' if (gpu != NULL) {\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' %s' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + ' %s%s' + ' %s' + ' } else {\n' + ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' + ' return VK_ERROR_INVALID_POINTER;\n' + ' // This layer compatible with all GPUs\n' + ' *pOutLayerCount = 1;\n' + ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' + ' return VK_SUCCESS;\n' + ' }\n' + '}' % (qual, decl, proto.params[0].name, using_line, self.layer_name, ret_val, c_call, create_line, destroy_line, stmt, self.layer_name)) + elif 'GetExtensionSupport' == proto.name: + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + funcs.append('%s%s\n' + '{\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + ' VK_RESULT result;\n' + ' /* This entrypoint is NOT going to init its own dispatch table since loader calls this early */\n' + ' if (!strncmp(pExtName, "%s", strlen("%s")) ||\n' + ' !strncmp(pExtName, "objTrackGetObjectCount", strlen("objTrackGetObjectCount")) ||\n' + ' !strncmp(pExtName, "objTrackGetObjects", strlen("objTrackGetObjects")))\n' + ' {\n' + ' result = VK_SUCCESS;\n' + ' } else if (nextTable.GetExtensionSupport != NULL)\n' + ' {\n' + ' %s' + ' result = nextTable.%s;\n' + ' } else\n' + ' {\n' + ' result = VK_ERROR_INVALID_EXTENSION;\n' + ' }\n' + '%s' + '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, using_line, c_call, stmt)) + elif proto.params[0].ty != "VK_PHYSICAL_GPU": + funcs.append('%s%s\n' + '{\n' + '%s' + ' %snextTable.%s;\n' + '%s%s' + '%s' + '}' % (qual, decl, using_line, ret_val, proto.c_call(), create_line, destroy_line, stmt)) + else: + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + gpu_state = '' + if 'GetGpuInfo' in proto.name: + gpu_state = ' if (infoType == VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES) {\n' + gpu_state += ' if (pData != NULL) {\n' + gpu_state += ' setGpuQueueInfoState(pData);\n' + gpu_state += ' }\n' + gpu_state += ' }\n' + funcs.append('%s%s\n' + '{\n' + ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' + '%s' + ' pCurObj = gpuw;\n' + ' loader_platform_thread_once(&tabOnce, init%s);\n' + ' %snextTable.%s;\n' + '%s%s' + '%s' + '%s' + '}' % (qual, decl, proto.params[0].name, using_line, self.layer_name, ret_val, c_call, create_line, destroy_line, gpu_state, stmt)) + if 'WsiX11QueuePresent' == proto.name: + funcs.append("#endif") + return "\n\n".join(funcs) + + def generate_body(self): + self.layer_name = "ObjectTracker" + body = [self._generate_layer_initialization(True, lockname='obj'), + self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), + self._generate_extensions(), + self._generate_layer_gpa_function(extensions=['objTrackGetObjectCount', 'objTrackGetObjects'])] + + return "\n\n".join(body) + +def main(): + subcommands = { + "layer-funcs" : LayerFuncsSubcommand, + "layer-dispatch" : LayerDispatchSubcommand, + "Generic" : GenericLayerSubcommand, + "ApiDump" : ApiDumpSubcommand, + "ApiDumpFile" : ApiDumpFileSubcommand, + "ApiDumpNoAddr" : ApiDumpNoAddrSubcommand, + "ApiDumpCpp" : ApiDumpCppSubcommand, + "ApiDumpNoAddrCpp" : ApiDumpNoAddrCppSubcommand, + "ObjectTracker" : ObjectTrackerSubcommand, + } + + if len(sys.argv) < 3 or sys.argv[1] not in subcommands or not os.path.exists(sys.argv[2]): + print("Usage: %s [options]" % sys.argv[0]) + print + print("Available subcommands are: %s" % " ".join(subcommands)) + exit(1) + + hfp = vk_helper.HeaderFileParser(sys.argv[2]) + hfp.parse() + vk_helper.enum_val_dict = hfp.get_enum_val_dict() + vk_helper.enum_type_dict = hfp.get_enum_type_dict() + vk_helper.struct_dict = hfp.get_struct_dict() + vk_helper.typedef_fwd_dict = hfp.get_typedef_fwd_dict() + vk_helper.typedef_rev_dict = hfp.get_typedef_rev_dict() + vk_helper.types_dict = hfp.get_types_dict() + + subcmd = subcommands[sys.argv[1]](sys.argv[2:]) + subcmd.run() + +if __name__ == "__main__": + main() diff --git a/vk_helper.py b/vk_helper.py index cee04700..33e13487 100755 --- a/vk_helper.py +++ b/vk_helper.py @@ -1612,7 +1612,7 @@ def main(argv=None): sw.generateStringHelperCpp() sw.set_no_addr(False) sw.generateStringHelperCpp() - sw.set_include_headers(["stdio.h", "stdlib.h", "xgl.h"]) + sw.set_include_headers(["stdio.h", "stdlib.h", "vulkan.h"]) sw.generateSizeHelper() sw.generateSizeHelperC() if opts.gen_cmake: diff --git a/vulkan.py b/vulkan.py new file mode 100755 index 00000000..6e30e45b --- /dev/null +++ b/vulkan.py @@ -0,0 +1,1034 @@ +"""VK API description""" + +# Copyright (C) 2014 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +# DEALINGS IN THE SOFTWARE. + +class Param(object): + """A function parameter.""" + + def __init__(self, ty, name): + self.ty = ty + self.name = name + + def c(self): + """Return the parameter in C.""" + idx = self.ty.find("[") + + # arrays have a different syntax + if idx >= 0: + return "%s %s%s" % (self.ty[:idx], self.name, self.ty[idx:]) + else: + return "%s %s" % (self.ty, self.name) + + def indirection_level(self): + """Return the level of indirection.""" + return self.ty.count("*") + self.ty.count("[") + + def dereferenced_type(self, level=0): + """Return the type after dereferencing.""" + if not level: + level = self.indirection_level() + + deref = self.ty if level else "" + while level > 0: + idx = deref.rfind("[") + if idx < 0: + idx = deref.rfind("*") + if idx < 0: + deref = "" + break + deref = deref[:idx] + level -= 1; + + return deref.rstrip() + + def __repr__(self): + return "Param(\"%s\", \"%s\")" % (self.ty, self.name) + +class Proto(object): + """A function prototype.""" + + def __init__(self, ret, name, params=[]): + # the proto has only a param + if not isinstance(params, list): + params = [params] + + self.ret = ret + self.name = name + self.params = params + + def c_params(self, need_type=True, need_name=True): + """Return the parameter list in C.""" + if self.params and (need_type or need_name): + if need_type and need_name: + return ", ".join([param.c() for param in self.params]) + elif need_type: + return ", ".join([param.ty for param in self.params]) + else: + return ", ".join([param.name for param in self.params]) + else: + return "void" if need_type else "" + + def c_decl(self, name, attr="", typed=False, need_param_names=True): + """Return a named declaration in C.""" + format_vals = (self.ret, + attr + " " if attr else "", + name, + self.c_params(need_name=need_param_names)) + + if typed: + return "%s (%s*%s)(%s)" % format_vals + else: + return "%s %s%s(%s)" % format_vals + + def c_pretty_decl(self, name, attr=""): + """Return a named declaration in C, with vulkan.h formatting.""" + plist = [] + for param in self.params: + idx = param.ty.find("[") + if idx < 0: + idx = len(param.ty) + + pad = 44 - idx + if pad <= 0: + pad = 1 + + plist.append(" %s%s%s%s" % (param.ty[:idx], + " " * pad, param.name, param.ty[idx:])) + + return "%s %s%s(\n%s)" % (self.ret, + attr + " " if attr else "", + name, + ",\n".join(plist)) + + def c_typedef(self, suffix="", attr=""): + """Return the typedef for the prototype in C.""" + return self.c_decl(self.name + suffix, attr=attr, typed=True) + + def c_func(self, prefix="", attr=""): + """Return the prototype in C.""" + return self.c_decl(prefix + self.name, attr=attr, typed=False) + + def c_call(self): + """Return a call to the prototype in C.""" + return "%s(%s)" % (self.name, self.c_params(need_type=False)) + + def object_in_params(self): + """Return the params that are simple VK objects and are inputs.""" + return [param for param in self.params if param.ty in objects] + + def object_out_params(self): + """Return the params that are simple VK objects and are outputs.""" + return [param for param in self.params + if param.dereferenced_type() in objects] + + def __repr__(self): + param_strs = [] + for param in self.params: + param_strs.append(str(param)) + param_str = " [%s]" % (",\n ".join(param_strs)) + + return "Proto(\"%s\", \"%s\",\n%s)" % \ + (self.ret, self.name, param_str) + +class Extension(object): + def __init__(self, name, headers, objects, protos): + self.name = name + self.headers = headers + self.objects = objects + self.protos = protos + + def __repr__(self): + lines = [] + lines.append("Extension(") + lines.append(" name=\"%s\"," % self.name) + lines.append(" headers=[\"%s\"]," % + "\", \"".join(self.headers)) + + lines.append(" objects=[") + for obj in self.objects: + lines.append(" \"%s\"," % obj) + lines.append(" ],") + + lines.append(" protos=[") + for proto in self.protos: + param_lines = str(proto).splitlines() + param_lines[-1] += ",\n" if proto != self.protos[-1] else "," + for p in param_lines: + lines.append(" " + p) + lines.append(" ],") + lines.append(")") + + return "\n".join(lines) + +# VK core API +core = Extension( + name="VK_CORE", + headers=["vulkan.h", "vkDbg.h"], + objects=[ + "VK_INSTANCE", + "VK_PHYSICAL_GPU", + "VK_BASE_OBJECT", + "VK_DEVICE", + "VK_QUEUE", + "VK_GPU_MEMORY", + "VK_OBJECT", + "VK_BUFFER", + "VK_BUFFER_VIEW", + "VK_IMAGE", + "VK_IMAGE_VIEW", + "VK_COLOR_ATTACHMENT_VIEW", + "VK_DEPTH_STENCIL_VIEW", + "VK_SHADER", + "VK_PIPELINE", + "VK_SAMPLER", + "VK_DESCRIPTOR_SET", + "VK_DESCRIPTOR_SET_LAYOUT", + "VK_DESCRIPTOR_SET_LAYOUT_CHAIN", + "VK_DESCRIPTOR_POOL", + "VK_DYNAMIC_STATE_OBJECT", + "VK_DYNAMIC_VP_STATE_OBJECT", + "VK_DYNAMIC_RS_STATE_OBJECT", + "VK_DYNAMIC_CB_STATE_OBJECT", + "VK_DYNAMIC_DS_STATE_OBJECT", + "VK_CMD_BUFFER", + "VK_FENCE", + "VK_SEMAPHORE", + "VK_EVENT", + "VK_QUERY_POOL", + "VK_FRAMEBUFFER", + "VK_RENDER_PASS", + ], + protos=[ + Proto("VK_RESULT", "CreateInstance", + [Param("const VK_INSTANCE_CREATE_INFO*", "pCreateInfo"), + Param("VK_INSTANCE*", "pInstance")]), + + Proto("VK_RESULT", "DestroyInstance", + [Param("VK_INSTANCE", "instance")]), + + Proto("VK_RESULT", "EnumerateGpus", + [Param("VK_INSTANCE", "instance"), + Param("uint32_t", "maxGpus"), + Param("uint32_t*", "pGpuCount"), + Param("VK_PHYSICAL_GPU*", "pGpus")]), + + Proto("VK_RESULT", "GetGpuInfo", + [Param("VK_PHYSICAL_GPU", "gpu"), + Param("VK_PHYSICAL_GPU_INFO_TYPE", "infoType"), + Param("size_t*", "pDataSize"), + Param("void*", "pData")]), + + Proto("void*", "GetProcAddr", + [Param("VK_PHYSICAL_GPU", "gpu"), + Param("const char*", "pName")]), + + Proto("VK_RESULT", "CreateDevice", + [Param("VK_PHYSICAL_GPU", "gpu"), + Param("const VK_DEVICE_CREATE_INFO*", "pCreateInfo"), + Param("VK_DEVICE*", "pDevice")]), + + Proto("VK_RESULT", "DestroyDevice", + [Param("VK_DEVICE", "device")]), + + Proto("VK_RESULT", "GetExtensionSupport", + [Param("VK_PHYSICAL_GPU", "gpu"), + Param("const char*", "pExtName")]), + + Proto("VK_RESULT", "EnumerateLayers", + [Param("VK_PHYSICAL_GPU", "gpu"), + Param("size_t", "maxLayerCount"), + Param("size_t", "maxStringSize"), + Param("size_t*", "pOutLayerCount"), + Param("char* const*", "pOutLayers"), + Param("void*", "pReserved")]), + + Proto("VK_RESULT", "GetDeviceQueue", + [Param("VK_DEVICE", "device"), + Param("uint32_t", "queueNodeIndex"), + Param("uint32_t", "queueIndex"), + Param("VK_QUEUE*", "pQueue")]), + + Proto("VK_RESULT", "QueueSubmit", + [Param("VK_QUEUE", "queue"), + Param("uint32_t", "cmdBufferCount"), + Param("const VK_CMD_BUFFER*", "pCmdBuffers"), + Param("VK_FENCE", "fence")]), + + Proto("VK_RESULT", "QueueAddMemReference", + [Param("VK_QUEUE", "queue"), + Param("VK_GPU_MEMORY", "mem")]), + + Proto("VK_RESULT", "QueueRemoveMemReference", + [Param("VK_QUEUE", "queue"), + Param("VK_GPU_MEMORY", "mem")]), + + Proto("VK_RESULT", "QueueWaitIdle", + [Param("VK_QUEUE", "queue")]), + + Proto("VK_RESULT", "DeviceWaitIdle", + [Param("VK_DEVICE", "device")]), + + Proto("VK_RESULT", "AllocMemory", + [Param("VK_DEVICE", "device"), + Param("const VK_MEMORY_ALLOC_INFO*", "pAllocInfo"), + Param("VK_GPU_MEMORY*", "pMem")]), + + Proto("VK_RESULT", "FreeMemory", + [Param("VK_GPU_MEMORY", "mem")]), + + Proto("VK_RESULT", "SetMemoryPriority", + [Param("VK_GPU_MEMORY", "mem"), + Param("VK_MEMORY_PRIORITY", "priority")]), + + Proto("VK_RESULT", "MapMemory", + [Param("VK_GPU_MEMORY", "mem"), + Param("VK_FLAGS", "flags"), + Param("void**", "ppData")]), + + Proto("VK_RESULT", "UnmapMemory", + [Param("VK_GPU_MEMORY", "mem")]), + + Proto("VK_RESULT", "PinSystemMemory", + [Param("VK_DEVICE", "device"), + Param("const void*", "pSysMem"), + Param("size_t", "memSize"), + Param("VK_GPU_MEMORY*", "pMem")]), + + Proto("VK_RESULT", "GetMultiGpuCompatibility", + [Param("VK_PHYSICAL_GPU", "gpu0"), + Param("VK_PHYSICAL_GPU", "gpu1"), + Param("VK_GPU_COMPATIBILITY_INFO*", "pInfo")]), + + Proto("VK_RESULT", "OpenSharedMemory", + [Param("VK_DEVICE", "device"), + Param("const VK_MEMORY_OPEN_INFO*", "pOpenInfo"), + Param("VK_GPU_MEMORY*", "pMem")]), + + Proto("VK_RESULT", "OpenSharedSemaphore", + [Param("VK_DEVICE", "device"), + Param("const VK_SEMAPHORE_OPEN_INFO*", "pOpenInfo"), + Param("VK_SEMAPHORE*", "pSemaphore")]), + + Proto("VK_RESULT", "OpenPeerMemory", + [Param("VK_DEVICE", "device"), + Param("const VK_PEER_MEMORY_OPEN_INFO*", "pOpenInfo"), + Param("VK_GPU_MEMORY*", "pMem")]), + + Proto("VK_RESULT", "OpenPeerImage", + [Param("VK_DEVICE", "device"), + Param("const VK_PEER_IMAGE_OPEN_INFO*", "pOpenInfo"), + Param("VK_IMAGE*", "pImage"), + Param("VK_GPU_MEMORY*", "pMem")]), + + Proto("VK_RESULT", "DestroyObject", + [Param("VK_OBJECT", "object")]), + + Proto("VK_RESULT", "GetObjectInfo", + [Param("VK_BASE_OBJECT", "object"), + Param("VK_OBJECT_INFO_TYPE", "infoType"), + Param("size_t*", "pDataSize"), + Param("void*", "pData")]), + + Proto("VK_RESULT", "BindObjectMemory", + [Param("VK_OBJECT", "object"), + Param("uint32_t", "allocationIdx"), + Param("VK_GPU_MEMORY", "mem"), + Param("VK_GPU_SIZE", "offset")]), + + Proto("VK_RESULT", "BindObjectMemoryRange", + [Param("VK_OBJECT", "object"), + Param("uint32_t", "allocationIdx"), + Param("VK_GPU_SIZE", "rangeOffset"), + Param("VK_GPU_SIZE", "rangeSize"), + Param("VK_GPU_MEMORY", "mem"), + Param("VK_GPU_SIZE", "memOffset")]), + + Proto("VK_RESULT", "BindImageMemoryRange", + [Param("VK_IMAGE", "image"), + Param("uint32_t", "allocationIdx"), + Param("const VK_IMAGE_MEMORY_BIND_INFO*", "bindInfo"), + Param("VK_GPU_MEMORY", "mem"), + Param("VK_GPU_SIZE", "memOffset")]), + + Proto("VK_RESULT", "CreateFence", + [Param("VK_DEVICE", "device"), + Param("const VK_FENCE_CREATE_INFO*", "pCreateInfo"), + Param("VK_FENCE*", "pFence")]), + + Proto("VK_RESULT", "ResetFences", + [Param("VK_DEVICE", "device"), + Param("uint32_t", "fenceCount"), + Param("VK_FENCE*", "pFences")]), + + Proto("VK_RESULT", "GetFenceStatus", + [Param("VK_FENCE", "fence")]), + + Proto("VK_RESULT", "WaitForFences", + [Param("VK_DEVICE", "device"), + Param("uint32_t", "fenceCount"), + Param("const VK_FENCE*", "pFences"), + Param("bool32_t", "waitAll"), + Param("uint64_t", "timeout")]), + + Proto("VK_RESULT", "CreateSemaphore", + [Param("VK_DEVICE", "device"), + Param("const VK_SEMAPHORE_CREATE_INFO*", "pCreateInfo"), + Param("VK_SEMAPHORE*", "pSemaphore")]), + + Proto("VK_RESULT", "QueueSignalSemaphore", + [Param("VK_QUEUE", "queue"), + Param("VK_SEMAPHORE", "semaphore")]), + + Proto("VK_RESULT", "QueueWaitSemaphore", + [Param("VK_QUEUE", "queue"), + Param("VK_SEMAPHORE", "semaphore")]), + + Proto("VK_RESULT", "CreateEvent", + [Param("VK_DEVICE", "device"), + Param("const VK_EVENT_CREATE_INFO*", "pCreateInfo"), + Param("VK_EVENT*", "pEvent")]), + + Proto("VK_RESULT", "GetEventStatus", + [Param("VK_EVENT", "event")]), + + Proto("VK_RESULT", "SetEvent", + [Param("VK_EVENT", "event")]), + + Proto("VK_RESULT", "ResetEvent", + [Param("VK_EVENT", "event")]), + + Proto("VK_RESULT", "CreateQueryPool", + [Param("VK_DEVICE", "device"), + Param("const VK_QUERY_POOL_CREATE_INFO*", "pCreateInfo"), + Param("VK_QUERY_POOL*", "pQueryPool")]), + + Proto("VK_RESULT", "GetQueryPoolResults", + [Param("VK_QUERY_POOL", "queryPool"), + Param("uint32_t", "startQuery"), + Param("uint32_t", "queryCount"), + Param("size_t*", "pDataSize"), + Param("void*", "pData")]), + + Proto("VK_RESULT", "GetFormatInfo", + [Param("VK_DEVICE", "device"), + Param("VK_FORMAT", "format"), + Param("VK_FORMAT_INFO_TYPE", "infoType"), + Param("size_t*", "pDataSize"), + Param("void*", "pData")]), + + Proto("VK_RESULT", "CreateBuffer", + [Param("VK_DEVICE", "device"), + Param("const VK_BUFFER_CREATE_INFO*", "pCreateInfo"), + Param("VK_BUFFER*", "pBuffer")]), + + Proto("VK_RESULT", "CreateBufferView", + [Param("VK_DEVICE", "device"), + Param("const VK_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"), + Param("VK_BUFFER_VIEW*", "pView")]), + + Proto("VK_RESULT", "CreateImage", + [Param("VK_DEVICE", "device"), + Param("const VK_IMAGE_CREATE_INFO*", "pCreateInfo"), + Param("VK_IMAGE*", "pImage")]), + + Proto("VK_RESULT", "GetImageSubresourceInfo", + [Param("VK_IMAGE", "image"), + Param("const VK_IMAGE_SUBRESOURCE*", "pSubresource"), + Param("VK_SUBRESOURCE_INFO_TYPE", "infoType"), + Param("size_t*", "pDataSize"), + Param("void*", "pData")]), + + Proto("VK_RESULT", "CreateImageView", + [Param("VK_DEVICE", "device"), + Param("const VK_IMAGE_VIEW_CREATE_INFO*", "pCreateInfo"), + Param("VK_IMAGE_VIEW*", "pView")]), + + Proto("VK_RESULT", "CreateColorAttachmentView", + [Param("VK_DEVICE", "device"), + Param("const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO*", "pCreateInfo"), + Param("VK_COLOR_ATTACHMENT_VIEW*", "pView")]), + + Proto("VK_RESULT", "CreateDepthStencilView", + [Param("VK_DEVICE", "device"), + Param("const VK_DEPTH_STENCIL_VIEW_CREATE_INFO*", "pCreateInfo"), + Param("VK_DEPTH_STENCIL_VIEW*", "pView")]), + + Proto("VK_RESULT", "CreateShader", + [Param("VK_DEVICE", "device"), + Param("const VK_SHADER_CREATE_INFO*", "pCreateInfo"), + Param("VK_SHADER*", "pShader")]), + + Proto("VK_RESULT", "CreateGraphicsPipeline", + [Param("VK_DEVICE", "device"), + Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"), + Param("VK_PIPELINE*", "pPipeline")]), + + Proto("VK_RESULT", "CreateGraphicsPipelineDerivative", + [Param("VK_DEVICE", "device"), + Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"), + Param("VK_PIPELINE", "basePipeline"), + Param("VK_PIPELINE*", "pPipeline")]), + + Proto("VK_RESULT", "CreateComputePipeline", + [Param("VK_DEVICE", "device"), + Param("const VK_COMPUTE_PIPELINE_CREATE_INFO*", "pCreateInfo"), + Param("VK_PIPELINE*", "pPipeline")]), + + Proto("VK_RESULT", "StorePipeline", + [Param("VK_PIPELINE", "pipeline"), + Param("size_t*", "pDataSize"), + Param("void*", "pData")]), + + Proto("VK_RESULT", "LoadPipeline", + [Param("VK_DEVICE", "device"), + Param("size_t", "dataSize"), + Param("const void*", "pData"), + Param("VK_PIPELINE*", "pPipeline")]), + + Proto("VK_RESULT", "LoadPipelineDerivative", + [Param("VK_DEVICE", "device"), + Param("size_t", "dataSize"), + Param("const void*", "pData"), + Param("VK_PIPELINE", "basePipeline"), + Param("VK_PIPELINE*", "pPipeline")]), + + Proto("VK_RESULT", "CreateSampler", + [Param("VK_DEVICE", "device"), + Param("const VK_SAMPLER_CREATE_INFO*", "pCreateInfo"), + Param("VK_SAMPLER*", "pSampler")]), + + Proto("VK_RESULT", "CreateDescriptorSetLayout", + [Param("VK_DEVICE", "device"), + Param("const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*", "pCreateInfo"), + Param("VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayout")]), + + Proto("VK_RESULT", "CreateDescriptorSetLayoutChain", + [Param("VK_DEVICE", "device"), + Param("uint32_t", "setLayoutArrayCount"), + Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayoutArray"), + Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN*", "pLayoutChain")]), + + Proto("VK_RESULT", "BeginDescriptorPoolUpdate", + [Param("VK_DEVICE", "device"), + Param("VK_DESCRIPTOR_UPDATE_MODE", "updateMode")]), + + Proto("VK_RESULT", "EndDescriptorPoolUpdate", + [Param("VK_DEVICE", "device"), + Param("VK_CMD_BUFFER", "cmd")]), + + Proto("VK_RESULT", "CreateDescriptorPool", + [Param("VK_DEVICE", "device"), + Param("VK_DESCRIPTOR_POOL_USAGE", "poolUsage"), + Param("uint32_t", "maxSets"), + Param("const VK_DESCRIPTOR_POOL_CREATE_INFO*", "pCreateInfo"), + Param("VK_DESCRIPTOR_POOL*", "pDescriptorPool")]), + + Proto("VK_RESULT", "ResetDescriptorPool", + [Param("VK_DESCRIPTOR_POOL", "descriptorPool")]), + + Proto("VK_RESULT", "AllocDescriptorSets", + [Param("VK_DESCRIPTOR_POOL", "descriptorPool"), + Param("VK_DESCRIPTOR_SET_USAGE", "setUsage"), + Param("uint32_t", "count"), + Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayouts"), + Param("VK_DESCRIPTOR_SET*", "pDescriptorSets"), + Param("uint32_t*", "pCount")]), + + Proto("void", "ClearDescriptorSets", + [Param("VK_DESCRIPTOR_POOL", "descriptorPool"), + Param("uint32_t", "count"), + Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets")]), + + Proto("void", "UpdateDescriptors", + [Param("VK_DESCRIPTOR_SET", "descriptorSet"), + Param("uint32_t", "updateCount"), + Param("const void**", "ppUpdateArray")]), + + Proto("VK_RESULT", "CreateDynamicViewportState", + [Param("VK_DEVICE", "device"), + Param("const VK_DYNAMIC_VP_STATE_CREATE_INFO*", "pCreateInfo"), + Param("VK_DYNAMIC_VP_STATE_OBJECT*", "pState")]), + + Proto("VK_RESULT", "CreateDynamicRasterState", + [Param("VK_DEVICE", "device"), + Param("const VK_DYNAMIC_RS_STATE_CREATE_INFO*", "pCreateInfo"), + Param("VK_DYNAMIC_RS_STATE_OBJECT*", "pState")]), + + Proto("VK_RESULT", "CreateDynamicColorBlendState", + [Param("VK_DEVICE", "device"), + Param("const VK_DYNAMIC_CB_STATE_CREATE_INFO*", "pCreateInfo"), + Param("VK_DYNAMIC_CB_STATE_OBJECT*", "pState")]), + + Proto("VK_RESULT", "CreateDynamicDepthStencilState", + [Param("VK_DEVICE", "device"), + Param("const VK_DYNAMIC_DS_STATE_CREATE_INFO*", "pCreateInfo"), + Param("VK_DYNAMIC_DS_STATE_OBJECT*", "pState")]), + + Proto("VK_RESULT", "CreateCommandBuffer", + [Param("VK_DEVICE", "device"), + Param("const VK_CMD_BUFFER_CREATE_INFO*", "pCreateInfo"), + Param("VK_CMD_BUFFER*", "pCmdBuffer")]), + + Proto("VK_RESULT", "BeginCommandBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("const VK_CMD_BUFFER_BEGIN_INFO*", "pBeginInfo")]), + + Proto("VK_RESULT", "EndCommandBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer")]), + + Proto("VK_RESULT", "ResetCommandBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer")]), + + Proto("void", "CmdBindPipeline", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + Param("VK_PIPELINE", "pipeline")]), + + Proto("void", "CmdBindDynamicStateObject", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_STATE_BIND_POINT", "stateBindPoint"), + Param("VK_DYNAMIC_STATE_OBJECT", "state")]), + + Proto("void", "CmdBindDescriptorSets", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN", "layoutChain"), + Param("uint32_t", "layoutChainSlot"), + Param("uint32_t", "count"), + Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets"), + Param("const uint32_t*", "pUserData")]), + + Proto("void", "CmdBindVertexBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "buffer"), + Param("VK_GPU_SIZE", "offset"), + Param("uint32_t", "binding")]), + + Proto("void", "CmdBindIndexBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "buffer"), + Param("VK_GPU_SIZE", "offset"), + Param("VK_INDEX_TYPE", "indexType")]), + + Proto("void", "CmdDraw", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("uint32_t", "firstVertex"), + Param("uint32_t", "vertexCount"), + Param("uint32_t", "firstInstance"), + Param("uint32_t", "instanceCount")]), + + Proto("void", "CmdDrawIndexed", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("uint32_t", "firstIndex"), + Param("uint32_t", "indexCount"), + Param("int32_t", "vertexOffset"), + Param("uint32_t", "firstInstance"), + Param("uint32_t", "instanceCount")]), + + Proto("void", "CmdDrawIndirect", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "buffer"), + Param("VK_GPU_SIZE", "offset"), + Param("uint32_t", "count"), + Param("uint32_t", "stride")]), + + Proto("void", "CmdDrawIndexedIndirect", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "buffer"), + Param("VK_GPU_SIZE", "offset"), + Param("uint32_t", "count"), + Param("uint32_t", "stride")]), + + Proto("void", "CmdDispatch", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("uint32_t", "x"), + Param("uint32_t", "y"), + Param("uint32_t", "z")]), + + Proto("void", "CmdDispatchIndirect", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "buffer"), + Param("VK_GPU_SIZE", "offset")]), + + Proto("void", "CmdCopyBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "srcBuffer"), + Param("VK_BUFFER", "destBuffer"), + Param("uint32_t", "regionCount"), + Param("const VK_BUFFER_COPY*", "pRegions")]), + + Proto("void", "CmdCopyImage", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_IMAGE", "srcImage"), + Param("VK_IMAGE_LAYOUT", "srcImageLayout"), + Param("VK_IMAGE", "destImage"), + Param("VK_IMAGE_LAYOUT", "destImageLayout"), + Param("uint32_t", "regionCount"), + Param("const VK_IMAGE_COPY*", "pRegions")]), + + Proto("void", "CmdBlitImage", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_IMAGE", "srcImage"), + Param("VK_IMAGE_LAYOUT", "srcImageLayout"), + Param("VK_IMAGE", "destImage"), + Param("VK_IMAGE_LAYOUT", "destImageLayout"), + Param("uint32_t", "regionCount"), + Param("const VK_IMAGE_BLIT*", "pRegions")]), + + Proto("void", "CmdCopyBufferToImage", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "srcBuffer"), + Param("VK_IMAGE", "destImage"), + Param("VK_IMAGE_LAYOUT", "destImageLayout"), + Param("uint32_t", "regionCount"), + Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]), + + Proto("void", "CmdCopyImageToBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_IMAGE", "srcImage"), + Param("VK_IMAGE_LAYOUT", "srcImageLayout"), + Param("VK_BUFFER", "destBuffer"), + Param("uint32_t", "regionCount"), + Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]), + + Proto("void", "CmdCloneImageData", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_IMAGE", "srcImage"), + Param("VK_IMAGE_LAYOUT", "srcImageLayout"), + Param("VK_IMAGE", "destImage"), + Param("VK_IMAGE_LAYOUT", "destImageLayout")]), + + Proto("void", "CmdUpdateBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "destBuffer"), + Param("VK_GPU_SIZE", "destOffset"), + Param("VK_GPU_SIZE", "dataSize"), + Param("const uint32_t*", "pData")]), + + Proto("void", "CmdFillBuffer", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_BUFFER", "destBuffer"), + Param("VK_GPU_SIZE", "destOffset"), + Param("VK_GPU_SIZE", "fillSize"), + Param("uint32_t", "data")]), + + Proto("void", "CmdClearColorImage", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_IMAGE", "image"), + Param("VK_IMAGE_LAYOUT", "imageLayout"), + Param("VK_CLEAR_COLOR", "color"), + Param("uint32_t", "rangeCount"), + Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]), + + Proto("void", "CmdClearDepthStencil", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_IMAGE", "image"), + Param("VK_IMAGE_LAYOUT", "imageLayout"), + Param("float", "depth"), + Param("uint32_t", "stencil"), + Param("uint32_t", "rangeCount"), + Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]), + + Proto("void", "CmdResolveImage", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_IMAGE", "srcImage"), + Param("VK_IMAGE_LAYOUT", "srcImageLayout"), + Param("VK_IMAGE", "destImage"), + Param("VK_IMAGE_LAYOUT", "destImageLayout"), + Param("uint32_t", "rectCount"), + Param("const VK_IMAGE_RESOLVE*", "pRects")]), + + Proto("void", "CmdSetEvent", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_EVENT", "event"), + Param("VK_PIPE_EVENT", "pipeEvent")]), + + Proto("void", "CmdResetEvent", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_EVENT", "event"), + Param("VK_PIPE_EVENT", "pipeEvent")]), + + Proto("void", "CmdWaitEvents", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("const VK_EVENT_WAIT_INFO*", "pWaitInfo")]), + + Proto("void", "CmdPipelineBarrier", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("const VK_PIPELINE_BARRIER*", "pBarrier")]), + + Proto("void", "CmdBeginQuery", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_QUERY_POOL", "queryPool"), + Param("uint32_t", "slot"), + Param("VK_FLAGS", "flags")]), + + Proto("void", "CmdEndQuery", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_QUERY_POOL", "queryPool"), + Param("uint32_t", "slot")]), + + Proto("void", "CmdResetQueryPool", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_QUERY_POOL", "queryPool"), + Param("uint32_t", "startQuery"), + Param("uint32_t", "queryCount")]), + + Proto("void", "CmdWriteTimestamp", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_TIMESTAMP_TYPE", "timestampType"), + Param("VK_BUFFER", "destBuffer"), + Param("VK_GPU_SIZE", "destOffset")]), + + Proto("void", "CmdInitAtomicCounters", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + Param("uint32_t", "startCounter"), + Param("uint32_t", "counterCount"), + Param("const uint32_t*", "pData")]), + + Proto("void", "CmdLoadAtomicCounters", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + Param("uint32_t", "startCounter"), + Param("uint32_t", "counterCount"), + Param("VK_BUFFER", "srcBuffer"), + Param("VK_GPU_SIZE", "srcOffset")]), + + Proto("void", "CmdSaveAtomicCounters", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + Param("uint32_t", "startCounter"), + Param("uint32_t", "counterCount"), + Param("VK_BUFFER", "destBuffer"), + Param("VK_GPU_SIZE", "destOffset")]), + + Proto("VK_RESULT", "CreateFramebuffer", + [Param("VK_DEVICE", "device"), + Param("const VK_FRAMEBUFFER_CREATE_INFO*", "pCreateInfo"), + Param("VK_FRAMEBUFFER*", "pFramebuffer")]), + + Proto("VK_RESULT", "CreateRenderPass", + [Param("VK_DEVICE", "device"), + Param("const VK_RENDER_PASS_CREATE_INFO*", "pCreateInfo"), + Param("VK_RENDER_PASS*", "pRenderPass")]), + + Proto("void", "CmdBeginRenderPass", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("const VK_RENDER_PASS_BEGIN*", "pRenderPassBegin")]), + + Proto("void", "CmdEndRenderPass", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("VK_RENDER_PASS", "renderPass")]), + + Proto("VK_RESULT", "DbgSetValidationLevel", + [Param("VK_DEVICE", "device"), + Param("VK_VALIDATION_LEVEL", "validationLevel")]), + + Proto("VK_RESULT", "DbgRegisterMsgCallback", + [Param("VK_INSTANCE", "instance"), + Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback"), + Param("void*", "pUserData")]), + + Proto("VK_RESULT", "DbgUnregisterMsgCallback", + [Param("VK_INSTANCE", "instance"), + Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback")]), + + Proto("VK_RESULT", "DbgSetMessageFilter", + [Param("VK_DEVICE", "device"), + Param("int32_t", "msgCode"), + Param("VK_DBG_MSG_FILTER", "filter")]), + + Proto("VK_RESULT", "DbgSetObjectTag", + [Param("VK_BASE_OBJECT", "object"), + Param("size_t", "tagSize"), + Param("const void*", "pTag")]), + + Proto("VK_RESULT", "DbgSetGlobalOption", + [Param("VK_INSTANCE", "instance"), + Param("VK_DBG_GLOBAL_OPTION", "dbgOption"), + Param("size_t", "dataSize"), + Param("const void*", "pData")]), + + Proto("VK_RESULT", "DbgSetDeviceOption", + [Param("VK_DEVICE", "device"), + Param("VK_DBG_DEVICE_OPTION", "dbgOption"), + Param("size_t", "dataSize"), + Param("const void*", "pData")]), + + Proto("void", "CmdDbgMarkerBegin", + [Param("VK_CMD_BUFFER", "cmdBuffer"), + Param("const char*", "pMarker")]), + + Proto("void", "CmdDbgMarkerEnd", + [Param("VK_CMD_BUFFER", "cmdBuffer")]), + ], +) + +wsi_x11 = Extension( + name="VK_WSI_X11", + headers=["vkWsiX11Ext.h"], + objects=[], + protos=[ + Proto("VK_RESULT", "WsiX11AssociateConnection", + [Param("VK_PHYSICAL_GPU", "gpu"), + Param("const VK_WSI_X11_CONNECTION_INFO*", "pConnectionInfo")]), + + Proto("VK_RESULT", "WsiX11GetMSC", + [Param("VK_DEVICE", "device"), + Param("xcb_window_t", "window"), + Param("xcb_randr_crtc_t", "crtc"), + Param("uint64_t*", "pMsc")]), + + Proto("VK_RESULT", "WsiX11CreatePresentableImage", + [Param("VK_DEVICE", "device"), + Param("const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO*", "pCreateInfo"), + Param("VK_IMAGE*", "pImage"), + Param("VK_GPU_MEMORY*", "pMem")]), + + Proto("VK_RESULT", "WsiX11QueuePresent", + [Param("VK_QUEUE", "queue"), + Param("const VK_WSI_X11_PRESENT_INFO*", "pPresentInfo"), + Param("VK_FENCE", "fence")]), + ], +) + +extensions = [core, wsi_x11] + +object_root_list = [ + "VK_INSTANCE", + "VK_PHYSICAL_GPU", + "VK_BASE_OBJECT" +] + +object_base_list = [ + "VK_DEVICE", + "VK_QUEUE", + "VK_GPU_MEMORY", + "VK_OBJECT" +] + +object_list = [ + "VK_BUFFER", + "VK_BUFFER_VIEW", + "VK_IMAGE", + "VK_IMAGE_VIEW", + "VK_COLOR_ATTACHMENT_VIEW", + "VK_DEPTH_STENCIL_VIEW", + "VK_SHADER", + "VK_PIPELINE", + "VK_SAMPLER", + "VK_DESCRIPTOR_SET", + "VK_DESCRIPTOR_SET_LAYOUT", + "VK_DESCRIPTOR_SET_LAYOUT_CHAIN", + "VK_DESCRIPTOR_POOL", + "VK_DYNAMIC_STATE_OBJECT", + "VK_CMD_BUFFER", + "VK_FENCE", + "VK_SEMAPHORE", + "VK_EVENT", + "VK_QUERY_POOL", + "VK_FRAMEBUFFER", + "VK_RENDER_PASS" +] + +object_dynamic_state_list = [ + "VK_DYNAMIC_VP_STATE_OBJECT", + "VK_DYNAMIC_RS_STATE_OBJECT", + "VK_DYNAMIC_CB_STATE_OBJECT", + "VK_DYNAMIC_DS_STATE_OBJECT" +] + +object_type_list = object_root_list + object_base_list + object_list + object_dynamic_state_list + +object_parent_list = ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT"] + +headers = [] +objects = [] +protos = [] +for ext in extensions: + headers.extend(ext.headers) + objects.extend(ext.objects) + protos.extend(ext.protos) + +proto_names = [proto.name for proto in protos] + +def parse_vk_h(filename): + # read object and protoype typedefs + object_lines = [] + proto_lines = [] + with open(filename, "r") as fp: + for line in fp: + line = line.strip() + if line.startswith("VK_DEFINE"): + begin = line.find("(") + 1 + end = line.find(",") + # extract the object type + object_lines.append(line[begin:end]) + if line.startswith("typedef") and line.endswith(");"): + # drop leading "typedef " and trailing ");" + proto_lines.append(line[8:-2]) + + # parse proto_lines to protos + protos = [] + for line in proto_lines: + first, rest = line.split(" (VKAPI *vk") + second, third = rest.split("Type)(") + + # get the return type, no space before "*" + proto_ret = "*".join([t.rstrip() for t in first.split("*")]) + + # get the name + proto_name = second.strip() + + # get the list of params + param_strs = third.split(", ") + params = [] + for s in param_strs: + ty, name = s.rsplit(" ", 1) + + # no space before "*" + ty = "*".join([t.rstrip() for t in ty.split("*")]) + # attach [] to ty + idx = name.rfind("[") + if idx >= 0: + ty += name[idx:] + name = name[:idx] + + params.append(Param(ty, name)) + + protos.append(Proto(proto_ret, proto_name, params)) + + # make them an extension and print + ext = Extension("VK_CORE", + headers=["vulkan.h", "vkDbg.h"], + objects=object_lines, + protos=protos) + print("core =", str(ext)) + + print("") + print("typedef struct _VK_LAYER_DISPATCH_TABLE") + print("{") + for proto in ext.protos: + print(" vk%sType %s;" % (proto.name, proto.name)) + print("} VK_LAYER_DISPATCH_TABLE;") + +if __name__ == "__main__": + parse_vk_h("include/vulkan.h") diff --git a/xgl-generate.py b/xgl-generate.py deleted file mode 100755 index 1a03d53c..00000000 --- a/xgl-generate.py +++ /dev/null @@ -1,484 +0,0 @@ -#!/usr/bin/env python3 -# -# VK -# -# Copyright (C) 2014 LunarG, Inc. -# -# Permission is hereby granted, free of charge, to any person obtaining a -# copy of this software and associated documentation files (the "Software"), -# to deal in the Software without restriction, including without limitation -# the rights to use, copy, modify, merge, publish, distribute, sublicense, -# and/or sell copies of the Software, and to permit persons to whom the -# Software is furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included -# in all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -# DEALINGS IN THE SOFTWARE. -# -# Authors: -# Chia-I Wu - -import sys - -import xgl - -def generate_get_proc_addr_check(name): - return " if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \ - " return NULL;" % ((name,) * 3) - -class Subcommand(object): - def __init__(self, argv): - self.argv = argv - self.headers = xgl.headers - self.protos = xgl.protos - - def run(self): - print(self.generate()) - - def generate(self): - copyright = self.generate_copyright() - header = self.generate_header() - body = self.generate_body() - footer = self.generate_footer() - - contents = [] - if copyright: - contents.append(copyright) - if header: - contents.append(header) - if body: - contents.append(body) - if footer: - contents.append(footer) - - return "\n\n".join(contents) - - def generate_copyright(self): - return """/* THIS FILE IS GENERATED. DO NOT EDIT. */ - -/* - * Vulkan - * - * Copyright (C) 2014 LunarG, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER - * DEALINGS IN THE SOFTWARE. - */""" - - def generate_header(self): - return "\n".join(["#include <" + h + ">" for h in self.headers]) - - def generate_body(self): - pass - - def generate_footer(self): - pass - -class LoaderEntrypointsSubcommand(Subcommand): - def generate_header(self): - return "#include \"loader.h\"" - - def _is_dispatchable(self, proto): - if proto.name in ["GetProcAddr", "DestroyInstance", "EnumerateGpus", - "EnumerateLayers", "DbgRegisterMsgCallback", "GetExtensionSupport", - "DbgUnregisterMsgCallback", "DbgSetGlobalOption"]: - return False - - in_objs = proto.object_in_params() - return in_objs and in_objs[0] == proto.params[0] - - def _generate_object_setup(self, proto): - method = "loader_init_data" - cond = "res == VK_SUCCESS" - - if "Get" in proto.name: - method = "loader_set_data" - - setup = [] - - if proto.name == "AllocDescriptorSets": - psets = proto.params[-2].name - pcount = proto.params[-1].name - setup.append("uint32_t i;") - setup.append("for (i = 0; i < *%s; i++)" % pcount) - setup.append(" %s(%s[i], disp);" % (method, psets)) - else: - obj_params = proto.object_out_params() - for param in obj_params: - setup.append("%s(*%s, disp);" % (method, param.name)) - - if setup: - joined = "\n ".join(setup) - setup = [] - setup.append(" if (%s) {" % cond) - setup.append(" " + joined) - setup.append(" }") - - return "\n".join(setup) - - def _generate_loader_dispatch_entrypoints(self, qual=""): - if qual: - qual += " " - - funcs = [] - for proto in self.protos: - if not self._is_dispatchable(proto): - continue - func = [] - - obj_setup = self._generate_object_setup(proto) - - func.append(qual + proto.c_func(prefix="vk", attr="VKAPI")) - func.append("{") - - # declare local variables - func.append(" const VK_LAYER_DISPATCH_TABLE *disp;") - if proto.ret != 'void' and obj_setup: - func.append(" VK_RESULT res;") - func.append("") - - # active layers before dispatching CreateDevice - if proto.name == "CreateDevice": - func.append(" loader_activate_layers(%s, %s);" % - (proto.params[0].name, proto.params[1].name)) - func.append("") - - # get dispatch table and unwrap GPUs - for param in proto.params: - stmt = "" - if param.ty == "VK_PHYSICAL_GPU": - stmt = "loader_unwrap_gpu(&%s);" % param.name - if param == proto.params[0]: - stmt = "disp = " + stmt - elif param == proto.params[0]: - stmt = "disp = loader_get_data(%s);" % param.name - - if stmt: - func.append(" " + stmt) - func.append("") - - # dispatch! - dispatch = "disp->%s;" % proto.c_call() - if proto.ret == 'void': - func.append(" " + dispatch) - elif not obj_setup: - func.append(" return " + dispatch) - else: - func.append(" res = " + dispatch) - func.append(obj_setup) - func.append("") - func.append(" return res;") - - func.append("}") - - if 'WsiX11AssociateConnection' == proto.name: - funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - - funcs.append("\n".join(func)) - - funcs.append("#endif") - return "\n\n".join(funcs) - - def generate_body(self): - body = [self._generate_loader_dispatch_entrypoints("LOADER_EXPORT")] - - return "\n\n".join(body) - -class DispatchTableOpsSubcommand(Subcommand): - def run(self): - if len(self.argv) != 1: - print("DispatchTableOpsSubcommand: unspecified") - return - - self.prefix = self.argv[0] - super().run() - - def generate_header(self): - return "\n".join(["#include ", - "#include ", - "#include ", - "#include \"loader_platform.h\""]) - - def _generate_init(self): - stmts = [] - for proto in self.protos: - if 'WsiX11AssociateConnection' == proto.name: - stmts.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - if proto.name == "GetProcAddr": - stmts.append("table->%s = gpa; /* direct assignment */" % - proto.name) - else: - stmts.append("table->%s = (vk%sType) gpa(gpu, \"vk%s\");" % - (proto.name, proto.name, proto.name)) - stmts.append("#endif") - - func = [] - func.append("static inline void %s_initialize_dispatch_table(VK_LAYER_DISPATCH_TABLE *table," - % self.prefix) - func.append("%s vkGetProcAddrType gpa," - % (" " * len(self.prefix))) - func.append("%s VK_PHYSICAL_GPU gpu)" - % (" " * len(self.prefix))) - func.append("{") - func.append(" %s" % "\n ".join(stmts)) - func.append("}") - - return "\n".join(func) - - def _generate_lookup(self): - lookups = [] - for proto in self.protos: - if 'WsiX11AssociateConnection' == proto.name: - lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - lookups.append("if (!strcmp(name, \"%s\"))" % (proto.name)) - lookups.append(" return (void *) table->%s;" - % (proto.name)) - lookups.append("#endif") - - func = [] - func.append("static inline void *%s_lookup_dispatch_table(const VK_LAYER_DISPATCH_TABLE *table," - % self.prefix) - func.append("%s const char *name)" - % (" " * len(self.prefix))) - func.append("{") - func.append(generate_get_proc_addr_check("name")) - func.append("") - func.append(" name += 2;") - func.append(" %s" % "\n ".join(lookups)) - func.append("") - func.append(" return NULL;") - func.append("}") - - return "\n".join(func) - - def generate_body(self): - body = [self._generate_init(), - self._generate_lookup()] - - return "\n\n".join(body) - -class IcdDummyEntrypointsSubcommand(Subcommand): - def run(self): - if len(self.argv) == 1: - self.prefix = self.argv[0] - self.qual = "static" - else: - self.prefix = "vk" - self.qual = "ICD_EXPORT" - - super().run() - - def generate_header(self): - return "#include \"icd.h\"" - - def _generate_stub_decl(self, proto): - return proto.c_pretty_decl(self.prefix + proto.name, attr="VKAPI") - - def _generate_stubs(self): - stubs = [] - for proto in self.protos: - decl = self._generate_stub_decl(proto) - if proto.ret != "void": - stmt = " return VK_ERROR_UNKNOWN;\n" - else: - stmt = "" - - stubs.append("%s %s\n{\n%s}" % (self.qual, decl, stmt)) - - return "\n\n".join(stubs) - - def generate_body(self): - return self._generate_stubs() - -class IcdGetProcAddrSubcommand(IcdDummyEntrypointsSubcommand): - def generate_header(self): - return "\n".join(["#include ", "#include \"icd.h\""]) - - def generate_body(self): - for proto in self.protos: - if proto.name == "GetProcAddr": - gpa_proto = proto - - gpa_decl = self._generate_stub_decl(gpa_proto) - gpa_pname = gpa_proto.params[-1].name - - lookups = [] - for proto in self.protos: - if 'WsiX11AssociateConnection' == proto.name: - lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - lookups.append("if (!strcmp(%s, \"%s\"))" % - (gpa_pname, proto.name)) - lookups.append(" return (%s) %s%s;" % - (gpa_proto.ret, self.prefix, proto.name)) - lookups.append("#endif") - - body = [] - body.append("%s %s" % (self.qual, gpa_decl)) - body.append("{") - body.append(generate_get_proc_addr_check(gpa_pname)) - body.append("") - body.append(" %s += 2;" % gpa_pname) - body.append(" %s" % "\n ".join(lookups)) - body.append("") - body.append(" return NULL;") - body.append("}") - - return "\n".join(body) - -class LayerInterceptProcSubcommand(Subcommand): - def run(self): - self.prefix = "vk" - - # we could get the list from argv if wanted - self.intercepted = [proto.name for proto in self.protos - if proto.name not in ["EnumerateGpus"]] - - for proto in self.protos: - if proto.name == "GetProcAddr": - self.gpa = proto - - super().run() - - def generate_header(self): - return "\n".join(["#include ", "#include \"vkLayer.h\""]) - - def generate_body(self): - lookups = [] - for proto in self.protos: - if proto.name not in self.intercepted: - lookups.append("/* no %s%s */" % (self.prefix, proto.name)) - continue - - if 'WsiX11AssociateConnection' == proto.name: - lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - lookups.append("if (!strcmp(name, \"%s\"))" % proto.name) - lookups.append(" return (%s) %s%s;" % - (self.gpa.ret, self.prefix, proto.name)) - lookups.append("#endif") - - body = [] - body.append("static inline %s layer_intercept_proc(const char *name)" % - self.gpa.ret) - body.append("{") - body.append(generate_get_proc_addr_check("name")) - body.append("") - body.append(" name += 2;") - body.append(" %s" % "\n ".join(lookups)) - body.append("") - body.append(" return NULL;") - body.append("}") - - return "\n".join(body) - -class WinDefFileSubcommand(Subcommand): - def run(self): - library_exports = { - "all": [], - "icd": [ - "EnumerateGpus", - "CreateInstance", - "DestroyInstance", - "GetProcAddr", - ], - "layer": [ - "GetProcAddr", - "EnumerateLayers", - ], - } - - if len(self.argv) != 2 or self.argv[1] not in library_exports: - print("WinDefFileSubcommand: {%s}" % - "|".join(library_exports.keys())) - return - - self.library = self.argv[0] - self.exports = library_exports[self.argv[1]] - - super().run() - - def generate_copyright(self): - return """; THIS FILE IS GENERATED. DO NOT EDIT. - -;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; Vulkan -; -; Copyright (C) 2015 LunarG, Inc. -; -; Permission is hereby granted, free of charge, to any person obtaining a -; copy of this software and associated documentation files (the "Software"), -; to deal in the Software without restriction, including without limitation -; the rights to use, copy, modify, merge, publish, distribute, sublicense, -; and/or sell copies of the Software, and to permit persons to whom the -; Software is furnished to do so, subject to the following conditions: -; -; The above copyright notice and this permission notice shall be included -; in all copies or substantial portions of the Software. -; -; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -; THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -; DEALINGS IN THE SOFTWARE. -;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;""" - - def generate_header(self): - return "; The following is required on Windows, for exporting symbols from the DLL" - - def generate_body(self): - body = [] - - body.append("LIBRARY " + self.library) - body.append("EXPORTS") - - for proto in self.protos: - if self.exports and proto.name not in self.exports: - continue - body.append(" vk" + proto.name) - - return "\n".join(body) - -def main(): - subcommands = { - "loader-entrypoints": LoaderEntrypointsSubcommand, - "dispatch-table-ops": DispatchTableOpsSubcommand, - "icd-dummy-entrypoints": IcdDummyEntrypointsSubcommand, - "icd-get-proc-addr": IcdGetProcAddrSubcommand, - "layer-intercept-proc": LayerInterceptProcSubcommand, - "win-def-file": WinDefFileSubcommand, - } - - if len(sys.argv) < 2 or sys.argv[1] not in subcommands: - print("Usage: %s [options]" % sys.argv[0]) - print - print("Available sucommands are: %s" % " ".join(subcommands)) - exit(1) - - subcmd = subcommands[sys.argv[1]](sys.argv[2:]) - subcmd.run() - -if __name__ == "__main__": - main() diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py deleted file mode 100755 index bf82d189..00000000 --- a/xgl-layer-generate.py +++ /dev/null @@ -1,1539 +0,0 @@ -#!/usr/bin/env python3 -# -# VK -# -# Copyright (C) 2014 LunarG, Inc. -# -# Permission is hereby granted, free of charge, to any person obtaining a -# copy of this software and associated documentation files (the "Software"), -# to deal in the Software without restriction, including without limitation -# the rights to use, copy, modify, merge, publish, distribute, sublicense, -# and/or sell copies of the Software, and to permit persons to whom the -# Software is furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included -# in all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -# DEALINGS IN THE SOFTWARE. -# -# Authors: -# Chia-I Wu - -import sys -import os - -import xgl -import vk_helper - -def generate_get_proc_addr_check(name): - return " if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \ - " return NULL;" % ((name,) * 3) - -class Subcommand(object): - def __init__(self, argv): - self.argv = argv - self.headers = xgl.headers - self.protos = xgl.protos - self.no_addr = False - self.layer_name = "" - - def run(self): - print(self.generate()) - - def generate(self): - copyright = self.generate_copyright() - header = self.generate_header() - body = self.generate_body() - footer = self.generate_footer() - - contents = [] - if copyright: - contents.append(copyright) - if header: - contents.append(header) - if body: - contents.append(body) - if footer: - contents.append(footer) - - return "\n\n".join(contents) - - def generate_copyright(self): - return """/* THIS FILE IS GENERATED. DO NOT EDIT. */ - -/* - * Vulkan - * - * Copyright (C) 2014 LunarG, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER - * DEALINGS IN THE SOFTWARE. - */""" - - def generate_header(self): - return "\n".join(["#include <" + h + ">" for h in self.headers]) - - def generate_body(self): - pass - - def generate_footer(self): - pass - - # Return set of printf '%' qualifier and input to that qualifier - def _get_printf_params(self, vk_type, name, output_param, cpp=False): - # TODO : Need ENUM and STRUCT checks here - if vk_helper.is_type(vk_type, 'enum'):#"_TYPE" in vk_type: # TODO : This should be generic ENUM check - return ("%s", "string_%s(%s)" % (vk_type.strip('const ').strip('*'), name)) - if "char*" == vk_type: - return ("%s", name) - if "uint64" in vk_type: - if '*' in vk_type: - return ("%lu", "*%s" % name) - return ("%lu", name) - if "size" in vk_type: - if '*' in vk_type: - return ("%zu", "*%s" % name) - return ("%zu", name) - if "float" in vk_type: - if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic) - if cpp: - return ("[%i, %i, %i, %i]", '"[" << %s[0] << "," << %s[1] << "," << %s[2] << "," << %s[3] << "]"' % (name, name, name, name)) - return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name)) - return ("%f", name) - if "bool" in vk_type or 'xcb_randr_crtc_t' in vk_type: - return ("%u", name) - if True in [t in vk_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]: - if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic) - if cpp: - return ("[%i, %i, %i, %i]", "%s[0] << %s[1] << %s[2] << %s[3]" % (name, name, name, name)) - return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name)) - if '*' in vk_type: - if 'pUserData' == name: - return ("%i", "((pUserData == 0) ? 0 : *(pUserData))") - return ("%i", "*(%s)" % name) - return ("%i", name) - # TODO : This is special-cased as there's only one "format" param currently and it's nice to expand it - if "VK_FORMAT" == vk_type: - if cpp: - return ("%p", "&%s" % name) - return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_CHANNEL_FORMAT(%s.channelFormat), string_VK_NUM_FORMAT(%s.numericFormat)" % (name, name)) - if output_param: - return ("%p", "(void*)*%s" % name) - if vk_helper.is_type(vk_type, 'struct') and '*' not in vk_type: - return ("%p", "(void*)(&%s)" % name) - return ("%p", "(void*)(%s)" % name) - - def _gen_layer_dbg_callback_register(self): - r_body = [] - r_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)') - r_body.append('{') - r_body.append(' // This layer intercepts callbacks') - r_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));') - r_body.append(' if (!pNewDbgFuncNode)') - r_body.append(' return VK_ERROR_OUT_OF_MEMORY;') - r_body.append(' pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;') - r_body.append(' pNewDbgFuncNode->pUserData = pUserData;') - r_body.append(' pNewDbgFuncNode->pNext = g_pDbgFunctionHead;') - r_body.append(' g_pDbgFunctionHead = pNewDbgFuncNode;') - r_body.append(' // force callbacks if DebugAction hasn\'t been set already other than initial value') - r_body.append(' if (g_actionIsDefault) {') - r_body.append(' g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;') - r_body.append(' }') - r_body.append(' VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);') - r_body.append(' return result;') - r_body.append('}') - return "\n".join(r_body) - - def _gen_layer_dbg_callback_unregister(self): - ur_body = [] - ur_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)') - ur_body.append('{') - ur_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;') - ur_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;') - ur_body.append(' while (pTrav) {') - ur_body.append(' if (pTrav->pfnMsgCallback == pfnMsgCallback) {') - ur_body.append(' pPrev->pNext = pTrav->pNext;') - ur_body.append(' if (g_pDbgFunctionHead == pTrav)') - ur_body.append(' g_pDbgFunctionHead = pTrav->pNext;') - ur_body.append(' free(pTrav);') - ur_body.append(' break;') - ur_body.append(' }') - ur_body.append(' pPrev = pTrav;') - ur_body.append(' pTrav = pTrav->pNext;') - ur_body.append(' }') - ur_body.append(' if (g_pDbgFunctionHead == NULL)') - ur_body.append(' {') - ur_body.append(' if (g_actionIsDefault)') - ur_body.append(' g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;') - ur_body.append(' else') - ur_body.append(' g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK;') - ur_body.append(' }') - ur_body.append(' VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);') - ur_body.append(' return result;') - ur_body.append('}') - return "\n".join(ur_body) - - def _gen_layer_get_extension_support(self, layer="Generic"): - ges_body = [] - ges_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)') - ges_body.append('{') - ges_body.append(' VK_RESULT result;') - ges_body.append(' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;') - ges_body.append('') - ges_body.append(' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */') - ges_body.append(' if (!strncmp(pExtName, "%s", strlen("%s")))' % (layer, layer)) - ges_body.append(' {') - ges_body.append(' result = VK_SUCCESS;') - ges_body.append(' } else if (nextTable.GetExtensionSupport != NULL)') - ges_body.append(' {') - ges_body.append(' result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);') - ges_body.append(' } else') - ges_body.append(' {') - ges_body.append(' result = VK_ERROR_INVALID_EXTENSION;') - ges_body.append(' }') - ges_body.append(' return result;') - ges_body.append('}') - return "\n".join(ges_body) - - def _generate_dispatch_entrypoints(self, qual=""): - if qual: - qual += " " - - funcs = [] - intercepted = [] - for proto in self.protos: - if proto.name != "GetProcAddr" and proto.name != "InitAndEnumerateGpus": - intercept = self.generate_intercept(proto, qual) - if intercept is None: - # fill in default intercept for certain entrypoints - if 'DbgRegisterMsgCallback' == proto.name: - intercept = self._gen_layer_dbg_callback_register() - elif 'DbgUnregisterMsgCallback' == proto.name: - intercept = self._gen_layer_dbg_callback_unregister() - elif 'GetExtensionSupport' == proto.name: - funcs.append(self._gen_layer_get_extension_support(self.layer_name)) - if intercept is not None: - funcs.append(intercept) - intercepted.append(proto) - - prefix="vk" - lookups = [] - for proto in intercepted: - if 'WsiX11' in proto.name: - lookups.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - lookups.append("if (!strcmp(name, \"%s\"))" % proto.name) - lookups.append(" return (void*) %s%s;" % - (prefix, proto.name)) - if 'WsiX11' in proto.name: - lookups.append("#endif") - - # add customized layer_intercept_proc - body = [] - body.append("static inline void* layer_intercept_proc(const char *name)") - body.append("{") - body.append(generate_get_proc_addr_check("name")) - body.append("") - body.append(" name += 2;") - body.append(" %s" % "\n ".join(lookups)) - body.append("") - body.append(" return NULL;") - body.append("}") - funcs.append("\n".join(body)) - return "\n\n".join(funcs) - - - def _generate_extensions(self): - exts = [] - exts.append('uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type)') - exts.append('{') - exts.append(' return (type == VK_OBJECT_TYPE_ANY) ? numTotalObjs : numObjs[type];') - exts.append('}') - exts.append('') - exts.append('VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray)') - exts.append('{') - exts.append(" // This bool flags if we're pulling all objs or just a single class of objs") - exts.append(' bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY);') - exts.append(' // Check the count first thing') - exts.append(' uint64_t maxObjCount = (bAllObjs) ? numTotalObjs : numObjs[type];') - exts.append(' if (objCount > maxObjCount) {') - exts.append(' char str[1024];') - exts.append(' sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_VK_OBJECT_TYPE(type));') - exts.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_OBJCOUNT_MAX_EXCEEDED, "OBJTRACK", str);') - exts.append(' return VK_ERROR_INVALID_VALUE;') - exts.append(' }') - exts.append(' objNode* pTrav = (bAllObjs) ? pGlobalHead : pObjectHead[type];') - exts.append(' for (uint64_t i = 0; i < objCount; i++) {') - exts.append(' if (!pTrav) {') - exts.append(' char str[1024];') - exts.append(' sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_VK_OBJECT_TYPE(type), maxObjCount, i, objCount);') - exts.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);') - exts.append(' return VK_ERROR_UNKNOWN;') - exts.append(' }') - exts.append(' memcpy(&pObjNodeArray[i], pTrav, sizeof(OBJTRACK_NODE));') - exts.append(' pTrav = (bAllObjs) ? pTrav->pNextGlobal : pTrav->pNextObj;') - exts.append(' }') - exts.append(' return VK_SUCCESS;') - exts.append('}') - - return "\n".join(exts) - - def _generate_layer_gpa_function(self, extensions=[]): - func_body = [] - func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)\n" - "{\n" - " VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;\n" - " void* addr;\n" - " if (gpu == NULL)\n" - " return NULL;\n" - " pCurObj = gpuw;\n" - " loader_platform_thread_once(&tabOnce, init%s);\n\n" - " addr = layer_intercept_proc(funcName);\n" - " if (addr)\n" - " return addr;" % self.layer_name) - - if 0 != len(extensions): - for ext_name in extensions: - func_body.append(' else if (!strncmp("%s", funcName, sizeof("%s")))\n' - ' return %s;' % (ext_name, ext_name, ext_name)) - func_body.append(" else {\n" - " if (gpuw->pGPA == NULL)\n" - " return NULL;\n" - " return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);\n" - " }\n" - "}\n") - return "\n".join(func_body) - - def _generate_layer_initialization(self, init_opts=False, prefix='vk', lockname=None): - func_body = ["#include \"vk_dispatch_table_helper.h\""] - func_body.append('static void init%s(void)\n' - '{\n' % self.layer_name) - if init_opts: - func_body.append(' const char *strOpt;') - func_body.append(' // initialize %s options' % self.layer_name) - func_body.append(' getLayerOptionEnum("%sReportLevel", (uint32_t *) &g_reportingLevel);' % self.layer_name) - func_body.append(' g_actionIsDefault = getLayerOptionEnum("%sDebugAction", (uint32_t *) &g_debugAction);' % self.layer_name) - func_body.append('') - func_body.append(' if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)') - func_body.append(' {') - func_body.append(' strOpt = getLayerOption("%sLogFilename");' % self.layer_name) - func_body.append(' if (strOpt)') - func_body.append(' {') - func_body.append(' g_logFile = fopen(strOpt, "w");') - func_body.append(' }') - func_body.append(' if (g_logFile == NULL)') - func_body.append(' g_logFile = stdout;') - func_body.append(' }') - func_body.append('') - func_body.append(' vkGetProcAddrType fpNextGPA;\n' - ' fpNextGPA = pCurObj->pGPA;\n' - ' assert(fpNextGPA);\n') - - func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);") - if lockname is not None: - func_body.append(" if (!%sLockInitialized)" % lockname) - func_body.append(" {") - func_body.append(" // TODO/TBD: Need to delete this mutex sometime. How???") - func_body.append(" loader_platform_thread_create_mutex(&%sLock);" % lockname) - func_body.append(" %sLockInitialized = 1;" % lockname) - func_body.append(" }") - func_body.append("}\n") - return "\n".join(func_body) - - def _generate_layer_initialization_with_lock(self, prefix='vk'): - func_body = ["#include \"vk_dispatch_table_helper.h\""] - func_body.append('static void init%s(void)\n' - '{\n' - ' vkGetProcAddrType fpNextGPA;\n' - ' fpNextGPA = pCurObj->pGPA;\n' - ' assert(fpNextGPA);\n' % self.layer_name); - - func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);\n") - func_body.append(" if (!printLockInitialized)") - func_body.append(" {") - func_body.append(" // TODO/TBD: Need to delete this mutex sometime. How???") - func_body.append(" loader_platform_thread_create_mutex(&printLock);") - func_body.append(" printLockInitialized = 1;") - func_body.append(" }") - func_body.append("}\n") - return "\n".join(func_body) - -class LayerFuncsSubcommand(Subcommand): - def generate_header(self): - return '#include \n#include "loader.h"' - - def generate_body(self): - return self._generate_dispatch_entrypoints("static") - -class LayerDispatchSubcommand(Subcommand): - def generate_header(self): - return '#include "layer_wrappers.h"' - - def generate_body(self): - return self._generate_layer_initialization() - -class GenericLayerSubcommand(Subcommand): - def generate_header(self): - return '#include \n#include \n#include \n#include "loader_platform.h"\n#include "vkLayer.h"\n//The following is #included again to catch certain OS-specific functions being used:\n#include "loader_platform.h"\n\n#include "layers_config.h"\n#include "layers_msg.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;\n\nstatic LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);' - - def generate_intercept(self, proto, qual): - if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback' , 'GetExtensionSupport']: - # use default version - return None - decl = proto.c_func(prefix="vk", attr="VKAPI") - param0_name = proto.params[0].name - ret_val = '' - stmt = '' - funcs = [] - if proto.ret != "void": - ret_val = "VK_RESULT result = " - stmt = " return result;\n" - if 'WsiX11AssociateConnection' == proto.name: - funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - if proto.name == "EnumerateLayers": - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' char str[1024];\n' - ' if (gpu != NULL) {\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' sprintf(str, "At start of layered %s\\n");\n' - ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - ' sprintf(str, "Completed layered %s\\n");\n' - ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n' - ' fflush(stdout);\n' - ' %s' - ' } else {\n' - ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' - ' return VK_ERROR_INVALID_POINTER;\n' - ' // This layer compatible with all GPUs\n' - ' *pOutLayerCount = 1;\n' - ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' - ' return VK_SUCCESS;\n' - ' }\n' - '}' % (qual, decl, proto.params[0].name, proto.name, self.layer_name, ret_val, c_call, proto.name, stmt, self.layer_name)) - elif proto.params[0].ty != "VK_PHYSICAL_GPU": - funcs.append('%s%s\n' - '{\n' - ' %snextTable.%s;\n' - '%s' - '}' % (qual, decl, ret_val, proto.c_call(), stmt)) - else: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' char str[1024];' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' sprintf(str, "At start of layered %s\\n");\n' - ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - ' sprintf(str, "Completed layered %s\\n");\n' - ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n' - ' fflush(stdout);\n' - '%s' - '}' % (qual, decl, proto.params[0].name, proto.name, self.layer_name, ret_val, c_call, proto.name, stmt)) - if 'WsiX11QueuePresent' == proto.name: - funcs.append("#endif") - return "\n\n".join(funcs) - - def generate_body(self): - self.layer_name = "Generic" - body = [self._generate_layer_initialization(True), - self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), - self._generate_layer_gpa_function()] - - return "\n\n".join(body) - -class ApiDumpSubcommand(Subcommand): - def generate_header(self): - header_txt = [] - header_txt.append('#include \n#include \n#include ') - header_txt.append('#include "loader_platform.h"') - header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper.h"\n') - header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') - header_txt.append('#include "loader_platform.h"') - header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') - header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') - header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') - header_txt.append('static int printLockInitialized = 0;') - header_txt.append('static loader_platform_thread_mutex printLock;\n') - header_txt.append('#define MAX_TID 513') - header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') - header_txt.append('static uint32_t maxTID = 0;') - header_txt.append('// Map actual TID to an index value and return that index') - header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') - header_txt.append('static uint32_t getTIDIndex() {') - header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') - header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') - header_txt.append(' if (tid == tidMapping[i])') - header_txt.append(' return i;') - header_txt.append(' }') - header_txt.append(" // Don't yet have mapping, set it and return newly set index") - header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') - header_txt.append(' tidMapping[maxTID++] = tid;') - header_txt.append(' assert(maxTID < MAX_TID);') - header_txt.append(' return retVal;') - header_txt.append('}') - return "\n".join(header_txt) - - def generate_intercept(self, proto, qual): - decl = proto.c_func(prefix="vk", attr="VKAPI") - param0_name = proto.params[0].name - ret_val = '' - stmt = '' - funcs = [] - sp_param_dict = {} # Store 'index' for struct param to print, or an name of binding "Count" param for array to print - create_params = 0 # Num of params at end of function that are created and returned as output values - if 'WsiX11CreatePresentableImage' in proto.name: - create_params = -2 - elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name: - create_params = -1 - if proto.ret != "void": - ret_val = "VK_RESULT result = " - stmt = " return result;\n" - f_open = '' - f_close = '' - if "File" in self.layer_name: - file_mode = "a" - if 'CreateDevice' in proto.name: - file_mode = "w" - f_open = 'loader_platform_thread_lock_mutex(&printLock);\n pOutFile = fopen(outFileName, "%s");\n ' % (file_mode) - log_func = 'fprintf(pOutFile, "t{%%u} vk%s(' % proto.name - f_close = '\n fclose(pOutFile);\n loader_platform_thread_unlock_mutex(&printLock);' - else: - f_open = 'loader_platform_thread_lock_mutex(&printLock);\n ' - log_func = 'printf("t{%%u} vk%s(' % proto.name - f_close = '\n loader_platform_thread_unlock_mutex(&printLock);' - print_vals = ', getTIDIndex()' - pindex = 0 - prev_count_name = '' - for p in proto.params: - cp = False - if 0 != create_params: - # If this is any of the N last params of the func, treat as output - for y in range(-1, create_params-1, -1): - if p.name == proto.params[y].name: - cp = True - (pft, pfi) = self._get_printf_params(p.ty, p.name, cp) - if self.no_addr and "%p" == pft: - (pft, pfi) = ("%s", '"addr"') - log_func += '%s = %s, ' % (p.name, pft) - print_vals += ', %s' % (pfi) - # Catch array inputs that are bound by a "Count" param - if prev_count_name != '' and (prev_count_name.strip('Count')[1:] in p.name or 'slotCount' == prev_count_name): - sp_param_dict[pindex] = prev_count_name - elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount': - sp_param_dict[pindex] = '*pCount' - elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').strip('const '), 'struct'): - sp_param_dict[pindex] = 'index' - pindex += 1 - if p.name.endswith('Count'): - if '*' in p.ty: - prev_count_name = "*%s" % p.name - else: - prev_count_name = p.name - else: - prev_count_name = '' - log_func = log_func.strip(', ') - if proto.ret != "void": - log_func += ') = %s\\n"' - print_vals += ', string_VK_RESULT(result)' - else: - log_func += ')\\n"' - log_func = '%s%s);' % (log_func, print_vals) - if len(sp_param_dict) > 0: - i_decl = False - log_func += '\n char *pTmpStr = "";' - for sp_index in sorted(sp_param_dict): - # TODO : Clean this if/else block up, too much duplicated code - if 'index' == sp_param_dict[sp_index]: - cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower()) - var_name = proto.params[sp_index].name - if proto.params[sp_index].name != 'color': - log_func += '\n if (%s) {' % (proto.params[sp_index].name) - else: - var_name = "&%s" % proto.params[sp_index].name - log_func += '\n pTmpStr = %s(%s, " ");' % (cis_print_func, var_name) - if "File" in self.layer_name: - if self.no_addr: - log_func += '\n fprintf(pOutFile, " %s (addr)\\n%%s\\n", pTmpStr);' % (var_name) - else: - log_func += '\n fprintf(pOutFile, " %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (var_name, var_name) - else: - if self.no_addr: - log_func += '\n printf(" %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) - else: - log_func += '\n printf(" %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, var_name) - log_func += '\n fflush(stdout);' - log_func += '\n free(pTmpStr);' - if proto.params[sp_index].name != 'color': - log_func += '\n }' - else: # should have a count value stored to iterate over array - if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'): - cis_print_func = 'pTmpStr = vk_print_%s(&%s[i], " ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name) - else: - cis_print_func = 'pTmpStr = (char*)malloc(32);\n sprintf(pTmpStr, " %%p", %s[i]);' % proto.params[sp_index].name - if not i_decl: - log_func += '\n uint32_t i;' - i_decl = True - log_func += '\n for (i = 0; i < %s; i++) {' % (sp_param_dict[sp_index]) - log_func += '\n %s' % (cis_print_func) - if "File" in self.layer_name: - if self.no_addr: - log_func += '\n fprintf(pOutFile, " %s[%%i] (addr)\\n%%s\\n", i, pTmpStr);' % (proto.params[sp_index].name) - else: - log_func += '\n fprintf(pOutFile, " %s[%%i] (%%p)\\n%%s\\n", i, (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) - else: - if self.no_addr: - log_func += '\n printf(" %s[%%i] (addr)\\n%%s\\n", i, pTmpStr);' % (proto.params[sp_index].name) - else: - log_func += '\n printf(" %s[%%i] (%%p)\\n%%s\\n", i, (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) - log_func += '\n fflush(stdout);' - log_func += '\n free(pTmpStr);\n }' - if 'WsiX11AssociateConnection' == proto.name: - funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - if proto.name == "EnumerateLayers": - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' if (gpu != NULL) {\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - ' %s %s %s\n' - ' %s' - ' } else {\n' - ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' - ' return VK_ERROR_INVALID_POINTER;\n' - ' // This layer compatible with all GPUs\n' - ' *pOutLayerCount = 1;\n' - ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' - ' return VK_SUCCESS;\n' - ' }\n' - '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call,f_open, log_func, f_close, stmt, self.layer_name)) - elif 'GetExtensionSupport' == proto.name: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' VK_RESULT result;\n' - ' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n' - ' if (!strncmp(pExtName, "%s", strlen("%s")))\n' - ' {\n' - ' result = VK_SUCCESS;\n' - ' } else if (nextTable.GetExtensionSupport != NULL)\n' - ' {\n' - ' result = nextTable.%s;\n' - ' %s %s %s\n' - ' } else\n' - ' {\n' - ' result = VK_ERROR_INVALID_EXTENSION;\n' - ' }\n' - '%s' - '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, c_call, f_open, log_func, f_close, stmt)) - elif proto.params[0].ty != "VK_PHYSICAL_GPU": - funcs.append('%s%s\n' - '{\n' - ' %snextTable.%s;\n' - ' %s%s%s\n' - '%s' - '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt)) - else: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - ' %s%s%s\n' - '%s' - '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call, f_open, log_func, f_close, stmt)) - if 'WsiX11QueuePresent' == proto.name: - funcs.append("#endif") - return "\n\n".join(funcs) - - def generate_body(self): - self.layer_name = "APIDump" - body = [self._generate_layer_initialization_with_lock(), - self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), - self._generate_layer_gpa_function()] - - return "\n\n".join(body) - -class ApiDumpCppSubcommand(Subcommand): - def generate_header(self): - header_txt = [] - header_txt.append('#include \n#include \n#include ') - header_txt.append('#include "loader_platform.h"') - header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_cpp.h"\n') - header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') - header_txt.append('#include "loader_platform.h"') - header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') - header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') - header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') - header_txt.append('static int printLockInitialized = 0;') - header_txt.append('static loader_platform_thread_mutex printLock;\n') - header_txt.append('#define MAX_TID 513') - header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') - header_txt.append('static uint32_t maxTID = 0;') - header_txt.append('// Map actual TID to an index value and return that index') - header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') - header_txt.append('static uint32_t getTIDIndex() {') - header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') - header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') - header_txt.append(' if (tid == tidMapping[i])') - header_txt.append(' return i;') - header_txt.append(' }') - header_txt.append(" // Don't yet have mapping, set it and return newly set index") - header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') - header_txt.append(' tidMapping[maxTID++] = tid;') - header_txt.append(' assert(maxTID < MAX_TID);') - header_txt.append(' return retVal;') - header_txt.append('}') - return "\n".join(header_txt) - - def generate_intercept(self, proto, qual): - decl = proto.c_func(prefix="vk", attr="VKAPI") - param0_name = proto.params[0].name - ret_val = '' - stmt = '' - funcs = [] - sp_param_dict = {} # Store 'index' for struct param to print, or an name of binding "Count" param for array to print - create_params = 0 # Num of params at end of function that are created and returned as output values - if 'WsiX11CreatePresentableImage' in proto.name or 'AllocDescriptorSets' in proto.name: - create_params = -2 - elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name: - create_params = -1 - if proto.ret != "void": - ret_val = "VK_RESULT result = " - stmt = " return result;\n" - f_open = '' - f_close = '' - if "File" in self.layer_name: - file_mode = "a" - if 'CreateDevice' in proto.name: - file_mode = "w" - f_open = 'loader_platform_thread_lock_mutex(&printLock);\n pOutFile = fopen(outFileName, "%s");\n ' % (file_mode) - log_func = 'fprintf(pOutFile, "t{%%u} vk%s(' % proto.name - f_close = '\n fclose(pOutFile);\n loader_platform_thread_unlock_mutex(&printLock);' - else: - f_open = 'loader_platform_thread_lock_mutex(&printLock);\n ' - log_func = 'cout << "t{" << getTIDIndex() << "} vk%s(' % proto.name - f_close = '\n loader_platform_thread_unlock_mutex(&printLock);' - pindex = 0 - prev_count_name = '' - for p in proto.params: - cp = False - if 0 != create_params: - # If this is any of the N last params of the func, treat as output - for y in range(-1, create_params-1, -1): - if p.name == proto.params[y].name: - cp = True - (pft, pfi) = self._get_printf_params(p.ty, p.name, cp, cpp=True) - if self.no_addr and "%p" == pft: - (pft, pfi) = ("%s", '"addr"') - log_func += '%s = " << %s << ", ' % (p.name, pfi) - #print_vals += ', %s' % (pfi) - if prev_count_name != '' and (prev_count_name.strip('Count')[1:] in p.name or 'slotCount' == prev_count_name): - sp_param_dict[pindex] = prev_count_name - elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount': - sp_param_dict[pindex] = '*pCount' - elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').strip('const '), 'struct'): - sp_param_dict[pindex] = 'index' - pindex += 1 - if p.name.endswith('Count'): - if '*' in p.ty: - prev_count_name = "*%s" % p.name - else: - prev_count_name = p.name - else: - prev_count_name = '' - log_func = log_func.strip(', ') - if proto.ret != "void": - log_func += ') = " << string_VK_RESULT((VK_RESULT)result) << endl' - #print_vals += ', string_VK_RESULT_CODE(result)' - else: - log_func += ')\\n"' - log_func += ';' - if len(sp_param_dict) > 0: - i_decl = False - log_func += '\n string tmp_str;' - for sp_index in sp_param_dict: - if 'index' == sp_param_dict[sp_index]: - cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower()) - var_name = proto.params[sp_index].name - if proto.params[sp_index].name != 'color': - log_func += '\n if (%s) {' % (proto.params[sp_index].name) - else: - var_name = '&%s' % (proto.params[sp_index].name) - log_func += '\n tmp_str = %s(%s, " ");' % (cis_print_func, var_name) - if "File" in self.layer_name: - if self.no_addr: - log_func += '\n fprintf(pOutFile, " %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) - else: - log_func += '\n fprintf(pOutFile, " %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, var_name) - else: - if self.no_addr: - #log_func += '\n printf(" %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) - log_func += '\n cout << " %s (addr)" << endl << tmp_str << endl;' % (proto.params[sp_index].name) - else: - #log_func += '\n printf(" %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) - log_func += '\n cout << " %s (" << %s << ")" << endl << tmp_str << endl;' % (proto.params[sp_index].name, var_name) - #log_func += '\n fflush(stdout);' - if proto.params[sp_index].name != 'color': - log_func += '\n }' - else: # We have a count value stored to iterate over an array - print_cast = '' - print_func = '' - if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'): - print_cast = '&' - print_func = 'vk_print_%s' % proto.params[sp_index].ty.strip('const ').strip('*').lower() - #cis_print_func = 'tmp_str = vk_print_%s(&%s[i], " ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name) -# TODO : Need to display this address as a string - else: - print_cast = '(void*)' - print_func = 'string_convert_helper' - #cis_print_func = 'tmp_str = string_convert_helper((void*)%s[i], " ");' % proto.params[sp_index].name - cis_print_func = 'tmp_str = %s(%s%s[i], " ");' % (print_func, print_cast, proto.params[sp_index].name) -# else: -# cis_print_func = '' - if not i_decl: - log_func += '\n uint32_t i;' - i_decl = True - log_func += '\n for (i = 0; i < %s; i++) {' % (sp_param_dict[sp_index]) - log_func += '\n %s' % (cis_print_func) - if "File" in self.layer_name: - if self.no_addr: - log_func += '\n fprintf(pOutFile, " %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) - else: - log_func += '\n fprintf(pOutFile, " %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) - else: - if self.no_addr: - #log_func += '\n printf(" %s (addr)\\n%%s\\n", pTmpStr);' % (proto.params[sp_index].name) - log_func += '\n cout << " %s[" << (uint32_t)i << "] (addr)" << endl << tmp_str << endl;' % (proto.params[sp_index].name) - else: - #log_func += '\n printf(" %s (%%p)\\n%%s\\n", (void*)%s, pTmpStr);' % (proto.params[sp_index].name, proto.params[sp_index].name) - #log_func += '\n cout << " %s[" << (uint32_t)i << "] (" << %s[i] << ")" << endl << tmp_str << endl;' % (proto.params[sp_index].name, proto.params[sp_index].name) - log_func += '\n cout << " %s[" << i << "] (" << %s%s[i] << ")" << endl << tmp_str << endl;' % (proto.params[sp_index].name, print_cast, proto.params[sp_index].name) - #log_func += '\n fflush(stdout);' - log_func += '\n }' - if 'WsiX11AssociateConnection' == proto.name: - funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - if proto.name == "EnumerateLayers": - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' if (gpu != NULL) {\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - ' %s %s %s\n' - ' %s' - ' } else {\n' - ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' - ' return VK_ERROR_INVALID_POINTER;\n' - ' // This layer compatible with all GPUs\n' - ' *pOutLayerCount = 1;\n' - ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' - ' return VK_SUCCESS;\n' - ' }\n' - '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call,f_open, log_func, f_close, stmt, self.layer_name)) - elif 'GetExtensionSupport' == proto.name: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' VK_RESULT result;\n' - ' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n' - ' if (!strncmp(pExtName, "%s", strlen("%s")))\n' - ' {\n' - ' result = VK_SUCCESS;\n' - ' } else if (nextTable.GetExtensionSupport != NULL)\n' - ' {\n' - ' result = nextTable.%s;\n' - ' %s %s %s\n' - ' } else\n' - ' {\n' - ' result = VK_ERROR_INVALID_EXTENSION;\n' - ' }\n' - '%s' - '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, c_call, f_open, log_func, f_close, stmt)) - elif proto.params[0].ty != "VK_PHYSICAL_GPU": - funcs.append('%s%s\n' - '{\n' - ' %snextTable.%s;\n' - ' %s%s%s\n' - '%s' - '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt)) - else: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - ' %s%s%s\n' - '%s' - '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call, f_open, log_func, f_close, stmt)) - if 'WsiX11QueuePresent' == proto.name: - funcs.append("#endif") - return "\n\n".join(funcs) - - def generate_body(self): - self.layer_name = "APIDumpCpp" - body = [self._generate_layer_initialization_with_lock(), - self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), - self._generate_layer_gpa_function()] - - return "\n\n".join(body) - -# subclass from ApiDumpSubcommand instead of Subcommand -class ApiDumpFileSubcommand(ApiDumpSubcommand): - def generate_header(self): - header_txt = [] - header_txt.append('#include \n#include \n#include ') - header_txt.append('#include "loader_platform.h"') - header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper.h"\n') - header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') - header_txt.append('#include "loader_platform.h"') - header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') - header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') - header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') - header_txt.append('static int printLockInitialized = 0;') - header_txt.append('static loader_platform_thread_mutex printLock;\n') - header_txt.append('#define MAX_TID 513') - header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') - header_txt.append('static uint32_t maxTID = 0;') - header_txt.append('// Map actual TID to an index value and return that index') - header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') - header_txt.append('static uint32_t getTIDIndex() {') - header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') - header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') - header_txt.append(' if (tid == tidMapping[i])') - header_txt.append(' return i;') - header_txt.append(' }') - header_txt.append(" // Don't yet have mapping, set it and return newly set index") - header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') - header_txt.append(' tidMapping[maxTID++] = tid;') - header_txt.append(' assert(maxTID < MAX_TID);') - header_txt.append(' return retVal;') - header_txt.append('}\n') - header_txt.append('static FILE* pOutFile;\nstatic char* outFileName = "vk_apidump.txt";') - return "\n".join(header_txt) - - def generate_body(self): - self.layer_name = "APIDumpFile" - body = [self._generate_layer_initialization_with_lock(), - self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), - self._generate_layer_gpa_function()] - - return "\n\n".join(body) - -# subclass from ApiDumpSubcommand instead of Subcommand -class ApiDumpNoAddrSubcommand(ApiDumpSubcommand): - def generate_header(self): - header_txt = [] - header_txt.append('#include \n#include \n#include ') - header_txt.append('#include "loader_platform.h"') - header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_no_addr.h"\n') - header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') - header_txt.append('#include "loader_platform.h"') - header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') - header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') - header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') - header_txt.append('static int printLockInitialized = 0;') - header_txt.append('static loader_platform_thread_mutex printLock;\n') - header_txt.append('#define MAX_TID 513') - header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') - header_txt.append('static uint32_t maxTID = 0;') - header_txt.append('// Map actual TID to an index value and return that index') - header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') - header_txt.append('static uint32_t getTIDIndex() {') - header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') - header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') - header_txt.append(' if (tid == tidMapping[i])') - header_txt.append(' return i;') - header_txt.append(' }') - header_txt.append(" // Don't yet have mapping, set it and return newly set index") - header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') - header_txt.append(' tidMapping[maxTID++] = tid;') - header_txt.append(' assert(maxTID < MAX_TID);') - header_txt.append(' return retVal;') - header_txt.append('}') - return "\n".join(header_txt) - - def generate_body(self): - self.layer_name = "APIDumpNoAddr" - self.no_addr = True - body = [self._generate_layer_initialization_with_lock(), - self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), - self._generate_layer_gpa_function()] - - return "\n\n".join(body) - -# subclass from ApiDumpCppSubcommand instead of Subcommand -class ApiDumpNoAddrCppSubcommand(ApiDumpCppSubcommand): - def generate_header(self): - header_txt = [] - header_txt.append('#include \n#include \n#include ') - header_txt.append('#include "loader_platform.h"') - header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_no_addr_cpp.h"\n') - header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') - header_txt.append('#include "loader_platform.h"') - header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;') - header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n') - header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') - header_txt.append('static int printLockInitialized = 0;') - header_txt.append('static loader_platform_thread_mutex printLock;\n') - header_txt.append('#define MAX_TID 513') - header_txt.append('static loader_platform_thread_id tidMapping[MAX_TID] = {0};') - header_txt.append('static uint32_t maxTID = 0;') - header_txt.append('// Map actual TID to an index value and return that index') - header_txt.append('// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs') - header_txt.append('static uint32_t getTIDIndex() {') - header_txt.append(' loader_platform_thread_id tid = loader_platform_get_thread_id();') - header_txt.append(' for (uint32_t i = 0; i < maxTID; i++) {') - header_txt.append(' if (tid == tidMapping[i])') - header_txt.append(' return i;') - header_txt.append(' }') - header_txt.append(" // Don't yet have mapping, set it and return newly set index") - header_txt.append(' uint32_t retVal = (uint32_t) maxTID;') - header_txt.append(' tidMapping[maxTID++] = tid;') - header_txt.append(' assert(maxTID < MAX_TID);') - header_txt.append(' return retVal;') - header_txt.append('}') - return "\n".join(header_txt) - - def generate_body(self): - self.layer_name = "APIDumpNoAddrCpp" - self.no_addr = True - body = [self._generate_layer_initialization_with_lock(), - self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), - self._generate_layer_gpa_function()] - - return "\n\n".join(body) - -class ObjectTrackerSubcommand(Subcommand): - def generate_header(self): - header_txt = [] - header_txt.append('#include \n#include \n#include \n#include "loader_platform.h"') - header_txt.append('#include "object_track.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;') - header_txt.append('// The following is #included again to catch certain OS-specific functions being used:') - header_txt.append('#include "loader_platform.h"') - header_txt.append('#include "layers_config.h"') - header_txt.append('#include "layers_msg.h"') - header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);') - header_txt.append('static long long unsigned int object_track_index = 0;') - header_txt.append('static int objLockInitialized = 0;') - header_txt.append('static loader_platform_thread_mutex objLock;') - header_txt.append('') - header_txt.append('// We maintain a "Global" list which links every object and a') - header_txt.append('// per-Object list which just links objects of a given type') - header_txt.append('// The object node has both pointers so the actual nodes are shared between the two lists') - header_txt.append('typedef struct _objNode {') - header_txt.append(' OBJTRACK_NODE obj;') - header_txt.append(' struct _objNode *pNextObj;') - header_txt.append(' struct _objNode *pNextGlobal;') - header_txt.append('} objNode;') - header_txt.append('static objNode *pObjectHead[VK_NUM_OBJECT_TYPE] = {0};') - header_txt.append('static objNode *pGlobalHead = NULL;') - header_txt.append('static uint64_t numObjs[VK_NUM_OBJECT_TYPE] = {0};') - header_txt.append('static uint64_t numTotalObjs = 0;') - header_txt.append('static uint32_t maxMemReferences = 0;') - header_txt.append('// Debug function to print global list and each individual object list') - header_txt.append('static void ll_print_lists()') - header_txt.append('{') - header_txt.append(' objNode* pTrav = pGlobalHead;') - header_txt.append(' printf("=====GLOBAL OBJECT LIST (%lu total objs):\\n", numTotalObjs);') - header_txt.append(' while (pTrav) {') - header_txt.append(' printf(" ObjNode (%p) w/ %s obj %p has pNextGlobal %p\\n", (void*)pTrav, string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextGlobal);') - header_txt.append(' pTrav = pTrav->pNextGlobal;') - header_txt.append(' }') - header_txt.append(' for (uint32_t i = 0; i < VK_NUM_OBJECT_TYPE; i++) {') - header_txt.append(' pTrav = pObjectHead[i];') - header_txt.append(' if (pTrav) {') - header_txt.append(' printf("=====%s OBJECT LIST (%lu objs):\\n", string_VK_OBJECT_TYPE(pTrav->obj.objType), numObjs[i]);') - header_txt.append(' while (pTrav) {') - header_txt.append(' printf(" ObjNode (%p) w/ %s obj %p has pNextObj %p\\n", (void*)pTrav, string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextObj);') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' }') - header_txt.append(' }') - header_txt.append('}') - header_txt.append('static void ll_insert_obj(void* pObj, VK_OBJECT_TYPE objType) {') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "OBJ[%llu] : CREATE %s object %p", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj);') - header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') - header_txt.append(' objNode* pNewObjNode = (objNode*)malloc(sizeof(objNode));') - header_txt.append(' pNewObjNode->obj.pObj = pObj;') - header_txt.append(' pNewObjNode->obj.objType = objType;') - header_txt.append(' pNewObjNode->obj.status = OBJSTATUS_NONE;') - header_txt.append(' pNewObjNode->obj.numUses = 0;') - header_txt.append(' // insert at front of global list') - header_txt.append(' pNewObjNode->pNextGlobal = pGlobalHead;') - header_txt.append(' pGlobalHead = pNewObjNode;') - header_txt.append(' // insert at front of object list') - header_txt.append(' pNewObjNode->pNextObj = pObjectHead[objType];') - header_txt.append(' pObjectHead[objType] = pNewObjNode;') - header_txt.append(' // increment obj counts') - header_txt.append(' numObjs[objType]++;') - header_txt.append(' numTotalObjs++;') - header_txt.append(' //sprintf(str, "OBJ_STAT : %lu total objs & %lu %s objs.", numTotalObjs, numObjs[objType], string_VK_OBJECT_TYPE(objType));') - header_txt.append(' if (0) ll_print_lists();') - header_txt.append('}') - header_txt.append('// Traverse global list and return type for given object') - header_txt.append('static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) {') - header_txt.append(' objNode *pTrav = pGlobalHead;') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == object)') - header_txt.append(' return pTrav->obj.objType;') - header_txt.append(' pTrav = pTrav->pNextGlobal;') - header_txt.append(' }') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "Attempting look-up on obj %p but it is NOT in the global list!", (void*)object);') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, OBJTRACK_MISSING_OBJECT, "OBJTRACK", str);') - header_txt.append(' return VK_OBJECT_TYPE_UNKNOWN;') - header_txt.append('}') - header_txt.append('#if 0') - header_txt.append('static uint64_t ll_get_obj_uses(void* pObj, VK_OBJECT_TYPE objType) {') - header_txt.append(' objNode *pTrav = pObjectHead[objType];') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' return pTrav->obj.numUses;') - header_txt.append(' }') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' return 0;') - header_txt.append('}') - header_txt.append('#endif') - header_txt.append('static void ll_increment_use_count(void* pObj, VK_OBJECT_TYPE objType) {') - header_txt.append(' objNode *pTrav = pObjectHead[objType];') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' pTrav->obj.numUses++;') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "OBJ[%llu] : USING %s object %p (%lu total uses)", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj, pTrav->obj.numUses);') - header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') - header_txt.append(' return;') - header_txt.append(' }') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' // If we do not find obj, insert it and then increment count') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_VK_OBJECT_TYPE(objType));') - header_txt.append(' layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') - header_txt.append('') - header_txt.append(' ll_insert_obj(pObj, objType);') - header_txt.append(' ll_increment_use_count(pObj, objType);') - header_txt.append('}') - header_txt.append('// We usually do not know Obj type when we destroy it so have to fetch') - header_txt.append('// Type from global list w/ ll_destroy_obj()') - header_txt.append('// and then do the full removal from both lists w/ ll_remove_obj_type()') - header_txt.append('static void ll_remove_obj_type(void* pObj, VK_OBJECT_TYPE objType) {') - header_txt.append(' objNode *pTrav = pObjectHead[objType];') - header_txt.append(' objNode *pPrev = pObjectHead[objType];') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' pPrev->pNextObj = pTrav->pNextObj;') - header_txt.append(' // update HEAD of Obj list as needed') - header_txt.append(' if (pObjectHead[objType] == pTrav)') - header_txt.append(' pObjectHead[objType] = pTrav->pNextObj;') - header_txt.append(' assert(numObjs[objType] > 0);') - header_txt.append(' numObjs[objType]--;') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "OBJ[%llu] : DESTROY %s object %p", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj);') - header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') - header_txt.append(' return;') - header_txt.append(' }') - header_txt.append(' pPrev = pTrav;') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_VK_OBJECT_TYPE(objType));') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);') - header_txt.append('}') - header_txt.append('// Parse global list to find obj type, then remove obj from obj type list, finally') - header_txt.append('// remove obj from global list') - header_txt.append('static void ll_destroy_obj(void* pObj) {') - header_txt.append(' objNode *pTrav = pGlobalHead;') - header_txt.append(' objNode *pPrev = pGlobalHead;') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' ll_remove_obj_type(pObj, pTrav->obj.objType);') - header_txt.append(' pPrev->pNextGlobal = pTrav->pNextGlobal;') - header_txt.append(' // update HEAD of global list if needed') - header_txt.append(' if (pGlobalHead == pTrav)') - header_txt.append(' pGlobalHead = pTrav->pNextGlobal;') - header_txt.append(' assert(numTotalObjs > 0);') - header_txt.append(' numTotalObjs--;') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "OBJ_STAT Removed %s obj %p that was used %lu times (%lu total objs remain & %lu %s objs).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses, numTotalObjs, numObjs[pTrav->obj.objType], string_VK_OBJECT_TYPE(pTrav->obj.objType));') - header_txt.append(' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);') - header_txt.append(' free(pTrav);') - header_txt.append(' return;') - header_txt.append(' }') - header_txt.append(' pPrev = pTrav;') - header_txt.append(' pTrav = pTrav->pNextGlobal;') - header_txt.append(' }') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "Unable to remove obj %p. Was it created? Has it already been destroyed?", pObj);') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_DESTROY_OBJECT_FAILED, "OBJTRACK", str);') - header_txt.append('}') - header_txt.append('// Set selected flag state for an object node') - header_txt.append('static void set_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {') - header_txt.append(' if (pObj != NULL) {') - header_txt.append(' objNode *pTrav = pObjectHead[objType];') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' pTrav->obj.status |= status_flag;') - header_txt.append(' return;') - header_txt.append(' }') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' // If we do not find it print an error') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') - header_txt.append(' }'); - header_txt.append('}') - header_txt.append('') - header_txt.append('// Track selected state for an object node') - header_txt.append('static void track_object_status(void* pObj, VK_STATE_BIND_POINT stateBindPoint) {') - header_txt.append(' objNode *pTrav = pObjectHead[VK_OBJECT_TYPE_CMD_BUFFER];') - header_txt.append('') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' if (stateBindPoint == VK_STATE_BIND_VIEWPORT) {') - header_txt.append(' pTrav->obj.status |= OBJSTATUS_VIEWPORT_BOUND;') - header_txt.append(' } else if (stateBindPoint == VK_STATE_BIND_RASTER) {') - header_txt.append(' pTrav->obj.status |= OBJSTATUS_RASTER_BOUND;') - header_txt.append(' } else if (stateBindPoint == VK_STATE_BIND_COLOR_BLEND) {') - header_txt.append(' pTrav->obj.status |= OBJSTATUS_COLOR_BLEND_BOUND;') - header_txt.append(' } else if (stateBindPoint == VK_STATE_BIND_DEPTH_STENCIL) {') - header_txt.append(' pTrav->obj.status |= OBJSTATUS_DEPTH_STENCIL_BOUND;') - header_txt.append(' }') - header_txt.append(' return;') - header_txt.append(' }') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' // If we do not find it print an error') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "Unable to track status for non-existent Command Buffer object %p", pObj);') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') - header_txt.append('}') - header_txt.append('') - header_txt.append('// Reset selected flag state for an object node') - header_txt.append('static void reset_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {') - header_txt.append(' objNode *pTrav = pObjectHead[objType];') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' pTrav->obj.status &= ~status_flag;') - header_txt.append(' return;') - header_txt.append(' }') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' // If we do not find it print an error') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') - header_txt.append('}') - header_txt.append('') - header_txt.append('// Check object status for selected flag state') - header_txt.append('static bool32_t validate_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_mask, OBJECT_STATUS status_flag, VK_DBG_MSG_TYPE error_level, OBJECT_TRACK_ERROR error_code, char* fail_msg) {') - header_txt.append(' objNode *pTrav = pObjectHead[objType];') - header_txt.append(' while (pTrav) {') - header_txt.append(' if (pTrav->obj.pObj == pObj) {') - header_txt.append(' if ((pTrav->obj.status & status_mask) != status_flag) {') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "OBJECT VALIDATION WARNING: %s object %p: %s", string_VK_OBJECT_TYPE(objType), (void*)pObj, fail_msg);') - header_txt.append(' layerCbMsg(error_level, VK_VALIDATION_LEVEL_0, pObj, 0, error_code, "OBJTRACK", str);') - header_txt.append(' return VK_FALSE;') - header_txt.append(' }') - header_txt.append(' return VK_TRUE;') - header_txt.append(' }') - header_txt.append(' pTrav = pTrav->pNextObj;') - header_txt.append(' }') - header_txt.append(' if (objType != VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {') - header_txt.append(' // If we do not find it print an error') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "Unable to obtain status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);') - header_txt.append(' }') - header_txt.append(' return VK_FALSE;') - header_txt.append('}') - header_txt.append('') - header_txt.append('static void validate_draw_state_flags(void* pObj) {') - header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_VIEWPORT_BOUND, OBJSTATUS_VIEWPORT_BOUND, VK_DBG_MSG_ERROR, OBJTRACK_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer");') - header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_RASTER_BOUND, OBJSTATUS_RASTER_BOUND, VK_DBG_MSG_ERROR, OBJTRACK_RASTER_NOT_BOUND, "Raster object not bound to this command buffer");') - header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_COLOR_BLEND_BOUND, OBJSTATUS_COLOR_BLEND_BOUND, VK_DBG_MSG_UNKNOWN, OBJTRACK_COLOR_BLEND_NOT_BOUND, "Color-blend object not bound to this command buffer");') - header_txt.append(' validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_DEPTH_STENCIL_BOUND, OBJSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_MSG_UNKNOWN, OBJTRACK_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");') - header_txt.append('}') - header_txt.append('') - header_txt.append('static void validate_memory_mapping_status(const VK_GPU_MEMORY* pMemRefs, uint32_t numRefs) {') - header_txt.append(' uint32_t i;') - header_txt.append(' for (i = 0; i < numRefs; i++) {') - header_txt.append(' if (pMemRefs[i]) {') - header_txt.append(' // If mem reference is in a presentable image memory list, skip the check of the GPU_MEMORY list') - header_txt.append(' if (!validate_status((void *)pMemRefs[i], VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY, OBJSTATUS_NONE, OBJSTATUS_NONE, VK_DBG_MSG_UNKNOWN, OBJTRACK_NONE, NULL) == VK_TRUE)') - header_txt.append(' {') - header_txt.append(' validate_status((void *)pMemRefs[i], VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED, OBJSTATUS_NONE, VK_DBG_MSG_ERROR, OBJTRACK_GPU_MEM_MAPPED, "A Mapped Memory Object was referenced in a command buffer");') - header_txt.append(' }') - header_txt.append(' }') - header_txt.append(' }') - header_txt.append('}') - header_txt.append('') - header_txt.append('static void validate_mem_ref_count(uint32_t numRefs) {') - header_txt.append(' if (maxMemReferences == 0) {') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "vkQueueSubmit called before calling vkGetGpuInfo");') - header_txt.append(' layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_GETGPUINFO_NOT_CALLED, "OBJTRACK", str);') - header_txt.append(' } else {') - header_txt.append(' if (numRefs > maxMemReferences) {') - header_txt.append(' char str[1024];') - header_txt.append(' sprintf(str, "vkQueueSubmit Memory reference count (%d) exceeds allowable GPU limit (%d)", numRefs, maxMemReferences);') - header_txt.append(' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_MEMREFCOUNT_MAX_EXCEEDED, "OBJTRACK", str);') - header_txt.append(' }') - header_txt.append(' }') - header_txt.append('}') - header_txt.append('') - header_txt.append('static void setGpuQueueInfoState(void *pData) {') - header_txt.append(' maxMemReferences = ((VK_PHYSICAL_GPU_QUEUE_PROPERTIES *)pData)->maxMemReferences;') - header_txt.append('}') - return "\n".join(header_txt) - - def generate_intercept(self, proto, qual): - if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback' ]: - # use default version - return None - obj_type_mapping = {base_t : base_t.replace("VK_", "VK_OBJECT_TYPE_") for base_t in xgl.object_type_list} - # For the various "super-types" we have to use function to distinguish sub type - for obj_type in ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT"]: - obj_type_mapping[obj_type] = "ll_get_obj_type(object)" - - decl = proto.c_func(prefix="vk", attr="VKAPI") - param0_name = proto.params[0].name - p0_type = proto.params[0].ty.strip('*').strip('const ') - create_line = '' - destroy_line = '' - funcs = [] - # Special cases for API funcs that don't use an object as first arg - if True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueAddMemReference', 'QueueRemoveMemReference', 'QueueWaitIdle', 'CreateDevice', 'GetGpuInfo', 'QueueSignalSemaphore', 'QueueWaitSemaphore', 'WsiX11QueuePresent']]: - using_line = '' - else: - using_line = ' loader_platform_thread_lock_mutex(&objLock);\n' - using_line += ' ll_increment_use_count((void*)%s, %s);\n' % (param0_name, obj_type_mapping[p0_type]) - using_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' - if 'QueueSubmit' in proto.name: - using_line += ' set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);\n' - using_line += ' // TODO: Fix for updated memory reference mechanism\n' - using_line += ' // validate_memory_mapping_status(pMemRefs, memRefCount);\n' - using_line += ' // validate_mem_ref_count(memRefCount);\n' - elif 'GetFenceStatus' in proto.name: - using_line += ' // Warn if submitted_flag is not set\n' - using_line += ' validate_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED, VK_DBG_MSG_ERROR, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");\n' - elif 'EndCommandBuffer' in proto.name: - using_line += ' reset_status((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND |\n' - using_line += ' OBJSTATUS_RASTER_BOUND |\n' - using_line += ' OBJSTATUS_COLOR_BLEND_BOUND |\n' - using_line += ' OBJSTATUS_DEPTH_STENCIL_BOUND));\n' - elif 'CmdBindDynamicStateObject' in proto.name: - using_line += ' track_object_status((void*)cmdBuffer, stateBindPoint);\n' - elif 'CmdDraw' in proto.name: - using_line += ' validate_draw_state_flags((void *)cmdBuffer);\n' - elif 'MapMemory' in proto.name: - using_line += ' set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n' - elif 'UnmapMemory' in proto.name: - using_line += ' reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n' - if 'AllocDescriptor' in proto.name: # Allocates array of DSs - create_line = ' for (uint32_t i = 0; i < *pCount; i++) {\n' - create_line += ' loader_platform_thread_lock_mutex(&objLock);\n' - create_line += ' ll_insert_obj((void*)pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);\n' - create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' - create_line += ' }\n' - elif 'CreatePresentableImage' in proto.name: - create_line = ' loader_platform_thread_lock_mutex(&objLock);\n' - create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-2].name, obj_type_mapping[proto.params[-2].ty.strip('*').strip('const ')]) - create_line += ' ll_insert_obj((void*)*pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' - # create_line += ' ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')]) - create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' - elif 'Create' in proto.name or 'Alloc' in proto.name: - create_line = ' loader_platform_thread_lock_mutex(&objLock);\n' - create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')]) - create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' - if 'DestroyObject' in proto.name: - destroy_line = ' loader_platform_thread_lock_mutex(&objLock);\n' - destroy_line += ' ll_destroy_obj((void*)%s);\n' % (param0_name) - destroy_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' - using_line = '' - else: - if 'Destroy' in proto.name or 'Free' in proto.name: - destroy_line = ' loader_platform_thread_lock_mutex(&objLock);\n' - destroy_line += ' ll_destroy_obj((void*)%s);\n' % (param0_name) - destroy_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' - using_line = '' - if 'DestroyDevice' in proto.name: - destroy_line += ' // Report any remaining objects in LL\n objNode *pTrav = pGlobalHead;\n while (pTrav) {\n' - destroy_line += ' if (pTrav->obj.objType == VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {\n' - destroy_line += ' objNode *pDel = pTrav;\n' - destroy_line += ' pTrav = pTrav->pNextGlobal;\n' - destroy_line += ' ll_destroy_obj((void*)(pDel->obj.pObj));\n' - destroy_line += ' } else {\n' - destroy_line += ' char str[1024];\n' - destroy_line += ' sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses);\n' - destroy_line += ' layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK", str);\n' - destroy_line += ' pTrav = pTrav->pNextGlobal;\n' - destroy_line += ' }\n' - destroy_line += ' }\n' - ret_val = '' - stmt = '' - if proto.ret != "void": - ret_val = "VK_RESULT result = " - stmt = " return result;\n" - if 'WsiX11AssociateConnection' == proto.name: - funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") - if proto.name == "EnumerateLayers": - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' if (gpu != NULL) {\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' %s' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - ' %s%s' - ' %s' - ' } else {\n' - ' if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n' - ' return VK_ERROR_INVALID_POINTER;\n' - ' // This layer compatible with all GPUs\n' - ' *pOutLayerCount = 1;\n' - ' strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n' - ' return VK_SUCCESS;\n' - ' }\n' - '}' % (qual, decl, proto.params[0].name, using_line, self.layer_name, ret_val, c_call, create_line, destroy_line, stmt, self.layer_name)) - elif 'GetExtensionSupport' == proto.name: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - funcs.append('%s%s\n' - '{\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' VK_RESULT result;\n' - ' /* This entrypoint is NOT going to init its own dispatch table since loader calls this early */\n' - ' if (!strncmp(pExtName, "%s", strlen("%s")) ||\n' - ' !strncmp(pExtName, "objTrackGetObjectCount", strlen("objTrackGetObjectCount")) ||\n' - ' !strncmp(pExtName, "objTrackGetObjects", strlen("objTrackGetObjects")))\n' - ' {\n' - ' result = VK_SUCCESS;\n' - ' } else if (nextTable.GetExtensionSupport != NULL)\n' - ' {\n' - ' %s' - ' result = nextTable.%s;\n' - ' } else\n' - ' {\n' - ' result = VK_ERROR_INVALID_EXTENSION;\n' - ' }\n' - '%s' - '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, using_line, c_call, stmt)) - elif proto.params[0].ty != "VK_PHYSICAL_GPU": - funcs.append('%s%s\n' - '{\n' - '%s' - ' %snextTable.%s;\n' - '%s%s' - '%s' - '}' % (qual, decl, using_line, ret_val, proto.c_call(), create_line, destroy_line, stmt)) - else: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) - gpu_state = '' - if 'GetGpuInfo' in proto.name: - gpu_state = ' if (infoType == VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES) {\n' - gpu_state += ' if (pData != NULL) {\n' - gpu_state += ' setGpuQueueInfoState(pData);\n' - gpu_state += ' }\n' - gpu_state += ' }\n' - funcs.append('%s%s\n' - '{\n' - ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - '%s' - ' pCurObj = gpuw;\n' - ' loader_platform_thread_once(&tabOnce, init%s);\n' - ' %snextTable.%s;\n' - '%s%s' - '%s' - '%s' - '}' % (qual, decl, proto.params[0].name, using_line, self.layer_name, ret_val, c_call, create_line, destroy_line, gpu_state, stmt)) - if 'WsiX11QueuePresent' == proto.name: - funcs.append("#endif") - return "\n\n".join(funcs) - - def generate_body(self): - self.layer_name = "ObjectTracker" - body = [self._generate_layer_initialization(True, lockname='obj'), - self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"), - self._generate_extensions(), - self._generate_layer_gpa_function(extensions=['objTrackGetObjectCount', 'objTrackGetObjects'])] - - return "\n\n".join(body) - -def main(): - subcommands = { - "layer-funcs" : LayerFuncsSubcommand, - "layer-dispatch" : LayerDispatchSubcommand, - "Generic" : GenericLayerSubcommand, - "ApiDump" : ApiDumpSubcommand, - "ApiDumpFile" : ApiDumpFileSubcommand, - "ApiDumpNoAddr" : ApiDumpNoAddrSubcommand, - "ApiDumpCpp" : ApiDumpCppSubcommand, - "ApiDumpNoAddrCpp" : ApiDumpNoAddrCppSubcommand, - "ObjectTracker" : ObjectTrackerSubcommand, - } - - if len(sys.argv) < 3 or sys.argv[1] not in subcommands or not os.path.exists(sys.argv[2]): - print("Usage: %s [options]" % sys.argv[0]) - print - print("Available subcommands are: %s" % " ".join(subcommands)) - exit(1) - - hfp = vk_helper.HeaderFileParser(sys.argv[2]) - hfp.parse() - vk_helper.enum_val_dict = hfp.get_enum_val_dict() - vk_helper.enum_type_dict = hfp.get_enum_type_dict() - vk_helper.struct_dict = hfp.get_struct_dict() - vk_helper.typedef_fwd_dict = hfp.get_typedef_fwd_dict() - vk_helper.typedef_rev_dict = hfp.get_typedef_rev_dict() - vk_helper.types_dict = hfp.get_types_dict() - - subcmd = subcommands[sys.argv[1]](sys.argv[2:]) - subcmd.run() - -if __name__ == "__main__": - main() diff --git a/xgl.py b/xgl.py deleted file mode 100755 index 861d4fee..00000000 --- a/xgl.py +++ /dev/null @@ -1,1034 +0,0 @@ -"""VK API description""" - -# Copyright (C) 2014 LunarG, Inc. -# -# Permission is hereby granted, free of charge, to any person obtaining a -# copy of this software and associated documentation files (the "Software"), -# to deal in the Software without restriction, including without limitation -# the rights to use, copy, modify, merge, publish, distribute, sublicense, -# and/or sell copies of the Software, and to permit persons to whom the -# Software is furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included -# in all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -# DEALINGS IN THE SOFTWARE. - -class Param(object): - """A function parameter.""" - - def __init__(self, ty, name): - self.ty = ty - self.name = name - - def c(self): - """Return the parameter in C.""" - idx = self.ty.find("[") - - # arrays have a different syntax - if idx >= 0: - return "%s %s%s" % (self.ty[:idx], self.name, self.ty[idx:]) - else: - return "%s %s" % (self.ty, self.name) - - def indirection_level(self): - """Return the level of indirection.""" - return self.ty.count("*") + self.ty.count("[") - - def dereferenced_type(self, level=0): - """Return the type after dereferencing.""" - if not level: - level = self.indirection_level() - - deref = self.ty if level else "" - while level > 0: - idx = deref.rfind("[") - if idx < 0: - idx = deref.rfind("*") - if idx < 0: - deref = "" - break - deref = deref[:idx] - level -= 1; - - return deref.rstrip() - - def __repr__(self): - return "Param(\"%s\", \"%s\")" % (self.ty, self.name) - -class Proto(object): - """A function prototype.""" - - def __init__(self, ret, name, params=[]): - # the proto has only a param - if not isinstance(params, list): - params = [params] - - self.ret = ret - self.name = name - self.params = params - - def c_params(self, need_type=True, need_name=True): - """Return the parameter list in C.""" - if self.params and (need_type or need_name): - if need_type and need_name: - return ", ".join([param.c() for param in self.params]) - elif need_type: - return ", ".join([param.ty for param in self.params]) - else: - return ", ".join([param.name for param in self.params]) - else: - return "void" if need_type else "" - - def c_decl(self, name, attr="", typed=False, need_param_names=True): - """Return a named declaration in C.""" - format_vals = (self.ret, - attr + " " if attr else "", - name, - self.c_params(need_name=need_param_names)) - - if typed: - return "%s (%s*%s)(%s)" % format_vals - else: - return "%s %s%s(%s)" % format_vals - - def c_pretty_decl(self, name, attr=""): - """Return a named declaration in C, with vulkan.h formatting.""" - plist = [] - for param in self.params: - idx = param.ty.find("[") - if idx < 0: - idx = len(param.ty) - - pad = 44 - idx - if pad <= 0: - pad = 1 - - plist.append(" %s%s%s%s" % (param.ty[:idx], - " " * pad, param.name, param.ty[idx:])) - - return "%s %s%s(\n%s)" % (self.ret, - attr + " " if attr else "", - name, - ",\n".join(plist)) - - def c_typedef(self, suffix="", attr=""): - """Return the typedef for the prototype in C.""" - return self.c_decl(self.name + suffix, attr=attr, typed=True) - - def c_func(self, prefix="", attr=""): - """Return the prototype in C.""" - return self.c_decl(prefix + self.name, attr=attr, typed=False) - - def c_call(self): - """Return a call to the prototype in C.""" - return "%s(%s)" % (self.name, self.c_params(need_type=False)) - - def object_in_params(self): - """Return the params that are simple VK objects and are inputs.""" - return [param for param in self.params if param.ty in objects] - - def object_out_params(self): - """Return the params that are simple VK objects and are outputs.""" - return [param for param in self.params - if param.dereferenced_type() in objects] - - def __repr__(self): - param_strs = [] - for param in self.params: - param_strs.append(str(param)) - param_str = " [%s]" % (",\n ".join(param_strs)) - - return "Proto(\"%s\", \"%s\",\n%s)" % \ - (self.ret, self.name, param_str) - -class Extension(object): - def __init__(self, name, headers, objects, protos): - self.name = name - self.headers = headers - self.objects = objects - self.protos = protos - - def __repr__(self): - lines = [] - lines.append("Extension(") - lines.append(" name=\"%s\"," % self.name) - lines.append(" headers=[\"%s\"]," % - "\", \"".join(self.headers)) - - lines.append(" objects=[") - for obj in self.objects: - lines.append(" \"%s\"," % obj) - lines.append(" ],") - - lines.append(" protos=[") - for proto in self.protos: - param_lines = str(proto).splitlines() - param_lines[-1] += ",\n" if proto != self.protos[-1] else "," - for p in param_lines: - lines.append(" " + p) - lines.append(" ],") - lines.append(")") - - return "\n".join(lines) - -# VK core API -core = Extension( - name="VK_CORE", - headers=["vulkan.h", "xglDbg.h"], - objects=[ - "VK_INSTANCE", - "VK_PHYSICAL_GPU", - "VK_BASE_OBJECT", - "VK_DEVICE", - "VK_QUEUE", - "VK_GPU_MEMORY", - "VK_OBJECT", - "VK_BUFFER", - "VK_BUFFER_VIEW", - "VK_IMAGE", - "VK_IMAGE_VIEW", - "VK_COLOR_ATTACHMENT_VIEW", - "VK_DEPTH_STENCIL_VIEW", - "VK_SHADER", - "VK_PIPELINE", - "VK_SAMPLER", - "VK_DESCRIPTOR_SET", - "VK_DESCRIPTOR_SET_LAYOUT", - "VK_DESCRIPTOR_SET_LAYOUT_CHAIN", - "VK_DESCRIPTOR_POOL", - "VK_DYNAMIC_STATE_OBJECT", - "VK_DYNAMIC_VP_STATE_OBJECT", - "VK_DYNAMIC_RS_STATE_OBJECT", - "VK_DYNAMIC_CB_STATE_OBJECT", - "VK_DYNAMIC_DS_STATE_OBJECT", - "VK_CMD_BUFFER", - "VK_FENCE", - "VK_SEMAPHORE", - "VK_EVENT", - "VK_QUERY_POOL", - "VK_FRAMEBUFFER", - "VK_RENDER_PASS", - ], - protos=[ - Proto("VK_RESULT", "CreateInstance", - [Param("const VK_INSTANCE_CREATE_INFO*", "pCreateInfo"), - Param("VK_INSTANCE*", "pInstance")]), - - Proto("VK_RESULT", "DestroyInstance", - [Param("VK_INSTANCE", "instance")]), - - Proto("VK_RESULT", "EnumerateGpus", - [Param("VK_INSTANCE", "instance"), - Param("uint32_t", "maxGpus"), - Param("uint32_t*", "pGpuCount"), - Param("VK_PHYSICAL_GPU*", "pGpus")]), - - Proto("VK_RESULT", "GetGpuInfo", - [Param("VK_PHYSICAL_GPU", "gpu"), - Param("VK_PHYSICAL_GPU_INFO_TYPE", "infoType"), - Param("size_t*", "pDataSize"), - Param("void*", "pData")]), - - Proto("void*", "GetProcAddr", - [Param("VK_PHYSICAL_GPU", "gpu"), - Param("const char*", "pName")]), - - Proto("VK_RESULT", "CreateDevice", - [Param("VK_PHYSICAL_GPU", "gpu"), - Param("const VK_DEVICE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DEVICE*", "pDevice")]), - - Proto("VK_RESULT", "DestroyDevice", - [Param("VK_DEVICE", "device")]), - - Proto("VK_RESULT", "GetExtensionSupport", - [Param("VK_PHYSICAL_GPU", "gpu"), - Param("const char*", "pExtName")]), - - Proto("VK_RESULT", "EnumerateLayers", - [Param("VK_PHYSICAL_GPU", "gpu"), - Param("size_t", "maxLayerCount"), - Param("size_t", "maxStringSize"), - Param("size_t*", "pOutLayerCount"), - Param("char* const*", "pOutLayers"), - Param("void*", "pReserved")]), - - Proto("VK_RESULT", "GetDeviceQueue", - [Param("VK_DEVICE", "device"), - Param("uint32_t", "queueNodeIndex"), - Param("uint32_t", "queueIndex"), - Param("VK_QUEUE*", "pQueue")]), - - Proto("VK_RESULT", "QueueSubmit", - [Param("VK_QUEUE", "queue"), - Param("uint32_t", "cmdBufferCount"), - Param("const VK_CMD_BUFFER*", "pCmdBuffers"), - Param("VK_FENCE", "fence")]), - - Proto("VK_RESULT", "QueueAddMemReference", - [Param("VK_QUEUE", "queue"), - Param("VK_GPU_MEMORY", "mem")]), - - Proto("VK_RESULT", "QueueRemoveMemReference", - [Param("VK_QUEUE", "queue"), - Param("VK_GPU_MEMORY", "mem")]), - - Proto("VK_RESULT", "QueueWaitIdle", - [Param("VK_QUEUE", "queue")]), - - Proto("VK_RESULT", "DeviceWaitIdle", - [Param("VK_DEVICE", "device")]), - - Proto("VK_RESULT", "AllocMemory", - [Param("VK_DEVICE", "device"), - Param("const VK_MEMORY_ALLOC_INFO*", "pAllocInfo"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "FreeMemory", - [Param("VK_GPU_MEMORY", "mem")]), - - Proto("VK_RESULT", "SetMemoryPriority", - [Param("VK_GPU_MEMORY", "mem"), - Param("VK_MEMORY_PRIORITY", "priority")]), - - Proto("VK_RESULT", "MapMemory", - [Param("VK_GPU_MEMORY", "mem"), - Param("VK_FLAGS", "flags"), - Param("void**", "ppData")]), - - Proto("VK_RESULT", "UnmapMemory", - [Param("VK_GPU_MEMORY", "mem")]), - - Proto("VK_RESULT", "PinSystemMemory", - [Param("VK_DEVICE", "device"), - Param("const void*", "pSysMem"), - Param("size_t", "memSize"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "GetMultiGpuCompatibility", - [Param("VK_PHYSICAL_GPU", "gpu0"), - Param("VK_PHYSICAL_GPU", "gpu1"), - Param("VK_GPU_COMPATIBILITY_INFO*", "pInfo")]), - - Proto("VK_RESULT", "OpenSharedMemory", - [Param("VK_DEVICE", "device"), - Param("const VK_MEMORY_OPEN_INFO*", "pOpenInfo"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "OpenSharedSemaphore", - [Param("VK_DEVICE", "device"), - Param("const VK_SEMAPHORE_OPEN_INFO*", "pOpenInfo"), - Param("VK_SEMAPHORE*", "pSemaphore")]), - - Proto("VK_RESULT", "OpenPeerMemory", - [Param("VK_DEVICE", "device"), - Param("const VK_PEER_MEMORY_OPEN_INFO*", "pOpenInfo"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "OpenPeerImage", - [Param("VK_DEVICE", "device"), - Param("const VK_PEER_IMAGE_OPEN_INFO*", "pOpenInfo"), - Param("VK_IMAGE*", "pImage"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "DestroyObject", - [Param("VK_OBJECT", "object")]), - - Proto("VK_RESULT", "GetObjectInfo", - [Param("VK_BASE_OBJECT", "object"), - Param("VK_OBJECT_INFO_TYPE", "infoType"), - Param("size_t*", "pDataSize"), - Param("void*", "pData")]), - - Proto("VK_RESULT", "BindObjectMemory", - [Param("VK_OBJECT", "object"), - Param("uint32_t", "allocationIdx"), - Param("VK_GPU_MEMORY", "mem"), - Param("VK_GPU_SIZE", "offset")]), - - Proto("VK_RESULT", "BindObjectMemoryRange", - [Param("VK_OBJECT", "object"), - Param("uint32_t", "allocationIdx"), - Param("VK_GPU_SIZE", "rangeOffset"), - Param("VK_GPU_SIZE", "rangeSize"), - Param("VK_GPU_MEMORY", "mem"), - Param("VK_GPU_SIZE", "memOffset")]), - - Proto("VK_RESULT", "BindImageMemoryRange", - [Param("VK_IMAGE", "image"), - Param("uint32_t", "allocationIdx"), - Param("const VK_IMAGE_MEMORY_BIND_INFO*", "bindInfo"), - Param("VK_GPU_MEMORY", "mem"), - Param("VK_GPU_SIZE", "memOffset")]), - - Proto("VK_RESULT", "CreateFence", - [Param("VK_DEVICE", "device"), - Param("const VK_FENCE_CREATE_INFO*", "pCreateInfo"), - Param("VK_FENCE*", "pFence")]), - - Proto("VK_RESULT", "ResetFences", - [Param("VK_DEVICE", "device"), - Param("uint32_t", "fenceCount"), - Param("VK_FENCE*", "pFences")]), - - Proto("VK_RESULT", "GetFenceStatus", - [Param("VK_FENCE", "fence")]), - - Proto("VK_RESULT", "WaitForFences", - [Param("VK_DEVICE", "device"), - Param("uint32_t", "fenceCount"), - Param("const VK_FENCE*", "pFences"), - Param("bool32_t", "waitAll"), - Param("uint64_t", "timeout")]), - - Proto("VK_RESULT", "CreateSemaphore", - [Param("VK_DEVICE", "device"), - Param("const VK_SEMAPHORE_CREATE_INFO*", "pCreateInfo"), - Param("VK_SEMAPHORE*", "pSemaphore")]), - - Proto("VK_RESULT", "QueueSignalSemaphore", - [Param("VK_QUEUE", "queue"), - Param("VK_SEMAPHORE", "semaphore")]), - - Proto("VK_RESULT", "QueueWaitSemaphore", - [Param("VK_QUEUE", "queue"), - Param("VK_SEMAPHORE", "semaphore")]), - - Proto("VK_RESULT", "CreateEvent", - [Param("VK_DEVICE", "device"), - Param("const VK_EVENT_CREATE_INFO*", "pCreateInfo"), - Param("VK_EVENT*", "pEvent")]), - - Proto("VK_RESULT", "GetEventStatus", - [Param("VK_EVENT", "event")]), - - Proto("VK_RESULT", "SetEvent", - [Param("VK_EVENT", "event")]), - - Proto("VK_RESULT", "ResetEvent", - [Param("VK_EVENT", "event")]), - - Proto("VK_RESULT", "CreateQueryPool", - [Param("VK_DEVICE", "device"), - Param("const VK_QUERY_POOL_CREATE_INFO*", "pCreateInfo"), - Param("VK_QUERY_POOL*", "pQueryPool")]), - - Proto("VK_RESULT", "GetQueryPoolResults", - [Param("VK_QUERY_POOL", "queryPool"), - Param("uint32_t", "startQuery"), - Param("uint32_t", "queryCount"), - Param("size_t*", "pDataSize"), - Param("void*", "pData")]), - - Proto("VK_RESULT", "GetFormatInfo", - [Param("VK_DEVICE", "device"), - Param("VK_FORMAT", "format"), - Param("VK_FORMAT_INFO_TYPE", "infoType"), - Param("size_t*", "pDataSize"), - Param("void*", "pData")]), - - Proto("VK_RESULT", "CreateBuffer", - [Param("VK_DEVICE", "device"), - Param("const VK_BUFFER_CREATE_INFO*", "pCreateInfo"), - Param("VK_BUFFER*", "pBuffer")]), - - Proto("VK_RESULT", "CreateBufferView", - [Param("VK_DEVICE", "device"), - Param("const VK_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"), - Param("VK_BUFFER_VIEW*", "pView")]), - - Proto("VK_RESULT", "CreateImage", - [Param("VK_DEVICE", "device"), - Param("const VK_IMAGE_CREATE_INFO*", "pCreateInfo"), - Param("VK_IMAGE*", "pImage")]), - - Proto("VK_RESULT", "GetImageSubresourceInfo", - [Param("VK_IMAGE", "image"), - Param("const VK_IMAGE_SUBRESOURCE*", "pSubresource"), - Param("VK_SUBRESOURCE_INFO_TYPE", "infoType"), - Param("size_t*", "pDataSize"), - Param("void*", "pData")]), - - Proto("VK_RESULT", "CreateImageView", - [Param("VK_DEVICE", "device"), - Param("const VK_IMAGE_VIEW_CREATE_INFO*", "pCreateInfo"), - Param("VK_IMAGE_VIEW*", "pView")]), - - Proto("VK_RESULT", "CreateColorAttachmentView", - [Param("VK_DEVICE", "device"), - Param("const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO*", "pCreateInfo"), - Param("VK_COLOR_ATTACHMENT_VIEW*", "pView")]), - - Proto("VK_RESULT", "CreateDepthStencilView", - [Param("VK_DEVICE", "device"), - Param("const VK_DEPTH_STENCIL_VIEW_CREATE_INFO*", "pCreateInfo"), - Param("VK_DEPTH_STENCIL_VIEW*", "pView")]), - - Proto("VK_RESULT", "CreateShader", - [Param("VK_DEVICE", "device"), - Param("const VK_SHADER_CREATE_INFO*", "pCreateInfo"), - Param("VK_SHADER*", "pShader")]), - - Proto("VK_RESULT", "CreateGraphicsPipeline", - [Param("VK_DEVICE", "device"), - Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "CreateGraphicsPipelineDerivative", - [Param("VK_DEVICE", "device"), - Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"), - Param("VK_PIPELINE", "basePipeline"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "CreateComputePipeline", - [Param("VK_DEVICE", "device"), - Param("const VK_COMPUTE_PIPELINE_CREATE_INFO*", "pCreateInfo"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "StorePipeline", - [Param("VK_PIPELINE", "pipeline"), - Param("size_t*", "pDataSize"), - Param("void*", "pData")]), - - Proto("VK_RESULT", "LoadPipeline", - [Param("VK_DEVICE", "device"), - Param("size_t", "dataSize"), - Param("const void*", "pData"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "LoadPipelineDerivative", - [Param("VK_DEVICE", "device"), - Param("size_t", "dataSize"), - Param("const void*", "pData"), - Param("VK_PIPELINE", "basePipeline"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "CreateSampler", - [Param("VK_DEVICE", "device"), - Param("const VK_SAMPLER_CREATE_INFO*", "pCreateInfo"), - Param("VK_SAMPLER*", "pSampler")]), - - Proto("VK_RESULT", "CreateDescriptorSetLayout", - [Param("VK_DEVICE", "device"), - Param("const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*", "pCreateInfo"), - Param("VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayout")]), - - Proto("VK_RESULT", "CreateDescriptorSetLayoutChain", - [Param("VK_DEVICE", "device"), - Param("uint32_t", "setLayoutArrayCount"), - Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayoutArray"), - Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN*", "pLayoutChain")]), - - Proto("VK_RESULT", "BeginDescriptorPoolUpdate", - [Param("VK_DEVICE", "device"), - Param("VK_DESCRIPTOR_UPDATE_MODE", "updateMode")]), - - Proto("VK_RESULT", "EndDescriptorPoolUpdate", - [Param("VK_DEVICE", "device"), - Param("VK_CMD_BUFFER", "cmd")]), - - Proto("VK_RESULT", "CreateDescriptorPool", - [Param("VK_DEVICE", "device"), - Param("VK_DESCRIPTOR_POOL_USAGE", "poolUsage"), - Param("uint32_t", "maxSets"), - Param("const VK_DESCRIPTOR_POOL_CREATE_INFO*", "pCreateInfo"), - Param("VK_DESCRIPTOR_POOL*", "pDescriptorPool")]), - - Proto("VK_RESULT", "ResetDescriptorPool", - [Param("VK_DESCRIPTOR_POOL", "descriptorPool")]), - - Proto("VK_RESULT", "AllocDescriptorSets", - [Param("VK_DESCRIPTOR_POOL", "descriptorPool"), - Param("VK_DESCRIPTOR_SET_USAGE", "setUsage"), - Param("uint32_t", "count"), - Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayouts"), - Param("VK_DESCRIPTOR_SET*", "pDescriptorSets"), - Param("uint32_t*", "pCount")]), - - Proto("void", "ClearDescriptorSets", - [Param("VK_DESCRIPTOR_POOL", "descriptorPool"), - Param("uint32_t", "count"), - Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets")]), - - Proto("void", "UpdateDescriptors", - [Param("VK_DESCRIPTOR_SET", "descriptorSet"), - Param("uint32_t", "updateCount"), - Param("const void**", "ppUpdateArray")]), - - Proto("VK_RESULT", "CreateDynamicViewportState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_VP_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_VP_STATE_OBJECT*", "pState")]), - - Proto("VK_RESULT", "CreateDynamicRasterState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_RS_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_RS_STATE_OBJECT*", "pState")]), - - Proto("VK_RESULT", "CreateDynamicColorBlendState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_CB_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_CB_STATE_OBJECT*", "pState")]), - - Proto("VK_RESULT", "CreateDynamicDepthStencilState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_DS_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_DS_STATE_OBJECT*", "pState")]), - - Proto("VK_RESULT", "CreateCommandBuffer", - [Param("VK_DEVICE", "device"), - Param("const VK_CMD_BUFFER_CREATE_INFO*", "pCreateInfo"), - Param("VK_CMD_BUFFER*", "pCmdBuffer")]), - - Proto("VK_RESULT", "BeginCommandBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_CMD_BUFFER_BEGIN_INFO*", "pBeginInfo")]), - - Proto("VK_RESULT", "EndCommandBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer")]), - - Proto("VK_RESULT", "ResetCommandBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer")]), - - Proto("void", "CmdBindPipeline", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), - Param("VK_PIPELINE", "pipeline")]), - - Proto("void", "CmdBindDynamicStateObject", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_STATE_BIND_POINT", "stateBindPoint"), - Param("VK_DYNAMIC_STATE_OBJECT", "state")]), - - Proto("void", "CmdBindDescriptorSets", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), - Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN", "layoutChain"), - Param("uint32_t", "layoutChainSlot"), - Param("uint32_t", "count"), - Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets"), - Param("const uint32_t*", "pUserData")]), - - Proto("void", "CmdBindVertexBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), - Param("uint32_t", "binding")]), - - Proto("void", "CmdBindIndexBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), - Param("VK_INDEX_TYPE", "indexType")]), - - Proto("void", "CmdDraw", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("uint32_t", "firstVertex"), - Param("uint32_t", "vertexCount"), - Param("uint32_t", "firstInstance"), - Param("uint32_t", "instanceCount")]), - - Proto("void", "CmdDrawIndexed", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("uint32_t", "firstIndex"), - Param("uint32_t", "indexCount"), - Param("int32_t", "vertexOffset"), - Param("uint32_t", "firstInstance"), - Param("uint32_t", "instanceCount")]), - - Proto("void", "CmdDrawIndirect", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), - Param("uint32_t", "count"), - Param("uint32_t", "stride")]), - - Proto("void", "CmdDrawIndexedIndirect", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), - Param("uint32_t", "count"), - Param("uint32_t", "stride")]), - - Proto("void", "CmdDispatch", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("uint32_t", "x"), - Param("uint32_t", "y"), - Param("uint32_t", "z")]), - - Proto("void", "CmdDispatchIndirect", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset")]), - - Proto("void", "CmdCopyBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "srcBuffer"), - Param("VK_BUFFER", "destBuffer"), - Param("uint32_t", "regionCount"), - Param("const VK_BUFFER_COPY*", "pRegions")]), - - Proto("void", "CmdCopyImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), - Param("uint32_t", "regionCount"), - Param("const VK_IMAGE_COPY*", "pRegions")]), - - Proto("void", "CmdBlitImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), - Param("uint32_t", "regionCount"), - Param("const VK_IMAGE_BLIT*", "pRegions")]), - - Proto("void", "CmdCopyBufferToImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "srcBuffer"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), - Param("uint32_t", "regionCount"), - Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]), - - Proto("void", "CmdCopyImageToBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_BUFFER", "destBuffer"), - Param("uint32_t", "regionCount"), - Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]), - - Proto("void", "CmdCloneImageData", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout")]), - - Proto("void", "CmdUpdateBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset"), - Param("VK_GPU_SIZE", "dataSize"), - Param("const uint32_t*", "pData")]), - - Proto("void", "CmdFillBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset"), - Param("VK_GPU_SIZE", "fillSize"), - Param("uint32_t", "data")]), - - Proto("void", "CmdClearColorImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "image"), - Param("VK_IMAGE_LAYOUT", "imageLayout"), - Param("VK_CLEAR_COLOR", "color"), - Param("uint32_t", "rangeCount"), - Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]), - - Proto("void", "CmdClearDepthStencil", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "image"), - Param("VK_IMAGE_LAYOUT", "imageLayout"), - Param("float", "depth"), - Param("uint32_t", "stencil"), - Param("uint32_t", "rangeCount"), - Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]), - - Proto("void", "CmdResolveImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), - Param("uint32_t", "rectCount"), - Param("const VK_IMAGE_RESOLVE*", "pRects")]), - - Proto("void", "CmdSetEvent", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_EVENT", "event"), - Param("VK_PIPE_EVENT", "pipeEvent")]), - - Proto("void", "CmdResetEvent", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_EVENT", "event"), - Param("VK_PIPE_EVENT", "pipeEvent")]), - - Proto("void", "CmdWaitEvents", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_EVENT_WAIT_INFO*", "pWaitInfo")]), - - Proto("void", "CmdPipelineBarrier", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_PIPELINE_BARRIER*", "pBarrier")]), - - Proto("void", "CmdBeginQuery", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_QUERY_POOL", "queryPool"), - Param("uint32_t", "slot"), - Param("VK_FLAGS", "flags")]), - - Proto("void", "CmdEndQuery", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_QUERY_POOL", "queryPool"), - Param("uint32_t", "slot")]), - - Proto("void", "CmdResetQueryPool", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_QUERY_POOL", "queryPool"), - Param("uint32_t", "startQuery"), - Param("uint32_t", "queryCount")]), - - Proto("void", "CmdWriteTimestamp", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_TIMESTAMP_TYPE", "timestampType"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset")]), - - Proto("void", "CmdInitAtomicCounters", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), - Param("uint32_t", "startCounter"), - Param("uint32_t", "counterCount"), - Param("const uint32_t*", "pData")]), - - Proto("void", "CmdLoadAtomicCounters", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), - Param("uint32_t", "startCounter"), - Param("uint32_t", "counterCount"), - Param("VK_BUFFER", "srcBuffer"), - Param("VK_GPU_SIZE", "srcOffset")]), - - Proto("void", "CmdSaveAtomicCounters", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), - Param("uint32_t", "startCounter"), - Param("uint32_t", "counterCount"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset")]), - - Proto("VK_RESULT", "CreateFramebuffer", - [Param("VK_DEVICE", "device"), - Param("const VK_FRAMEBUFFER_CREATE_INFO*", "pCreateInfo"), - Param("VK_FRAMEBUFFER*", "pFramebuffer")]), - - Proto("VK_RESULT", "CreateRenderPass", - [Param("VK_DEVICE", "device"), - Param("const VK_RENDER_PASS_CREATE_INFO*", "pCreateInfo"), - Param("VK_RENDER_PASS*", "pRenderPass")]), - - Proto("void", "CmdBeginRenderPass", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_RENDER_PASS_BEGIN*", "pRenderPassBegin")]), - - Proto("void", "CmdEndRenderPass", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_RENDER_PASS", "renderPass")]), - - Proto("VK_RESULT", "DbgSetValidationLevel", - [Param("VK_DEVICE", "device"), - Param("VK_VALIDATION_LEVEL", "validationLevel")]), - - Proto("VK_RESULT", "DbgRegisterMsgCallback", - [Param("VK_INSTANCE", "instance"), - Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback"), - Param("void*", "pUserData")]), - - Proto("VK_RESULT", "DbgUnregisterMsgCallback", - [Param("VK_INSTANCE", "instance"), - Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback")]), - - Proto("VK_RESULT", "DbgSetMessageFilter", - [Param("VK_DEVICE", "device"), - Param("int32_t", "msgCode"), - Param("VK_DBG_MSG_FILTER", "filter")]), - - Proto("VK_RESULT", "DbgSetObjectTag", - [Param("VK_BASE_OBJECT", "object"), - Param("size_t", "tagSize"), - Param("const void*", "pTag")]), - - Proto("VK_RESULT", "DbgSetGlobalOption", - [Param("VK_INSTANCE", "instance"), - Param("VK_DBG_GLOBAL_OPTION", "dbgOption"), - Param("size_t", "dataSize"), - Param("const void*", "pData")]), - - Proto("VK_RESULT", "DbgSetDeviceOption", - [Param("VK_DEVICE", "device"), - Param("VK_DBG_DEVICE_OPTION", "dbgOption"), - Param("size_t", "dataSize"), - Param("const void*", "pData")]), - - Proto("void", "CmdDbgMarkerBegin", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const char*", "pMarker")]), - - Proto("void", "CmdDbgMarkerEnd", - [Param("VK_CMD_BUFFER", "cmdBuffer")]), - ], -) - -wsi_x11 = Extension( - name="VK_WSI_X11", - headers=["xglWsiX11Ext.h"], - objects=[], - protos=[ - Proto("VK_RESULT", "WsiX11AssociateConnection", - [Param("VK_PHYSICAL_GPU", "gpu"), - Param("const VK_WSI_X11_CONNECTION_INFO*", "pConnectionInfo")]), - - Proto("VK_RESULT", "WsiX11GetMSC", - [Param("VK_DEVICE", "device"), - Param("xcb_window_t", "window"), - Param("xcb_randr_crtc_t", "crtc"), - Param("uint64_t*", "pMsc")]), - - Proto("VK_RESULT", "WsiX11CreatePresentableImage", - [Param("VK_DEVICE", "device"), - Param("const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO*", "pCreateInfo"), - Param("VK_IMAGE*", "pImage"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "WsiX11QueuePresent", - [Param("VK_QUEUE", "queue"), - Param("const VK_WSI_X11_PRESENT_INFO*", "pPresentInfo"), - Param("VK_FENCE", "fence")]), - ], -) - -extensions = [core, wsi_x11] - -object_root_list = [ - "VK_INSTANCE", - "VK_PHYSICAL_GPU", - "VK_BASE_OBJECT" -] - -object_base_list = [ - "VK_DEVICE", - "VK_QUEUE", - "VK_GPU_MEMORY", - "VK_OBJECT" -] - -object_list = [ - "VK_BUFFER", - "VK_BUFFER_VIEW", - "VK_IMAGE", - "VK_IMAGE_VIEW", - "VK_COLOR_ATTACHMENT_VIEW", - "VK_DEPTH_STENCIL_VIEW", - "VK_SHADER", - "VK_PIPELINE", - "VK_SAMPLER", - "VK_DESCRIPTOR_SET", - "VK_DESCRIPTOR_SET_LAYOUT", - "VK_DESCRIPTOR_SET_LAYOUT_CHAIN", - "VK_DESCRIPTOR_POOL", - "VK_DYNAMIC_STATE_OBJECT", - "VK_CMD_BUFFER", - "VK_FENCE", - "VK_SEMAPHORE", - "VK_EVENT", - "VK_QUERY_POOL", - "VK_FRAMEBUFFER", - "VK_RENDER_PASS" -] - -object_dynamic_state_list = [ - "VK_DYNAMIC_VP_STATE_OBJECT", - "VK_DYNAMIC_RS_STATE_OBJECT", - "VK_DYNAMIC_CB_STATE_OBJECT", - "VK_DYNAMIC_DS_STATE_OBJECT" -] - -object_type_list = object_root_list + object_base_list + object_list + object_dynamic_state_list - -object_parent_list = ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT"] - -headers = [] -objects = [] -protos = [] -for ext in extensions: - headers.extend(ext.headers) - objects.extend(ext.objects) - protos.extend(ext.protos) - -proto_names = [proto.name for proto in protos] - -def parse_xgl_h(filename): - # read object and protoype typedefs - object_lines = [] - proto_lines = [] - with open(filename, "r") as fp: - for line in fp: - line = line.strip() - if line.startswith("VK_DEFINE"): - begin = line.find("(") + 1 - end = line.find(",") - # extract the object type - object_lines.append(line[begin:end]) - if line.startswith("typedef") and line.endswith(");"): - # drop leading "typedef " and trailing ");" - proto_lines.append(line[8:-2]) - - # parse proto_lines to protos - protos = [] - for line in proto_lines: - first, rest = line.split(" (VKAPI *vk") - second, third = rest.split("Type)(") - - # get the return type, no space before "*" - proto_ret = "*".join([t.rstrip() for t in first.split("*")]) - - # get the name - proto_name = second.strip() - - # get the list of params - param_strs = third.split(", ") - params = [] - for s in param_strs: - ty, name = s.rsplit(" ", 1) - - # no space before "*" - ty = "*".join([t.rstrip() for t in ty.split("*")]) - # attach [] to ty - idx = name.rfind("[") - if idx >= 0: - ty += name[idx:] - name = name[:idx] - - params.append(Param(ty, name)) - - protos.append(Proto(proto_ret, proto_name, params)) - - # make them an extension and print - ext = Extension("VK_CORE", - headers=["vulkan.h", "xglDbg.h"], - objects=object_lines, - protos=protos) - print("core =", str(ext)) - - print("") - print("typedef struct _VK_LAYER_DISPATCH_TABLE") - print("{") - for proto in ext.protos: - print(" vk%sType %s;" % (proto.name, proto.name)) - print("} VK_LAYER_DISPATCH_TABLE;") - -if __name__ == "__main__": - parse_xgl_h("include/vulkan.h") -- cgit v1.2.3