Hello community, here is the log from the commit of package vulkan-tools for openSUSE:Factory checked in at 2020-04-27 23:30:58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/vulkan-tools (Old) and /work/SRC/openSUSE:Factory/.vulkan-tools.new.2738 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "vulkan-tools" Mon Apr 27 23:30:58 2020 rev:18 rq:795770 version:1.2.137 Changes: -------- --- /work/SRC/openSUSE:Factory/vulkan-tools/vulkan-tools.changes 2020-04-14 15:19:32.956668897 +0200 +++ /work/SRC/openSUSE:Factory/.vulkan-tools.new.2738/vulkan-tools.changes 2020-04-27 23:31:10.962680531 +0200 @@ -1,0 +2,8 @@ +Mon Apr 20 10:32:57 UTC 2020 - Jan Engelhardt <jeng...@inai.de> + +- Update to release 1.2.137 + * vulkaninfo: Fix lack of display throwing on linux + * cube: Pick non-SRGB surface formats first + * vulkaninfo: fix app bundle not finding loader + +------------------------------------------------------------------- Old: ---- v1.2.135.tar.gz New: ---- v1.2.137.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ vulkan-tools.spec ++++++ --- /var/tmp/diff_new_pack.yoDAzA/_old 2020-04-27 23:31:11.510681601 +0200 +++ /var/tmp/diff_new_pack.yoDAzA/_new 2020-04-27 23:31:11.518681617 +0200 @@ -17,7 +17,7 @@ Name: vulkan-tools -Version: 1.2.135 +Version: 1.2.137 Release: 0 Summary: Diagnostic utilities for Vulkan License: Apache-2.0 @@ -27,7 +27,7 @@ Source: https://github.com/KhronosGroup/Vulkan-Tools/archive/v%version.tar.gz BuildRequires: cmake >= 3.4 BuildRequires: gcc-c++ >= 4.8 -BuildRequires: glslang-devel >= 7.13.3496 +BuildRequires: glslang-devel >= 8.13.3727 BuildRequires: pkg-config BuildRequires: python3-base BuildRequires: pkgconfig(vulkan) >= %version ++++++ v1.2.135.tar.gz -> v1.2.137.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/CONTRIBUTING.md new/Vulkan-Tools-1.2.137/CONTRIBUTING.md --- old/Vulkan-Tools-1.2.135/CONTRIBUTING.md 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/CONTRIBUTING.md 2020-04-13 20:45:36.000000000 +0200 @@ -40,7 +40,7 @@ * There are `.clang-format` files present in the repository to define clang-format settings which are found and used automatically by clang-format. * **clang-format** binaries are available from the LLVM orginization, here: [LLVM](https://clang.llvm.org/). Our CI system (Travis-CI) - currently uses clang-format version 5.0.0 to check that the lines of code you have changed are formatted properly. It is + currently uses clang-format version 7.0.0 to check that the lines of code you have changed are formatted properly. It is recommended that you use the same version to format your code prior to submission. * A sample git workflow may look like: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/build-android/vulkan-headers_revision_android new/Vulkan-Tools-1.2.137/build-android/vulkan-headers_revision_android --- old/Vulkan-Tools-1.2.135/build-android/vulkan-headers_revision_android 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/build-android/vulkan-headers_revision_android 2020-04-13 20:45:36.000000000 +0200 @@ -1 +1 @@ -v1.2.135 \ No newline at end of file +v1.2.137 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/cube/cube.c new/Vulkan-Tools-1.2.137/cube/cube.c --- old/Vulkan-Tools-1.2.135/cube/cube.c 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/cube/cube.c 2020-04-13 20:45:36.000000000 +0200 @@ -3412,6 +3412,24 @@ assert(!err); } +static VkSurfaceFormatKHR pick_surface_format(const VkSurfaceFormatKHR *surfaceFormats, uint32_t count) { + // Prefer non-SRGB formats... + for (uint32_t i = 0; i < count; i++) { + const VkFormat format = surfaceFormats[i].format; + + if (format == VK_FORMAT_R8G8B8A8_UNORM || format == VK_FORMAT_B8G8R8A8_UNORM || + format == VK_FORMAT_A2B10G10R10_UNORM_PACK32 || format == VK_FORMAT_A2R10G10B10_UNORM_PACK32 || + format == VK_FORMAT_R16G16B16A16_SFLOAT) { + return surfaceFormats[i]; + } + } + + printf("Can't find our preferred formats... Falling back to first exposed format. Rendering may be incorrect.\n"); + + assert(count >= 1); + return surfaceFormats[0]; +} + static void demo_init_vk_swapchain(struct demo *demo) { VkResult U_ASSERT_ONLY err; @@ -3489,16 +3507,9 @@ VkSurfaceFormatKHR *surfFormats = (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR)); err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, surfFormats); assert(!err); - // If the format list includes just one entry of VK_FORMAT_UNDEFINED, - // the surface has no preferred format. Otherwise, at least one - // supported format will be returned. - if (formatCount == 1 && surfFormats[0].format == VK_FORMAT_UNDEFINED) { - demo->format = VK_FORMAT_B8G8R8A8_UNORM; - } else { - assert(formatCount >= 1); - demo->format = surfFormats[0].format; - } - demo->color_space = surfFormats[0].colorSpace; + VkSurfaceFormatKHR surfaceFormat = pick_surface_format(surfFormats, formatCount); + demo->format = surfaceFormat.format; + demo->color_space = surfaceFormat.colorSpace; free(surfFormats); demo->quit = false; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/cube/cube.cpp new/Vulkan-Tools-1.2.137/cube/cube.cpp --- old/Vulkan-Tools-1.2.135/cube/cube.cpp 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/cube/cube.cpp 2020-04-13 20:45:36.000000000 +0200 @@ -34,7 +34,6 @@ #include <sstream> #include <memory> -#define VULKAN_HPP_NO_SMART_HANDLE #define VULKAN_HPP_NO_EXCEPTIONS #define VULKAN_HPP_TYPESAFE_CONVERSION #include <vulkan/vulkan.hpp> @@ -2064,7 +2063,6 @@ VERIFY(result == vk::Result::eSuccess); vk::SubresourceLayout layout; - memset(&layout, 0, sizeof(layout)); layout.rowPitch = tex_width * 4; auto data = device.mapMemory(tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize); VERIFY(data.result == vk::Result::eSuccess); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/icd/generated/mock_icd.cpp new/Vulkan-Tools-1.2.137/icd/generated/mock_icd.cpp --- old/Vulkan-Tools-1.2.135/icd/generated/mock_icd.cpp 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/icd/generated/mock_icd.cpp 2020-04-13 20:45:36.000000000 +0200 @@ -21,6 +21,7 @@ #include "mock_icd.h" #include <stdlib.h> +#include <algorithm> #include <vector> #include "vk_typemap_helper.h" namespace vkmock { @@ -31,10 +32,16 @@ // Map device memory handle to any mapped allocations that we'll need to free on unmap static unordered_map<VkDeviceMemory, std::vector<void*>> mapped_memory_map; -static VkPhysicalDevice physical_device = nullptr; +// Map device memory allocation handle to the size +static unordered_map<VkDeviceMemory, VkDeviceSize> allocated_memory_size_map; + +static VkPhysicalDevice physical_device = (VkPhysicalDevice)CreateDispObjHandle(); static unordered_map<VkDevice, unordered_map<uint32_t, unordered_map<uint32_t, VkQueue>>> queue_map; static unordered_map<VkDevice, unordered_map<VkBuffer, VkBufferCreateInfo>> buffer_map; +static constexpr uint32_t icd_swapchain_image_count = 1; +static std::unordered_map<VkSwapchainKHR, VkImage[icd_swapchain_image_count]> swapchain_image_map; + // TODO: Would like to codegen this but limits aren't in XML static VkPhysicalDeviceLimits SetLimits(VkPhysicalDeviceLimits *limits) { limits->maxImageDimension1D = 4096; @@ -186,9 +193,6 @@ const VkAllocationCallbacks* pAllocator) { - // Destroy physical device - DestroyDispObjHandle((void*)physical_device); - DestroyDispObjHandle((void*)instance); } @@ -198,9 +202,6 @@ VkPhysicalDevice* pPhysicalDevices) { if (pPhysicalDevices) { - if (!physical_device) { - physical_device = (VkPhysicalDevice)CreateDispObjHandle(); - } *pPhysicalDevices = physical_device; } else { *pPhysicalDeviceCount = 1; @@ -488,6 +489,7 @@ VkDeviceMemory* pMemory) { unique_lock_t lock(global_lock); + allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize; *pMemory = (VkDeviceMemory)global_unique_handle++; return VK_SUCCESS; } @@ -498,6 +500,7 @@ const VkAllocationCallbacks* pAllocator) { //Destroy object + allocated_memory_size_map.erase(memory); } static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( @@ -509,9 +512,12 @@ void** ppData) { unique_lock_t lock(global_lock); - // TODO: Just hard-coding 64k whole size for now - if (VK_WHOLE_SIZE == size) - size = 0x10000; + if (VK_WHOLE_SIZE == size) { + if (allocated_memory_size_map.count(memory) != 0) + size = allocated_memory_size_map[memory] - offset; + else + size = 0x10000; + } void* map_addr = malloc((size_t)size); mapped_memory_map[memory].push_back(map_addr); *ppData = map_addr; @@ -846,7 +852,7 @@ const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { - // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. + // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. *pLayout = VkSubresourceLayout(); // Default constructor zero values. } @@ -2122,6 +2128,9 @@ { unique_lock_t lock(global_lock); *pSwapchain = (VkSwapchainKHR)global_unique_handle++; + for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){ + swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++; + } return VK_SUCCESS; } @@ -2130,7 +2139,8 @@ VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { -//Destroy object + unique_lock_t lock(global_lock); + swapchain_image_map.clear(); } static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( @@ -2140,12 +2150,15 @@ VkImage* pSwapchainImages) { if (!pSwapchainImages) { - *pSwapchainImageCount = 1; - } else if (*pSwapchainImageCount > 0) { - pSwapchainImages[0] = (VkImage)global_unique_handle++; - if (*pSwapchainImageCount != 1) { - return VK_INCOMPLETE; + *pSwapchainImageCount = icd_swapchain_image_count; + } else { + unique_lock_t lock(global_lock); + for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){ + pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i]; } + + if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE; + else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count; } return VK_SUCCESS; } @@ -2158,7 +2171,7 @@ VkFence fence, uint32_t* pImageIndex) { -//Not a CREATE or DESTROY function + *pImageIndex = 0; return VK_SUCCESS; } @@ -2202,7 +2215,7 @@ const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { -//Not a CREATE or DESTROY function + *pImageIndex = 0; return VK_SUCCESS; } @@ -3327,6 +3340,15 @@ return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, @@ -4416,6 +4438,7 @@ + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/icd/generated/mock_icd.h new/Vulkan-Tools-1.2.137/icd/generated/mock_icd.h --- old/Vulkan-Tools-1.2.135/icd/generated/mock_icd.h 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/icd/generated/mock_icd.h 2020-04-13 20:45:36.000000000 +0200 @@ -75,7 +75,7 @@ {"VK_KHR_get_display_properties2", 1}, {"VK_MVK_ios_surface", 2}, {"VK_MVK_macos_surface", 2}, - {"VK_EXT_debug_utils", 1}, + {"VK_EXT_debug_utils", 2}, {"VK_FUCHSIA_imagepipe_surface", 1}, {"VK_EXT_metal_surface", 1}, {"VK_KHR_surface_protected_capabilities", 1}, @@ -97,7 +97,7 @@ {"VK_AMD_gcn_shader", 1}, {"VK_NV_dedicated_allocation", 1}, {"VK_EXT_transform_feedback", 1}, - {"VK_NVX_image_view_handle", 1}, + {"VK_NVX_image_view_handle", 2}, {"VK_AMD_draw_indirect_count", 2}, {"VK_AMD_negative_viewport_height", 1}, {"VK_AMD_gpu_shader_half_float", 2}, @@ -250,8 +250,9 @@ {"VK_GOOGLE_user_type", 1}, {"VK_KHR_pipeline_library", 1}, {"VK_KHR_shader_non_semantic_info", 1}, - {"VK_EXT_pipeline_creation_cache_control", 2}, + {"VK_EXT_pipeline_creation_cache_control", 3}, {"VK_NV_device_diagnostics_config", 1}, + {"VK_QCOM_render_pass_store_ops", 2}, }; @@ -2006,6 +2007,11 @@ VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties); + static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, @@ -2721,6 +2727,7 @@ + #ifdef VK_ENABLE_BETA_EXTENSIONS static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( @@ -3167,6 +3174,7 @@ {"vkCmdEndQueryIndexedEXT", (void*)CmdEndQueryIndexedEXT}, {"vkCmdDrawIndirectByteCountEXT", (void*)CmdDrawIndirectByteCountEXT}, {"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX}, + {"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX}, {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD}, {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD}, {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD}, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/icd/generated/vk_typemap_helper.h new/Vulkan-Tools-1.2.137/icd/generated/vk_typemap_helper.h --- old/Vulkan-Tools-1.2.135/icd/generated/vk_typemap_helper.h 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/icd/generated/vk_typemap_helper.h 2020-04-13 20:45:36.000000000 +0200 @@ -2210,6 +2210,15 @@ typedef VkImageViewHandleInfoNVX Type; }; +// Map type VkImageViewAddressPropertiesNVX to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX +template <> struct LvlTypeMap<VkImageViewAddressPropertiesNVX> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; +}; + +template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX> { + typedef VkImageViewAddressPropertiesNVX Type; +}; + // Map type VkTextureLODGatherFormatPropertiesAMD to id VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD template <> struct LvlTypeMap<VkTextureLODGatherFormatPropertiesAMD> { static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; @@ -3237,12 +3246,12 @@ typedef VkInitializePerformanceApiInfoINTEL Type; }; -// Map type VkQueryPoolPerformanceQueryCreateInfoINTEL to id VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL +// Map type VkQueryPoolPerformanceQueryCreateInfoINTEL to id VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL template <> struct LvlTypeMap<VkQueryPoolPerformanceQueryCreateInfoINTEL> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL; + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; }; -template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL> { +template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL> { typedef VkQueryPoolPerformanceQueryCreateInfoINTEL Type; }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/scripts/check_code_format.sh new/Vulkan-Tools-1.2.137/scripts/check_code_format.sh --- old/Vulkan-Tools-1.2.135/scripts/check_code_format.sh 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/scripts/check_code_format.sh 2020-04-13 20:45:36.000000000 +0200 @@ -22,6 +22,8 @@ GREEN='\033[0;32m' NC='\033[0m' # No Color +clang-format --version + FILES_TO_CHECK=$(git diff --name-only master | grep -v -E "^include/vulkan" | grep -E ".*\.(cpp|cc|c\+\+|cxx|c|h|hpp)$") if [ -z "${FILES_TO_CHECK}" ]; then @@ -37,5 +39,7 @@ else echo -e "${RED}Found formatting errors!${NC}" echo "${FORMAT_DIFF}" + echo "Be sure you are using the following version of clang-format:" + clang-format --version exit 1 fi diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/scripts/known_good.json new/Vulkan-Tools-1.2.137/scripts/known_good.json --- old/Vulkan-Tools-1.2.135/scripts/known_good.json 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/scripts/known_good.json 2020-04-13 20:45:36.000000000 +0200 @@ -6,7 +6,7 @@ "sub_dir" : "glslang", "build_dir" : "glslang/build", "install_dir" : "glslang/build/install", - "commit" : "4fc7a33910fb8e40b970d160e1b38ab3f67fe0f3", + "commit" : "e157435c1e777aa1052f446dafed162b4a722e03", "prebuild" : [ "python update_glslang_sources.py" ] @@ -17,7 +17,7 @@ "sub_dir" : "Vulkan-Headers", "build_dir" : "Vulkan-Headers/build", "install_dir" : "Vulkan-Headers/build/install", - "commit" : "v1.2.135" + "commit" : "v1.2.137" }, { "name" : "MoltenVK", @@ -25,7 +25,7 @@ "sub_dir" : "MoltenVK", "build_dir" : "MoltenVK", "install_dir" : "MoltenVK", - "commit" : "v1.0.40", + "commit" : "v1.0.41", "custom_build" : [ "./fetchDependencies --glslang-root {0[glslang][repo_dir]}", "xcodebuild -project MoltenVKPackaging.xcodeproj GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS MVK_CONFIG_LOG_LEVEL=1' -scheme \"MoltenVK Package\" build" @@ -41,7 +41,7 @@ "sub_dir" : "Vulkan-Loader", "build_dir" : "Vulkan-Loader/build", "install_dir" : "Vulkan-Loader/build/install", - "commit" : "v1.2.135", + "commit" : "v1.2.137", "deps" : [ { "var_name" : "VULKAN_HEADERS_INSTALL_DIR", diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/scripts/mock_icd_generator.py new/Vulkan-Tools-1.2.137/scripts/mock_icd_generator.py --- old/Vulkan-Tools-1.2.135/scripts/mock_icd_generator.py 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/scripts/mock_icd_generator.py 2020-04-13 20:45:36.000000000 +0200 @@ -57,10 +57,16 @@ // Map device memory handle to any mapped allocations that we'll need to free on unmap static unordered_map<VkDeviceMemory, std::vector<void*>> mapped_memory_map; -static VkPhysicalDevice physical_device = nullptr; +// Map device memory allocation handle to the size +static unordered_map<VkDeviceMemory, VkDeviceSize> allocated_memory_size_map; + +static VkPhysicalDevice physical_device = (VkPhysicalDevice)CreateDispObjHandle(); static unordered_map<VkDevice, unordered_map<uint32_t, unordered_map<uint32_t, VkQueue>>> queue_map; static unordered_map<VkDevice, unordered_map<VkBuffer, VkBufferCreateInfo>> buffer_map; +static constexpr uint32_t icd_swapchain_image_count = 1; +static std::unordered_map<VkSwapchainKHR, VkImage[icd_swapchain_image_count]> swapchain_image_map; + // TODO: Would like to codegen this but limits aren't in XML static VkPhysicalDeviceLimits SetLimits(VkPhysicalDeviceLimits *limits) { limits->maxImageDimension1D = 4096; @@ -425,16 +431,10 @@ return VK_SUCCESS; ''', 'vkDestroyInstance': ''' - // Destroy physical device - DestroyDispObjHandle((void*)physical_device); - DestroyDispObjHandle((void*)instance); ''', 'vkEnumeratePhysicalDevices': ''' if (pPhysicalDevices) { - if (!physical_device) { - physical_device = (VkPhysicalDevice)CreateDispObjHandle(); - } *pPhysicalDevices = physical_device; } else { *pPhysicalDeviceCount = 1; @@ -860,9 +860,12 @@ ''', 'vkMapMemory': ''' unique_lock_t lock(global_lock); - // TODO: Just hard-coding 64k whole size for now - if (VK_WHOLE_SIZE == size) - size = 0x10000; + if (VK_WHOLE_SIZE == size) { + if (allocated_memory_size_map.count(memory) != 0) + size = allocated_memory_size_map[memory] - offset; + else + size = 0x10000; + } void* map_addr = malloc((size_t)size); mapped_memory_map[memory].push_back(map_addr); *ppData = map_addr; @@ -876,21 +879,40 @@ mapped_memory_map.erase(memory); ''', 'vkGetImageSubresourceLayout': ''' - // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. + // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. *pLayout = VkSubresourceLayout(); // Default constructor zero values. ''', +'vkCreateSwapchainKHR': ''' + unique_lock_t lock(global_lock); + *pSwapchain = (VkSwapchainKHR)global_unique_handle++; + for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){ + swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++; + } + return VK_SUCCESS; +''', +'vkDestroySwapchainKHR': ''' + unique_lock_t lock(global_lock); + swapchain_image_map.clear(); +''', 'vkGetSwapchainImagesKHR': ''' if (!pSwapchainImages) { - *pSwapchainImageCount = 1; - } else if (*pSwapchainImageCount > 0) { - pSwapchainImages[0] = (VkImage)global_unique_handle++; - if (*pSwapchainImageCount != 1) { - return VK_INCOMPLETE; + *pSwapchainImageCount = icd_swapchain_image_count; + } else { + unique_lock_t lock(global_lock); + for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){ + pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i]; } + + if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE; + else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count; } return VK_SUCCESS; ''', -'vkAcquireNextImagesKHR': ''' +'vkAcquireNextImageKHR': ''' + *pImageIndex = 0; + return VK_SUCCESS; +''', +'vkAcquireNextImage2KHR': ''' *pImageIndex = 0; return VK_SUCCESS; ''', @@ -1070,6 +1092,7 @@ else: write('#include "mock_icd.h"', file=self.outFile) write('#include <stdlib.h>', file=self.outFile) + write('#include <algorithm>', file=self.outFile) write('#include <vector>', file=self.outFile) write('#include "vk_typemap_helper.h"', file=self.outFile) @@ -1299,9 +1322,15 @@ self.appendSection('command', ' }') else: #print("Single %s last param is '%s' w/ type '%s'" % (handle_type, lp_txt, lp_type)) + if 'AllocateMemory' in api_function_name: + # Store allocation size in case it's mapped + self.appendSection('command', ' allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize;') self.appendSection('command', ' *%s = (%s)%s;' % (lp_txt, lp_type, allocator_txt)) elif True in [ftxt in api_function_name for ftxt in ['Destroy', 'Free']]: self.appendSection('command', '//Destroy object') + if 'FreeMemory' in api_function_name: + # Remove from allocation map + self.appendSection('command', ' allocated_memory_size_map.erase(memory);') else: self.appendSection('command', '//Not a CREATE or DESTROY function') diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/vulkaninfo/CMakeLists.txt new/Vulkan-Tools-1.2.137/vulkaninfo/CMakeLists.txt --- old/Vulkan-Tools-1.2.135/vulkaninfo/CMakeLists.txt 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/vulkaninfo/CMakeLists.txt 2020-04-13 20:45:36.000000000 +0200 @@ -124,7 +124,7 @@ file(COPY vulkaninfo.vcxproj.user DESTINATION ${CMAKE_BINARY_DIR}/vulkaninfo) elseif(APPLE) - add_definitions(-DVK_USE_PLATFORM_MACOS_MVK -DVK_USE_PLATFORM_METAL_EXT -DVK_NO_PROTOTYPES) + add_definitions(-DVK_USE_PLATFORM_MACOS_MVK -DVK_USE_PLATFORM_METAL_EXT) endif() if(APPLE) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/vulkaninfo/generated/vulkaninfo.hpp new/Vulkan-Tools-1.2.137/vulkaninfo/generated/vulkaninfo.hpp --- old/Vulkan-Tools-1.2.135/vulkaninfo/generated/vulkaninfo.hpp 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/vulkaninfo/generated/vulkaninfo.hpp 2020-04-13 20:45:36.000000000 +0200 @@ -88,7 +88,7 @@ case (1000268001): return "THREAD_DONE_KHR"; case (1000268002): return "OPERATION_DEFERRED_KHR"; case (1000268003): return "OPERATION_NOT_DEFERRED_KHR"; - case (1000297000): return "ERROR_PIPELINE_COMPILE_REQUIRED_EXT"; + case (1000297000): return "PIPELINE_COMPILE_REQUIRED_EXT"; default: return "UNKNOWN_VkResult"; } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/vulkaninfo/macOS/vulkaninfo.sh new/Vulkan-Tools-1.2.137/vulkaninfo/macOS/vulkaninfo.sh --- old/Vulkan-Tools-1.2.135/vulkaninfo/macOS/vulkaninfo.sh 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/vulkaninfo/macOS/vulkaninfo.sh 2020-04-13 20:45:36.000000000 +0200 @@ -7,3 +7,4 @@ else open /Applications/Utilities/Terminal.app $BASEDIR/vulkaninfo fi + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/vulkaninfo/outputprinter.h new/Vulkan-Tools-1.2.137/vulkaninfo/outputprinter.h --- old/Vulkan-Tools-1.2.135/vulkaninfo/outputprinter.h 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/vulkaninfo/outputprinter.h 2020-04-13 20:45:36.000000000 +0200 @@ -710,8 +710,9 @@ class ObjectWrapper { public: - ObjectWrapper(Printer &p, std::string object_name, int32_t count_subobjects = -1) : p(p) { - p.ObjectStart(object_name, count_subobjects); + ObjectWrapper(Printer &p, std::string object_name) : p(p) { p.ObjectStart(object_name); } + ObjectWrapper(Printer &p, std::string object_name, size_t count_subobjects) : p(p) { + p.ObjectStart(object_name, static_cast<int32_t>(count_subobjects)); } ~ObjectWrapper() { p.ObjectEnd(); } @@ -721,7 +722,9 @@ class ArrayWrapper { public: - ArrayWrapper(Printer &p, std::string array_name, int32_t element_count = 0) : p(p) { p.ArrayStart(array_name, element_count); } + ArrayWrapper(Printer &p, std::string array_name, size_t element_count = 0) : p(p) { + p.ArrayStart(array_name, static_cast<int32_t>(element_count)); + } ~ArrayWrapper() { p.ArrayEnd(); } private: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/vulkaninfo/vulkaninfo.cpp new/Vulkan-Tools-1.2.137/vulkaninfo/vulkaninfo.cpp --- old/Vulkan-Tools-1.2.135/vulkaninfo/vulkaninfo.cpp 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/vulkaninfo/vulkaninfo.cpp 2020-04-13 20:45:36.000000000 +0200 @@ -641,7 +641,7 @@ VkFormat fmt = static_cast<VkFormat>(fmt_counter); VkFormatProperties props; - gpu.inst.dll.vkGetPhysicalDeviceFormatProperties(gpu.phys_device, fmt, &props); + gpu.inst.dll.fp_vkGetPhysicalDeviceFormatProperties(gpu.phys_device, fmt, &props); GpuDumpFormatProperty(p, fmt, props); } @@ -660,7 +660,7 @@ VkFormat fmt = static_cast<VkFormat>(fmt_counter); VkFormatProperties props; - gpu.inst.dll.vkGetPhysicalDeviceFormatProperties(gpu.phys_device, fmt, &props); + gpu.inst.dll.fp_vkGetPhysicalDeviceFormatProperties(gpu.phys_device, fmt, &props); // don't print format properties that are unsupported if ((props.linearTilingFeatures || props.optimalTilingFeatures || props.bufferFeatures) == 0) continue; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-1.2.135/vulkaninfo/vulkaninfo.h new/Vulkan-Tools-1.2.137/vulkaninfo/vulkaninfo.h --- old/Vulkan-Tools-1.2.135/vulkaninfo/vulkaninfo.h 2020-03-19 22:30:30.000000000 +0100 +++ new/Vulkan-Tools-1.2.137/vulkaninfo/vulkaninfo.h 2020-04-13 20:45:36.000000000 +0200 @@ -256,168 +256,184 @@ #if defined(__linux__) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL); if (!library) library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); -#elif defined(__APPLE__) - library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); - if (!library) library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); - if (!library) library = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL); #elif defined(_WIN32) library = LoadLibrary(TEXT("vulkan-1.dll")); -#else - assert(false && "unsupported platform"); #endif +#if !defined(__APPLE__) if (library == 0) return VK_ERROR_INITIALIZATION_FAILED; +#endif return VK_SUCCESS; } void Close() { -#if defined(__linux__) || defined(__APPLE__) +#if defined(__linux__) dlclose(library); #elif defined(_WIN32) FreeLibrary(library); #endif +#if !defined(__APPLE__) library = 0; +#endif } + +#if defined(__APPLE__) +#define APPLE_FP(name) name +#else +#define APPLE_FP(nama) nullptr +#endif + // Function pointers, loaded from the dll - PFN_vkCreateInstance vkCreateInstance; - PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; - PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; - PFN_vkDestroyInstance vkDestroyInstance; - PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; - PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; - PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; - PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties; - PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; - PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; - PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr; - PFN_vkCreateDevice vkCreateDevice; - PFN_vkDestroyDevice vkDestroyDevice; - PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; - PFN_vkGetDeviceQueue vkGetDeviceQueue; - PFN_vkCreateImage vkCreateImage; - PFN_vkDestroyImage vkDestroyImage; - PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; - PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; - PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; - PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion; - PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups; - PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2; - PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2; - PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2; - PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2; - PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR; + PFN_vkCreateInstance fp_vkCreateInstance = APPLE_FP(vkCreateInstance); + PFN_vkEnumerateInstanceExtensionProperties fp_vkEnumerateInstanceExtensionProperties = + APPLE_FP(vkEnumerateInstanceExtensionProperties); + PFN_vkEnumerateInstanceLayerProperties fp_vkEnumerateInstanceLayerProperties = APPLE_FP(vkEnumerateInstanceLayerProperties); + PFN_vkDestroyInstance fp_vkDestroyInstance = APPLE_FP(vkDestroyInstance); + PFN_vkEnumeratePhysicalDevices fp_vkEnumeratePhysicalDevices = APPLE_FP(vkEnumeratePhysicalDevices); + PFN_vkGetPhysicalDeviceFeatures fp_vkGetPhysicalDeviceFeatures = APPLE_FP(vkGetPhysicalDeviceFeatures); + PFN_vkGetPhysicalDeviceFormatProperties fp_vkGetPhysicalDeviceFormatProperties = APPLE_FP(vkGetPhysicalDeviceFormatProperties); + PFN_vkGetPhysicalDeviceImageFormatProperties fp_vkGetPhysicalDeviceImageFormatProperties = + APPLE_FP(vkGetPhysicalDeviceImageFormatProperties); + PFN_vkGetPhysicalDeviceProperties fp_vkGetPhysicalDeviceProperties = APPLE_FP(vkGetPhysicalDeviceProperties); + PFN_vkGetPhysicalDeviceQueueFamilyProperties fp_vkGetPhysicalDeviceQueueFamilyProperties = + APPLE_FP(vkGetPhysicalDeviceQueueFamilyProperties); + PFN_vkGetPhysicalDeviceMemoryProperties fp_vkGetPhysicalDeviceMemoryProperties = APPLE_FP(vkGetPhysicalDeviceMemoryProperties); + PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr = APPLE_FP(vkGetInstanceProcAddr); + PFN_vkGetDeviceProcAddr fp_vkGetDeviceProcAddr = APPLE_FP(vkGetDeviceProcAddr); + PFN_vkCreateDevice fp_vkCreateDevice = APPLE_FP(vkCreateDevice); + PFN_vkDestroyDevice fp_vkDestroyDevice = APPLE_FP(vkDestroyDevice); + PFN_vkEnumerateDeviceExtensionProperties fp_vkEnumerateDeviceExtensionProperties = + APPLE_FP(vkEnumerateDeviceExtensionProperties); + PFN_vkGetDeviceQueue fp_vkGetDeviceQueue = APPLE_FP(vkGetDeviceQueue); + PFN_vkCreateImage fp_vkCreateImage = APPLE_FP(vkCreateImage); + PFN_vkDestroyImage fp_vkDestroyImage = APPLE_FP(vkDestroyImage); + PFN_vkGetBufferMemoryRequirements fp_vkGetBufferMemoryRequirements = APPLE_FP(vkGetBufferMemoryRequirements); + PFN_vkGetImageMemoryRequirements fp_vkGetImageMemoryRequirements = APPLE_FP(vkGetImageMemoryRequirements); + PFN_vkGetImageSparseMemoryRequirements fp_vkGetImageSparseMemoryRequirements = APPLE_FP(vkGetImageSparseMemoryRequirements); + PFN_vkEnumerateInstanceVersion fp_vkEnumerateInstanceVersion = APPLE_FP(vkEnumerateInstanceVersion); + PFN_vkEnumeratePhysicalDeviceGroups fp_vkEnumeratePhysicalDeviceGroups = APPLE_FP(vkEnumeratePhysicalDeviceGroups); + PFN_vkGetPhysicalDeviceFeatures2 fp_vkGetPhysicalDeviceFeatures2 = APPLE_FP(vkGetPhysicalDeviceFeatures2); + PFN_vkGetPhysicalDeviceProperties2 fp_vkGetPhysicalDeviceProperties2 = APPLE_FP(vkGetPhysicalDeviceProperties2); + PFN_vkGetPhysicalDeviceFormatProperties2 fp_vkGetPhysicalDeviceFormatProperties2 = + APPLE_FP(vkGetPhysicalDeviceFormatProperties2); + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 fp_vkGetPhysicalDeviceQueueFamilyProperties2 = + APPLE_FP(vkGetPhysicalDeviceQueueFamilyProperties2); + PFN_vkGetPhysicalDeviceMemoryProperties2 fp_vkGetPhysicalDeviceMemoryProperties2 = + APPLE_FP(vkGetPhysicalDeviceMemoryProperties2); + PFN_vkDestroySurfaceKHR fp_vkDestroySurfaceKHR = APPLE_FP(vkDestroySurfaceKHR); #ifdef VK_USE_PLATFORM_XLIB_KHR - PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; + PFN_vkCreateXlibSurfaceKHR fp_vkCreateXlibSurfaceKHR = APPLE_FP(vkCreateXlibSurfaceKHR); #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR - PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR fp_vkGetPhysicalDeviceXlibPresentationSupportKHR = + APPLE_FP(vkGetPhysicalDeviceXlibPresentationSupportKHR); #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR - PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; + PFN_vkCreateXcbSurfaceKHR fp_vkCreateXcbSurfaceKHR = APPLE_FP(vkCreateXcbSurfaceKHR); #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR - PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR fp_vkGetPhysicalDeviceXcbPresentationSupportKHR = + APPLE_FP(vkGetPhysicalDeviceXcbPresentationSupportKHR); #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR - PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; + PFN_vkCreateWaylandSurfaceKHR fp_vkCreateWaylandSurfaceKHR = APPLE_FP(vkCreateWaylandSurfaceKHR); #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR - PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR = + APPLE_FP(vkGetPhysicalDeviceWaylandPresentationSupportKHR); #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR - PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; + PFN_vkCreateAndroidSurfaceKHR fp_vkCreateAndroidSurfaceKHR = APPLE_FP(vkCreateAndroidSurfaceKHR); #endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; + PFN_vkCreateWin32SurfaceKHR fp_vkCreateWin32SurfaceKHR = APPLE_FP(vkCreateWin32SurfaceKHR); #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR fp_vkGetPhysicalDeviceWin32PresentationSupportKHR = + APPLE_FP(vkGetPhysicalDeviceWin32PresentationSupportKHR); #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_MACOS_MVK - PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; + PFN_vkCreateMacOSSurfaceMVK fp_vkCreateMacOSSurfaceMVK = APPLE_FP(vkCreateMacOSSurfaceMVK); #endif // VK_USE_PLATFORM_MACOS_MVK #ifdef VK_USE_PLATFORM_METAL_EXT - PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; + PFN_vkCreateMetalSurfaceEXT fp_vkCreateMetalSurfaceEXT = APPLE_FP(vkCreateMetalSurfaceEXT); #endif // VK_USE_PLATFORM_METAL_EXT void InitializeDispatchPointers() { - Load(vkCreateInstance, "vkCreateInstance"); - Load(vkDestroyInstance, "vkDestroyInstance"); - Load(vkEnumeratePhysicalDevices, "vkEnumeratePhysicalDevices"); - Load(vkGetPhysicalDeviceFeatures, "vkGetPhysicalDeviceFeatures"); - Load(vkGetPhysicalDeviceFormatProperties, "vkGetPhysicalDeviceFormatProperties"); - Load(vkGetPhysicalDeviceImageFormatProperties, "vkGetPhysicalDeviceImageFormatProperties"); - Load(vkGetPhysicalDeviceProperties, "vkGetPhysicalDeviceProperties"); - Load(vkGetPhysicalDeviceQueueFamilyProperties, "vkGetPhysicalDeviceQueueFamilyProperties"); - Load(vkGetPhysicalDeviceMemoryProperties, "vkGetPhysicalDeviceMemoryProperties"); - Load(vkGetInstanceProcAddr, "vkGetInstanceProcAddr"); - Load(vkGetDeviceProcAddr, "vkGetDeviceProcAddr"); - Load(vkCreateDevice, "vkCreateDevice"); - Load(vkDestroyDevice, "vkDestroyDevice"); - Load(vkEnumerateInstanceExtensionProperties, "vkEnumerateInstanceExtensionProperties"); - Load(vkEnumerateDeviceExtensionProperties, "vkEnumerateDeviceExtensionProperties"); - Load(vkEnumerateInstanceLayerProperties, "vkEnumerateInstanceLayerProperties"); - Load(vkGetDeviceQueue, "vkGetDeviceQueue"); - Load(vkCreateImage, "vkCreateImage"); - Load(vkDestroyImage, "vkDestroyImage"); - Load(vkGetBufferMemoryRequirements, "vkGetBufferMemoryRequirements"); - Load(vkGetImageMemoryRequirements, "vkGetImageMemoryRequirements"); - Load(vkGetImageSparseMemoryRequirements, "vkGetImageSparseMemoryRequirements"); - Load(vkEnumerateInstanceVersion, "vkEnumerateInstanceVersion"); - Load(vkEnumeratePhysicalDeviceGroups, "vkEnumeratePhysicalDeviceGroups"); - Load(vkGetPhysicalDeviceFeatures2, "vkGetPhysicalDeviceFeatures2"); - Load(vkGetPhysicalDeviceProperties2, "vkGetPhysicalDeviceProperties2"); - Load(vkGetPhysicalDeviceFormatProperties2, "vkGetPhysicalDeviceFormatProperties2"); - Load(vkGetPhysicalDeviceQueueFamilyProperties2, "vkGetPhysicalDeviceQueueFamilyProperties2"); - Load(vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2"); - Load(vkDestroySurfaceKHR, "vkDestroySurfaceKHR"); + Load(fp_vkCreateInstance, "vkCreateInstance"); + Load(fp_vkDestroyInstance, "vkDestroyInstance"); + Load(fp_vkEnumeratePhysicalDevices, "vkEnumeratePhysicalDevices"); + Load(fp_vkGetPhysicalDeviceFeatures, "vkGetPhysicalDeviceFeatures"); + Load(fp_vkGetPhysicalDeviceFormatProperties, "vkGetPhysicalDeviceFormatProperties"); + Load(fp_vkGetPhysicalDeviceImageFormatProperties, "vkGetPhysicalDeviceImageFormatProperties"); + Load(fp_vkGetPhysicalDeviceProperties, "vkGetPhysicalDeviceProperties"); + Load(fp_vkGetPhysicalDeviceQueueFamilyProperties, "vkGetPhysicalDeviceQueueFamilyProperties"); + Load(fp_vkGetPhysicalDeviceMemoryProperties, "vkGetPhysicalDeviceMemoryProperties"); + Load(fp_vkGetInstanceProcAddr, "vkGetInstanceProcAddr"); + Load(fp_vkGetDeviceProcAddr, "vkGetDeviceProcAddr"); + Load(fp_vkCreateDevice, "vkCreateDevice"); + Load(fp_vkDestroyDevice, "vkDestroyDevice"); + Load(fp_vkEnumerateInstanceExtensionProperties, "vkEnumerateInstanceExtensionProperties"); + Load(fp_vkEnumerateDeviceExtensionProperties, "vkEnumerateDeviceExtensionProperties"); + Load(fp_vkEnumerateInstanceLayerProperties, "vkEnumerateInstanceLayerProperties"); + Load(fp_vkGetDeviceQueue, "vkGetDeviceQueue"); + Load(fp_vkCreateImage, "vkCreateImage"); + Load(fp_vkDestroyImage, "vkDestroyImage"); + Load(fp_vkGetBufferMemoryRequirements, "vkGetBufferMemoryRequirements"); + Load(fp_vkGetImageMemoryRequirements, "vkGetImageMemoryRequirements"); + Load(fp_vkGetImageSparseMemoryRequirements, "vkGetImageSparseMemoryRequirements"); + Load(fp_vkEnumerateInstanceVersion, "vkEnumerateInstanceVersion"); + Load(fp_vkEnumeratePhysicalDeviceGroups, "vkEnumeratePhysicalDeviceGroups"); + Load(fp_vkGetPhysicalDeviceFeatures2, "vkGetPhysicalDeviceFeatures2"); + Load(fp_vkGetPhysicalDeviceProperties2, "vkGetPhysicalDeviceProperties2"); + Load(fp_vkGetPhysicalDeviceFormatProperties2, "vkGetPhysicalDeviceFormatProperties2"); + Load(fp_vkGetPhysicalDeviceQueueFamilyProperties2, "vkGetPhysicalDeviceQueueFamilyProperties2"); + Load(fp_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2"); + Load(fp_vkDestroySurfaceKHR, "vkDestroySurfaceKHR"); #ifdef VK_USE_PLATFORM_XLIB_KHR - Load(vkCreateXlibSurfaceKHR, "vkCreateXlibSurfaceKHR"); + Load(fp_vkCreateXlibSurfaceKHR, "vkCreateXlibSurfaceKHR"); #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR - Load(vkGetPhysicalDeviceXlibPresentationSupportKHR, "vkGetPhysicalDeviceXlibPresentationSupportKHR"); + Load(fp_vkGetPhysicalDeviceXlibPresentationSupportKHR, "vkGetPhysicalDeviceXlibPresentationSupportKHR"); #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR - Load(vkCreateXcbSurfaceKHR, "vkCreateXcbSurfaceKHR"); + Load(fp_vkCreateXcbSurfaceKHR, "vkCreateXcbSurfaceKHR"); #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR - Load(vkGetPhysicalDeviceXcbPresentationSupportKHR, "vkGetPhysicalDeviceXcbPresentationSupportKHR"); + Load(fp_vkGetPhysicalDeviceXcbPresentationSupportKHR, "vkGetPhysicalDeviceXcbPresentationSupportKHR"); #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR - Load(vkCreateWaylandSurfaceKHR, "vkCreateWaylandSurfaceKHR"); + Load(fp_vkCreateWaylandSurfaceKHR, "vkCreateWaylandSurfaceKHR"); #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR - Load(vkGetPhysicalDeviceWaylandPresentationSupportKHR, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"); + Load(fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"); #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR - Load(vkCreateAndroidSurfaceKHR, "vkCreateAndroidSurfaceKHR"); + Load(fp_vkCreateAndroidSurfaceKHR, "vkCreateAndroidSurfaceKHR"); #endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR - Load(vkCreateWin32SurfaceKHR, "vkCreateWin32SurfaceKHR"); + Load(fp_vkCreateWin32SurfaceKHR, "vkCreateWin32SurfaceKHR"); #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR - Load(vkGetPhysicalDeviceWin32PresentationSupportKHR, "vkGetPhysicalDeviceWin32PresentationSupportKHR"); + Load(fp_vkGetPhysicalDeviceWin32PresentationSupportKHR, "vkGetPhysicalDeviceWin32PresentationSupportKHR"); #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_MACOS_MVK - Load(vkCreateMacOSSurfaceMVK, "vkCreateMacOSSurfaceMVK"); + Load(fp_vkCreateMacOSSurfaceMVK, "vkCreateMacOSSurfaceMVK"); #endif // VK_USE_PLATFORM_MACOS_MVK #ifdef VK_USE_PLATFORM_METAL_EXT - Load(vkCreateMetalSurfaceEXT, "vkCreateMetalSurfaceEXT"); + Load(fp_vkCreateMetalSurfaceEXT, "vkCreateMetalSurfaceEXT"); #endif // VK_USE_PLATFORM_METAL_EXT } private: template <typename T> void Load(T &func_dest, const char *func_name) { -#if defined(__linux__) || defined(__APPLE__) +#if defined(__linux__) func_dest = reinterpret_cast<T>(dlsym(library, func_name)); #elif defined(_WIN32) func_dest = reinterpret_cast<T>(GetProcAddress(library, func_name)); #endif } -#if defined(__linux__) || defined(__APPLE__) +#if defined(__linux__) void *library; #elif defined(_WIN32) HMODULE library; @@ -587,10 +603,10 @@ } dll.InitializeDispatchPointers(); - if (!dll.vkEnumerateInstanceVersion) { + if (!dll.fp_vkEnumerateInstanceVersion) { instance_version = VK_API_VERSION_1_0; } else { - const VkResult err = dll.vkEnumerateInstanceVersion(&instance_version); + const VkResult err = dll.fp_vkEnumerateInstanceVersion(&instance_version); if (err) THROW_VK_ERR("vkEnumerateInstanceVersion", err); } @@ -616,7 +632,7 @@ const VkInstanceCreateInfo inst_info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, &dbg_info, 0, &app_info, 0, nullptr, static_cast<uint32_t>(inst_exts.size()), inst_exts.data()}; - VkResult err = dll.vkCreateInstance(&inst_info, nullptr, &instance); + VkResult err = dll.fp_vkCreateInstance(&inst_info, nullptr, &instance); if (err == VK_ERROR_INCOMPATIBLE_DRIVER) { std::cerr << "Cannot create Vulkan instance.\n"; std::cerr << "This problem is often caused by a faulty installation of the Vulkan driver or attempting to use a GPU " @@ -625,11 +641,11 @@ } else if (err) { THROW_VK_ERR("vkCreateInstance", err); } - ext_funcs.LoadInstanceExtensionDispatchPointers(dll.vkGetInstanceProcAddr, instance); + ext_funcs.LoadInstanceExtensionDispatchPointers(dll.fp_vkGetInstanceProcAddr, instance); } ~AppInstance() { - if (dll.vkDestroyInstance) dll.vkDestroyInstance(instance, nullptr); + if (dll.fp_vkDestroyInstance) dll.fp_vkDestroyInstance(instance, nullptr); dll.Close(); } @@ -649,7 +665,7 @@ void AppGetInstanceExtensions() { /* Scan layers */ auto global_layer_properties = - GetVector<VkLayerProperties>("vkEnumerateInstanceLayerProperties", dll.vkEnumerateInstanceLayerProperties); + GetVector<VkLayerProperties>("vkEnumerateInstanceLayerProperties", dll.fp_vkEnumerateInstanceLayerProperties); global_layers.resize(global_layer_properties.size()); for (size_t i = 0; i < global_layer_properties.size(); i++) { @@ -673,11 +689,11 @@ std::vector<VkExtensionProperties> AppGetGlobalLayerExtensions(char *layer_name) { return GetVector<VkExtensionProperties>("vkEnumerateInstanceExtensionProperties", - dll.vkEnumerateInstanceExtensionProperties, layer_name); + dll.fp_vkEnumerateInstanceExtensionProperties, layer_name); } std::vector<VkPhysicalDevice> FindPhysicalDevices() { - return GetVector<VkPhysicalDevice>("vkEnumerateInstanceExtensionProperties", dll.vkEnumeratePhysicalDevices, instance); + return GetVector<VkPhysicalDevice>("vkEnumerateInstanceExtensionProperties", dll.fp_vkEnumeratePhysicalDevices, instance); } }; @@ -745,7 +761,7 @@ createInfo.hwnd = inst.h_wnd; VkSurfaceKHR surface; - VkResult err = inst.dll.vkCreateWin32SurfaceKHR(inst.instance, &createInfo, nullptr, &surface); + VkResult err = inst.dll.fp_vkCreateWin32SurfaceKHR(inst.instance, &createInfo, nullptr, &surface); if (err) THROW_VK_ERR("vkCreateWin32SurfaceKHR", err); return surface; } @@ -758,7 +774,7 @@ defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_METAL_EXT) || defined(VK_USE_PLATFORM_WAYLAND_KHR) || \ defined(VK_USE_PLATFORM_ANDROID_KHR) static void AppDestroySurface(AppInstance &inst, VkSurfaceKHR surface) { // same for all platforms - inst.dll.vkDestroySurfaceKHR(inst.instance, surface, nullptr); + inst.dll.fp_vkDestroySurfaceKHR(inst.instance, surface, nullptr); } #endif @@ -813,7 +829,7 @@ xcb_createInfo.window = inst.xcb_window; VkSurfaceKHR surface; - VkResult err = inst.dll.vkCreateXcbSurfaceKHR(inst.instance, &xcb_createInfo, nullptr, &surface); + VkResult err = inst.dll.fp_vkCreateXcbSurfaceKHR(inst.instance, &xcb_createInfo, nullptr, &surface); if (err) THROW_VK_ERR("vkCreateXcbSurfaceKHR", err); return surface; } @@ -859,7 +875,7 @@ createInfo.window = inst.xlib_window; VkSurfaceKHR surface; - VkResult err = inst.dll.vkCreateXlibSurfaceKHR(inst.instance, &createInfo, nullptr, &surface); + VkResult err = inst.dll.fp_vkCreateXlibSurfaceKHR(inst.instance, &createInfo, nullptr, &surface); if (err) THROW_VK_ERR("vkCreateXlibSurfaceKHR", err); return surface; } @@ -888,7 +904,7 @@ createInfo.pView = inst.macos_window; VkSurfaceKHR surface; - VkResult err = inst.dll.vkCreateMacOSSurfaceMVK(inst.instance, &createInfo, nullptr, &surface); + VkResult err = inst.dll.fp_vkCreateMacOSSurfaceMVK(inst.instance, &createInfo, nullptr, &surface); if (err) THROW_VK_ERR("vkCreateMacOSSurfaceMVK", err); return surface; } @@ -914,7 +930,7 @@ createInfo.pLayer = static_cast<CAMetalLayer *>(GetCAMetalLayerFromMetalView(inst.metal_window)); VkSurfaceKHR surface; - VkResult err = inst.dll.vkCreateMetalSurfaceEXT(inst.instance, &createInfo, nullptr, &surface); + VkResult err = inst.dll.fp_vkCreateMetalSurfaceEXT(inst.instance, &createInfo, nullptr, &surface); if (err) THROW_VK_ERR("vkCreateMetalSurfaceEXT", err); return surface; } @@ -953,7 +969,7 @@ createInfo.surface = inst.wayland_surface; VkSurfaceKHR surface; - VkResult err = inst.dll.vkCreateWaylandSurfaceKHR(inst.instance, &createInfo, nullptr, &surface); + VkResult err = inst.dll.fp_vkCreateWaylandSurfaceKHR(inst.instance, &createInfo, nullptr, &surface); if (err) THROW_VK_ERR("vkCreateWaylandSurfaceKHR", err); return surface; } @@ -972,7 +988,7 @@ createInfo.flags = 0; createInfo.window = (struct ANativeWindow *)(inst.window); - err = inst.dll.vkCreateAndroidSurfaceKHR(inst.inst, &createInfo, NULL, &inst.surface); + err = inst.dll.fp_vkCreateAndroidSurfaceKHR(inst.inst, &createInfo, NULL, &inst.surface); THROW_VK_ERR("vkCreateAndroidSurfaceKHR", err); } static VkSurfaceKHR AppDestroyAndroidSurface(AppInstance &inst) {} @@ -987,7 +1003,7 @@ const char *display_var = getenv("DISPLAY"); if (display_var == nullptr || strlen(display_var) == 0) { has_display = false; - THROW_ERR("'DISPLAY' environment variable not set... skipping surface info"); + std::cerr << "'DISPLAY' environment variable not set... skipping surface info\n"; } #endif @@ -1183,7 +1199,7 @@ std::vector<VkPhysicalDeviceProperties> props(group.physicalDeviceCount); for (uint32_t i = 0; i < group.physicalDeviceCount; ++i) { - inst.dll.vkGetPhysicalDeviceProperties(group.physicalDevices[i], &props[i]); + inst.dll.fp_vkGetPhysicalDeviceProperties(group.physicalDevices[i], &props[i]); } return props; @@ -1207,12 +1223,12 @@ VkDevice logical_device = VK_NULL_HANDLE; - VkResult err = inst.dll.vkCreateDevice(group.physicalDevices[0], &device_ci, nullptr, &logical_device); + VkResult err = inst.dll.fp_vkCreateDevice(group.physicalDevices[0], &device_ci, nullptr, &logical_device); if (err != VK_SUCCESS && err != VK_ERROR_EXTENSION_NOT_PRESENT) THROW_VK_ERR("vkCreateDevice", err); if (err == VK_ERROR_EXTENSION_NOT_PRESENT) { VkDeviceGroupPresentCapabilitiesKHR group_capabilities = {VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, nullptr}; - inst.dll.vkDestroyDevice(logical_device, nullptr); + inst.dll.fp_vkDestroyDevice(logical_device, nullptr); return std::pair<bool, VkDeviceGroupPresentCapabilitiesKHR>(false, group_capabilities); } @@ -1223,7 +1239,7 @@ err = inst.ext_funcs.vkGetDeviceGroupPresentCapabilitiesKHR(logical_device, &group_capabilities); if (err) THROW_VK_ERR("vkGetDeviceGroupPresentCapabilitiesKHR", err); - inst.dll.vkDestroyDevice(logical_device, nullptr); + inst.dll.fp_vkDestroyDevice(logical_device, nullptr); return std::pair<bool, VkDeviceGroupPresentCapabilitiesKHR>(true, group_capabilities); } @@ -1296,7 +1312,7 @@ AppGpu(AppInstance &inst, uint32_t id, VkPhysicalDevice phys_device, pNextChainInfos chainInfos) : inst(inst), id(id), phys_device(phys_device) { - inst.dll.vkGetPhysicalDeviceProperties(phys_device, &props); + inst.dll.fp_vkGetPhysicalDeviceProperties(phys_device, &props); // needs to find the minimum of the instance and device version, and use that to print the device info uint32_t gpu_version = props.apiVersion < inst.instance_version ? props.apiVersion : inst.instance_version; @@ -1309,11 +1325,11 @@ inst.ext_funcs.vkGetPhysicalDeviceProperties2KHR(phys_device, &props2); } /* get queue count */ - inst.dll.vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, nullptr); + inst.dll.fp_vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, nullptr); queue_props.resize(queue_count); - inst.dll.vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, queue_props.data()); + inst.dll.fp_vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, queue_props.data()); if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { queue_props2.resize(queue_count); @@ -1326,9 +1342,9 @@ inst.ext_funcs.vkGetPhysicalDeviceQueueFamilyProperties2KHR(phys_device, &queue_count, queue_props2.data()); } - inst.dll.vkGetPhysicalDeviceMemoryProperties(phys_device, &memory_props); + inst.dll.fp_vkGetPhysicalDeviceMemoryProperties(phys_device, &memory_props); - inst.dll.vkGetPhysicalDeviceFeatures(phys_device, &features); + inst.dll.fp_vkGetPhysicalDeviceFeatures(phys_device, &features); if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { memory_props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR; @@ -1355,7 +1371,7 @@ const VkDeviceCreateInfo device_ci = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, nullptr, 0, 1, &q_ci, 0, nullptr, 0, nullptr, &enabled_features}; - VkResult err = inst.dll.vkCreateDevice(phys_device, &device_ci, nullptr, &dev); + VkResult err = inst.dll.fp_vkCreateDevice(phys_device, &device_ci, nullptr, &dev); if (err) THROW_VK_ERR("vkCreateDevice", err); const VkFormat color_format = VK_FORMAT_R8G8B8A8_UNORM; @@ -1375,7 +1391,7 @@ mem_type_res_support.image[tiling][fmt_i].transient_supported = true; VkFormatProperties fmt_props; - inst.dll.vkGetPhysicalDeviceFormatProperties(phys_device, formats[fmt_i], &fmt_props); + inst.dll.fp_vkGetPhysicalDeviceFormatProperties(phys_device, formats[fmt_i], &fmt_props); if ((tiling == VK_IMAGE_TILING_OPTIMAL && fmt_props.optimalTilingFeatures == 0) || (tiling == VK_IMAGE_TILING_LINEAR && fmt_props.linearTilingFeatures == 0)) { mem_type_res_support.image[tiling][fmt_i].regular_supported = false; @@ -1420,9 +1436,9 @@ } VkImageFormatProperties img_props; - err = inst.dll.vkGetPhysicalDeviceImageFormatProperties(phys_device, image_ci.format, image_ci.imageType, - image_ci.tiling, image_ci.usage, image_ci.flags, - &img_props); + err = inst.dll.fp_vkGetPhysicalDeviceImageFormatProperties(phys_device, image_ci.format, image_ci.imageType, + image_ci.tiling, image_ci.usage, image_ci.flags, + &img_props); uint32_t *memtypes; bool *support; @@ -1448,14 +1464,14 @@ if (err != VK_SUCCESS) THROW_VK_ERR("vkGetPhysicalDeviceImageFormatProperties", err); VkImage dummy_img; - err = inst.dll.vkCreateImage(dev, &image_ci, nullptr, &dummy_img); + err = inst.dll.fp_vkCreateImage(dev, &image_ci, nullptr, &dummy_img); if (err) THROW_VK_ERR("vkCreateImage", err); VkMemoryRequirements mem_req; - inst.dll.vkGetImageMemoryRequirements(dev, dummy_img, &mem_req); + inst.dll.fp_vkGetImageMemoryRequirements(dev, dummy_img, &mem_req); *memtypes = mem_req.memoryTypeBits; - inst.dll.vkDestroyImage(dev, dummy_img, nullptr); + inst.dll.fp_vkDestroyImage(dev, dummy_img, nullptr); } } } @@ -1515,7 +1531,7 @@ }; } ~AppGpu() { - inst.dll.vkDestroyDevice(dev, nullptr); + inst.dll.fp_vkDestroyDevice(dev, nullptr); if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { freepNextChain(static_cast<VkStructureHeader *>(features2.pNext)); @@ -1538,7 +1554,7 @@ std::vector<VkExtensionProperties> AppGetPhysicalDeviceLayerExtensions(char *layer_name) { return GetVector<VkExtensionProperties>("vkEnumerateDeviceExtensionProperties", - inst.dll.vkEnumerateDeviceExtensionProperties, phys_device, layer_name); + inst.dll.fp_vkEnumerateDeviceExtensionProperties, phys_device, layer_name); } // Helper function to determine whether a format range is currently supported. @@ -1628,7 +1644,7 @@ for (auto fmtRange : gpu.supported_format_ranges) { for (int32_t fmt = fmtRange.first_format; fmt <= fmtRange.last_format; ++fmt) { VkFormatProperties props; - gpu.inst.dll.vkGetPhysicalDeviceFormatProperties(gpu.phys_device, static_cast<VkFormat>(fmt), &props); + gpu.inst.dll.fp_vkGetPhysicalDeviceFormatProperties(gpu.phys_device, static_cast<VkFormat>(fmt), &props); PropFlags pf = {props.linearTilingFeatures, props.optimalTilingFeatures, props.bufferFeatures};
