Hello community, here is the log from the commit of package vulkan-loader for openSUSE:Factory checked in at 2019-10-23 15:33:10 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/vulkan-loader (Old) and /work/SRC/openSUSE:Factory/.vulkan-loader.new.2352 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "vulkan-loader" Wed Oct 23 15:33:10 2019 rev:12 rq:738943 version:1.1.124 Changes: -------- --- /work/SRC/openSUSE:Factory/vulkan-loader/vulkan-loader.changes 2019-10-07 13:36:42.245059738 +0200 +++ /work/SRC/openSUSE:Factory/.vulkan-loader.new.2352/vulkan-loader.changes 2019-10-23 15:33:11.917498871 +0200 @@ -1,0 +2,9 @@ +Wed Oct 16 20:56:59 UTC 2019 - Jan Engelhardt <[email protected]> + +- Update to release 1.1.124 + * loader: Add support for metal surfaces + * loader: Use dxgi1_2 header instead of 1_6 + * loader: Dynamically load DXGI + * layers: allow concurrent layer device creation + +------------------------------------------------------------------- Old: ---- v1.1.123.tar.gz New: ---- v1.1.124.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ vulkan-loader.spec ++++++ --- /var/tmp/diff_new_pack.Da3kU1/_old 2019-10-23 15:33:12.461499497 +0200 +++ /var/tmp/diff_new_pack.Da3kU1/_new 2019-10-23 15:33:12.461499497 +0200 @@ -16,15 +16,15 @@ # -%define version_unconverted 1.1.123 +%define version_unconverted 1.1.124 Name: vulkan-loader %define lname libvulkan1 -Version: 1.1.123 +Version: 1.1.124 Release: 0 Summary: Reference ICD loader for Vulkan License: Apache-2.0 -Group: Development/Libraries/C and C++ +Group: development vulkan URL: https://github.com/KhronosGroup/Vulkan-Loader Source: https://github.com/KhronosGroup/Vulkan-Loader/archive/v%version.tar.gz ++++++ v1.1.123.tar.gz -> v1.1.124.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/CMakeLists.txt new/Vulkan-Loader-1.1.124/CMakeLists.txt --- old/Vulkan-Loader-1.1.123/CMakeLists.txt 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/CMakeLists.txt 2019-10-07 18:17:08.000000000 +0200 @@ -24,7 +24,7 @@ enable_testing() -add_definitions(-DAPI_NAME="Vulkan") +set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS API_NAME="Vulkan") set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") find_package(PythonInterp 3 QUIET) @@ -133,21 +133,32 @@ endif() if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang") - set(COMMON_COMPILE_FLAGS "-Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -Wno-stringop-truncation -Wno-stringop-overflow") + set(COMMON_COMPILE_FLAGS "-Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers") set(COMMON_COMPILE_FLAGS "${COMMON_COMPILE_FLAGS} -fno-strict-aliasing -fno-builtin-memcmp") # For GCC version 7.1 or greater, we need to disable the implicit fallthrough warning since there's no consistent way to satisfy # all compilers until they all accept the C++17 standard - if(CMAKE_COMPILER_IS_GNUCC AND NOT (CMAKE_CXX_COMPILER_VERSION LESS 7.1)) - set(COMMON_COMPILE_FLAGS "${COMMON_COMPILE_FLAGS} -Wimplicit-fallthrough=0") + if(CMAKE_COMPILER_IS_GNUCC) + set(COMMON_COMPILE_FLAGS "${COMMON_COMPILE_FLAGS} -Wno-stringop-truncation -Wno-stringop-overflow") + if(CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 7.1) + set(COMMON_COMPILE_FLAGS "${COMMON_COMPILE_FLAGS} -Wimplicit-fallthrough=0") + endif() endif() if(APPLE) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMMON_COMPILE_FLAGS}") + #clang-cl on Windows + elseif((CMAKE_C_COMPILER_ID MATCHES "Clang") AND (CMAKE_CXX_SIMULATE_ID MATCHES "MSVC")) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Xclang -std=c99 ${COMMON_COMPILE_FLAGS}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Xclang -std=c++11 -fno-rtti") + # clang (not clang-cl) or gcc else() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 ${COMMON_COMPILE_FLAGS}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-rtti") endif() - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_COMPILE_FLAGS} -std=c++11 -fno-rtti") + + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_COMPILE_FLAGS}") + if(UNIX) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") @@ -176,18 +187,17 @@ if(UNIX) - add_definitions(-DFALLBACK_CONFIG_DIRS="${FALLBACK_CONFIG_DIRS}") - add_definitions(-DFALLBACK_DATA_DIRS="${FALLBACK_DATA_DIRS}") + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS FALLBACK_CONFIG_DIRS="${FALLBACK_CONFIG_DIRS}" FALLBACK_DATA_DIRS="${FALLBACK_DATA_DIRS}") if(NOT (SYSCONFDIR STREQUAL "")) # SYSCONFDIR is specified, use it and do not force /etc. - add_definitions(-DSYSCONFDIR="${SYSCONFDIR}") + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS SYSCONFDIR="${SYSCONFDIR}") else() - add_definitions(-DSYSCONFDIR="${CMAKE_INSTALL_FULL_SYSCONFDIR}") + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS SYSCONFDIR="${CMAKE_INSTALL_FULL_SYSCONFDIR}") # Make sure /etc is searched by the loader if(NOT (CMAKE_INSTALL_FULL_SYSCONFDIR STREQUAL "/etc")) - add_definitions(-DEXTRASYSCONFDIR="/etc") + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS EXTRASYSCONFDIR="/etc") endif() endif() endif() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/CMakeLists.txt new/Vulkan-Loader-1.1.124/loader/CMakeLists.txt --- old/Vulkan-Loader-1.1.123/loader/CMakeLists.txt 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/CMakeLists.txt 2019-10-07 18:17:08.000000000 +0200 @@ -26,7 +26,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/loader_cmake_config.h.in ${CMAKE_CURRENT_BINARY_DIR}/loader_cmake_config.h) if(WIN32) - add_definitions(-DVK_USE_PLATFORM_WIN32_KHR -DWIN32_LEAN_AND_MEAN) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_WIN32_KHR WIN32_LEAN_AND_MEAN) if(MSVC AND NOT MSVC_VERSION LESS 1900) # Enable control flow guard message(STATUS "Building loader with control flow guard") @@ -35,20 +35,20 @@ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /guard:cf") endif() elseif(ANDROID) - add_definitions(-DVK_USE_PLATFORM_ANDROID_KHR) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_ANDROID_KHR) elseif(APPLE) - add_definitions(-DVK_USE_PLATFORM_MACOS_MVK) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_MACOS_MVK VK_USE_PLATFORM_METAL_EXT) elseif(UNIX AND NOT APPLE) # i.e.: Linux if(BUILD_WSI_XCB_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_XCB_KHR) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_XCB_KHR) endif() if(BUILD_WSI_XLIB_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_XLIB_KHR -DVK_USE_PLATFORM_XLIB_XRANDR_EXT) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_XLIB_KHR VK_USE_PLATFORM_XLIB_XRANDR_EXT) endif() if(BUILD_WSI_WAYLAND_SUPPORT) - add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_WAYLAND_KHR) endif() else() message(FATAL_ERROR "Unsupported Platform!") @@ -153,7 +153,7 @@ check_include_file("cet.h" HAVE_CET_H) if(HAVE_CET_H) - add_definitions(-DHAVE_CET_H) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS HAVE_CET_H) endif() file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/asm_test.S ".intel_syntax noprefix\n.text\n.global sample\nsample:\nmov ecx, [eax + 16]\n") @@ -174,7 +174,7 @@ endif() if(WIN32) - add_library(loader-norm OBJECT ${NORMAL_LOADER_SRCS} dirent_on_windows.c) + add_library(loader-norm OBJECT ${NORMAL_LOADER_SRCS} dirent_on_windows.c dxgi_loader.c) target_compile_options(loader-norm PUBLIC "$<$<CONFIG:DEBUG>:${LOCAL_C_FLAGS_DBG}>") target_compile_options(loader-norm PUBLIC ${MSVC_LOADER_COMPILE_OPTIONS}) target_include_directories(loader-norm PRIVATE "$<TARGET_PROPERTY:Vulkan::Headers,INTERFACE_INCLUDE_DIRECTORIES>") @@ -213,10 +213,10 @@ endif() if(ENABLE_WIN10_ONECORE) - target_link_libraries(vulkan OneCoreUAP.lib LIBCMT.LIB LIBCMTD.LIB LIBVCRUNTIME.LIB LIBUCRT.LIB Dxgi) + target_link_libraries(vulkan OneCoreUAP.lib LIBCMT.LIB LIBCMTD.LIB LIBVCRUNTIME.LIB LIBUCRT.LIB) set_target_properties(vulkan PROPERTIES LINK_FLAGS "/NODEFAULTLIB") else() - target_link_libraries(vulkan Cfgmgr32 Dxgi) + target_link_libraries(vulkan Cfgmgr32) endif() add_dependencies(vulkan loader_asm_gen_files) @@ -233,13 +233,13 @@ add_library(vulkan SHARED ${NORMAL_LOADER_SRCS} ${OPT_LOADER_SRCS}) add_dependencies(vulkan loader_asm_gen_files) - target_compile_definitions(vulkan PUBLIC -DLOADER_DYNAMIC_LIB) + target_compile_definitions(vulkan PUBLIC LOADER_DYNAMIC_LIB) set_target_properties(vulkan PROPERTIES SOVERSION "1" VERSION "${VulkanHeaders_VERSION_MAJOR}.${VulkanHeaders_VERSION_MINOR}.${VulkanHeaders_VERSION_PATCH}") - target_link_libraries(vulkan ${CMAKE_DL_LIBS} -lpthread -lm) + target_link_libraries(vulkan ${CMAKE_DL_LIBS} pthread m) target_link_libraries(vulkan Vulkan::Headers) if(APPLE) @@ -266,7 +266,7 @@ ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan.hpp) add_library(vulkan-framework SHARED ${NORMAL_LOADER_SRCS} ${OPT_LOADER_SRCS} ${FRAMEWORK_HEADERS}) add_dependencies(vulkan-framework loader_asm_gen_files) - target_compile_definitions(vulkan-framework PUBLIC -DLOADER_DYNAMIC_LIB) + target_compile_definitions(vulkan-framework PUBLIC LOADER_DYNAMIC_LIB) target_link_libraries(vulkan-framework -ldl -lpthread -lm "-framework CoreFoundation") target_link_libraries(vulkan-framework Vulkan::Headers) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/dxgi_loader.c new/Vulkan-Loader-1.1.124/loader/dxgi_loader.c --- old/Vulkan-Loader-1.1.123/loader/dxgi_loader.c 1970-01-01 01:00:00.000000000 +0100 +++ new/Vulkan-Loader-1.1.124/loader/dxgi_loader.c 2019-10-07 18:17:08.000000000 +0200 @@ -0,0 +1,23 @@ +#include "dxgi_loader.h" + +#include <strsafe.h> + +static HMODULE load_dxgi_module() { + TCHAR systemPath[MAX_PATH] = ""; + GetSystemDirectory(systemPath, MAX_PATH); + StringCchCat(systemPath, MAX_PATH, TEXT("\\dxgi.dll")); + + return LoadLibrary(systemPath); +} + +typedef HRESULT (APIENTRY *PFN_CreateDXGIFactory1)(REFIID riid, void **ppFactory); + +HRESULT dyn_CreateDXGIFactory1(REFIID riid, void **ppFactory) { + PFN_CreateDXGIFactory1 fpCreateDXGIFactory1 = + (PFN_CreateDXGIFactory1)GetProcAddress(load_dxgi_module(), "CreateDXGIFactory1"); + + if (fpCreateDXGIFactory1 != NULL) + return fpCreateDXGIFactory1(riid, ppFactory); + + return DXGI_ERROR_NOT_FOUND; +} \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/dxgi_loader.h new/Vulkan-Loader-1.1.124/loader/dxgi_loader.h --- old/Vulkan-Loader-1.1.123/loader/dxgi_loader.h 1970-01-01 01:00:00.000000000 +0100 +++ new/Vulkan-Loader-1.1.124/loader/dxgi_loader.h 2019-10-07 18:17:08.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef DXGI_LOADER_H +#define DXGI_LOADER_H + +#include <dxgi1_2.h> + +HRESULT dyn_CreateDXGIFactory1(REFIID riid, void **ppFactory); + +#endif \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/generated/vk_dispatch_table_helper.h new/Vulkan-Loader-1.1.124/loader/generated/vk_dispatch_table_helper.h --- old/Vulkan-Loader-1.1.123/loader/generated/vk_dispatch_table_helper.h 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/generated/vk_dispatch_table_helper.h 2019-10-07 18:17:08.000000000 +0200 @@ -86,6 +86,9 @@ static VKAPI_ATTR void VKAPI_CALL StubGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { }; static VKAPI_ATTR void VKAPI_CALL StubCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { }; static VKAPI_ATTR void VKAPI_CALL StubCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { }; +static VKAPI_ATTR VkResult VKAPI_CALL StubGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { return VK_SUCCESS; }; +static VKAPI_ATTR VkResult VKAPI_CALL StubWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout) { return VK_SUCCESS; }; +static VKAPI_ATTR VkResult VKAPI_CALL StubSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo) { return VK_SUCCESS; }; static VKAPI_ATTR VkResult VKAPI_CALL StubGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { return VK_SUCCESS; }; static VKAPI_ATTR VkResult VKAPI_CALL StubGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { return VK_SUCCESS; }; static VKAPI_ATTR VkResult VKAPI_CALL StubGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { return VK_SUCCESS; }; @@ -429,6 +432,12 @@ if (table->CmdDrawIndirectCountKHR == nullptr) { table->CmdDrawIndirectCountKHR = (PFN_vkCmdDrawIndirectCountKHR)StubCmdDrawIndirectCountKHR; } table->CmdDrawIndexedIndirectCountKHR = (PFN_vkCmdDrawIndexedIndirectCountKHR) gpa(device, "vkCmdDrawIndexedIndirectCountKHR"); if (table->CmdDrawIndexedIndirectCountKHR == nullptr) { table->CmdDrawIndexedIndirectCountKHR = (PFN_vkCmdDrawIndexedIndirectCountKHR)StubCmdDrawIndexedIndirectCountKHR; } + table->GetSemaphoreCounterValueKHR = (PFN_vkGetSemaphoreCounterValueKHR) gpa(device, "vkGetSemaphoreCounterValueKHR"); + if (table->GetSemaphoreCounterValueKHR == nullptr) { table->GetSemaphoreCounterValueKHR = (PFN_vkGetSemaphoreCounterValueKHR)StubGetSemaphoreCounterValueKHR; } + table->WaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR) gpa(device, "vkWaitSemaphoresKHR"); + if (table->WaitSemaphoresKHR == nullptr) { table->WaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)StubWaitSemaphoresKHR; } + table->SignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR) gpa(device, "vkSignalSemaphoreKHR"); + if (table->SignalSemaphoreKHR == nullptr) { table->SignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)StubSignalSemaphoreKHR; } table->GetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR) gpa(device, "vkGetPipelineExecutablePropertiesKHR"); if (table->GetPipelineExecutablePropertiesKHR == nullptr) { table->GetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR)StubGetPipelineExecutablePropertiesKHR; } table->GetPipelineExecutableStatisticsKHR = (PFN_vkGetPipelineExecutableStatisticsKHR) gpa(device, "vkGetPipelineExecutableStatisticsKHR"); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/generated/vk_layer_dispatch_table.h new/Vulkan-Loader-1.1.124/loader/generated/vk_layer_dispatch_table.h --- old/Vulkan-Loader-1.1.123/loader/generated/vk_layer_dispatch_table.h 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/generated/vk_layer_dispatch_table.h 2019-10-07 18:17:08.000000000 +0200 @@ -470,6 +470,11 @@ PFN_vkCmdDrawIndirectCountKHR CmdDrawIndirectCountKHR; PFN_vkCmdDrawIndexedIndirectCountKHR CmdDrawIndexedIndirectCountKHR; + // ---- VK_KHR_timeline_semaphore extension commands + PFN_vkGetSemaphoreCounterValueKHR GetSemaphoreCounterValueKHR; + PFN_vkWaitSemaphoresKHR WaitSemaphoresKHR; + PFN_vkSignalSemaphoreKHR SignalSemaphoreKHR; + // ---- VK_KHR_pipeline_executable_properties extension commands PFN_vkGetPipelineExecutablePropertiesKHR GetPipelineExecutablePropertiesKHR; PFN_vkGetPipelineExecutableStatisticsKHR GetPipelineExecutableStatisticsKHR; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/generated/vk_loader_extensions.c new/Vulkan-Loader-1.1.124/loader/generated/vk_loader_extensions.c --- old/Vulkan-Loader-1.1.123/loader/generated/vk_loader_extensions.c 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/generated/vk_loader_extensions.c 2019-10-07 18:17:08.000000000 +0200 @@ -527,6 +527,11 @@ table->CmdDrawIndirectCountKHR = (PFN_vkCmdDrawIndirectCountKHR)gdpa(dev, "vkCmdDrawIndirectCountKHR"); table->CmdDrawIndexedIndirectCountKHR = (PFN_vkCmdDrawIndexedIndirectCountKHR)gdpa(dev, "vkCmdDrawIndexedIndirectCountKHR"); + // ---- VK_KHR_timeline_semaphore extension commands + table->GetSemaphoreCounterValueKHR = (PFN_vkGetSemaphoreCounterValueKHR)gdpa(dev, "vkGetSemaphoreCounterValueKHR"); + table->WaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)gdpa(dev, "vkWaitSemaphoresKHR"); + table->SignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)gdpa(dev, "vkSignalSemaphoreKHR"); + // ---- VK_KHR_pipeline_executable_properties extension commands table->GetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR)gdpa(dev, "vkGetPipelineExecutablePropertiesKHR"); table->GetPipelineExecutableStatisticsKHR = (PFN_vkGetPipelineExecutableStatisticsKHR)gdpa(dev, "vkGetPipelineExecutableStatisticsKHR"); @@ -1146,6 +1151,11 @@ if (!strcmp(name, "CmdDrawIndirectCountKHR")) return (void *)table->CmdDrawIndirectCountKHR; if (!strcmp(name, "CmdDrawIndexedIndirectCountKHR")) return (void *)table->CmdDrawIndexedIndirectCountKHR; + // ---- VK_KHR_timeline_semaphore extension commands + if (!strcmp(name, "GetSemaphoreCounterValueKHR")) return (void *)table->GetSemaphoreCounterValueKHR; + if (!strcmp(name, "WaitSemaphoresKHR")) return (void *)table->WaitSemaphoresKHR; + if (!strcmp(name, "SignalSemaphoreKHR")) return (void *)table->SignalSemaphoreKHR; + // ---- VK_KHR_pipeline_executable_properties extension commands if (!strcmp(name, "GetPipelineExecutablePropertiesKHR")) return (void *)table->GetPipelineExecutablePropertiesKHR; if (!strcmp(name, "GetPipelineExecutableStatisticsKHR")) return (void *)table->GetPipelineExecutableStatisticsKHR; @@ -1901,6 +1911,32 @@ } +// ---- VK_KHR_timeline_semaphore extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetSemaphoreCounterValueKHR(device, semaphore, pValue); +} + +VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfoKHR* pWaitInfo, + uint64_t timeout) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->WaitSemaphoresKHR(device, pWaitInfo, timeout); +} + +VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfoKHR* pSignalInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->SignalSemaphoreKHR(device, pSignalInfo); +} + + // ---- VK_KHR_pipeline_executable_properties extension trampoline/terminators VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( @@ -3051,28 +3087,6 @@ #endif // VK_USE_PLATFORM_FUCHSIA -// ---- VK_EXT_metal_surface extension trampoline/terminators - -#ifdef VK_USE_PLATFORM_METAL_EXT -VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( - VkInstance instance, - const VkMetalSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { -#error("Not implemented. Likely needs to be manually generated!"); - return disp->CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMetalSurfaceEXT( - VkInstance instance, - const VkMetalSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { -#error("Not implemented. Likely needs to be manually generated!"); -} - -#endif // VK_USE_PLATFORM_METAL_EXT - // ---- VK_EXT_buffer_device_address extension trampoline/terminators VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( @@ -3463,6 +3477,20 @@ return true; } + // ---- VK_KHR_timeline_semaphore extension commands + if (!strcmp("vkGetSemaphoreCounterValueKHR", name)) { + *addr = (void *)GetSemaphoreCounterValueKHR; + return true; + } + if (!strcmp("vkWaitSemaphoresKHR", name)) { + *addr = (void *)WaitSemaphoresKHR; + return true; + } + if (!strcmp("vkSignalSemaphoreKHR", name)) { + *addr = (void *)SignalSemaphoreKHR; + return true; + } + // ---- VK_KHR_pipeline_executable_properties extension commands if (!strcmp("vkGetPipelineExecutablePropertiesKHR", name)) { *addr = (void *)GetPipelineExecutablePropertiesKHR; @@ -3979,16 +4007,6 @@ } #endif // VK_USE_PLATFORM_FUCHSIA - // ---- VK_EXT_metal_surface extension commands -#ifdef VK_USE_PLATFORM_METAL_EXT - if (!strcmp("vkCreateMetalSurfaceEXT", name)) { - *addr = (ptr_instance->enabled_known_extensions.ext_metal_surface == 1) - ? (void *)CreateMetalSurfaceEXT - : NULL; - return true; - } -#endif // VK_USE_PLATFORM_METAL_EXT - // ---- VK_EXT_buffer_device_address extension commands if (!strcmp("vkGetBufferDeviceAddressEXT", name)) { *addr = (void *)GetBufferDeviceAddressEXT; @@ -4114,12 +4132,6 @@ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME)) { ptr_instance->enabled_known_extensions.fuchsia_imagepipe_surface = 1; #endif // VK_USE_PLATFORM_FUCHSIA - - // ---- VK_EXT_metal_surface extension commands -#ifdef VK_USE_PLATFORM_METAL_EXT - } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_METAL_SURFACE_EXTENSION_NAME)) { - ptr_instance->enabled_known_extensions.ext_metal_surface = 1; -#endif // VK_USE_PLATFORM_METAL_EXT } } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/generated/vk_loader_extensions.h new/Vulkan-Loader-1.1.124/loader/generated/vk_loader_extensions.h --- old/Vulkan-Loader-1.1.123/loader/generated/vk_loader_extensions.h 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/generated/vk_loader_extensions.h 2019-10-07 18:17:08.000000000 +0200 @@ -437,7 +437,6 @@ uint8_t ext_display_surface_counter : 1; uint8_t ext_debug_utils : 1; uint8_t fuchsia_imagepipe_surface : 1; - uint8_t ext_metal_surface : 1; }; uint64_t padding[4]; }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/loader.c new/Vulkan-Loader-1.1.124/loader/loader.c --- old/Vulkan-Loader-1.1.123/loader/loader.c 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/loader.c 2019-10-07 18:17:08.000000000 +0200 @@ -71,7 +71,7 @@ #include <devpkey.h> #include <winternl.h> #include <d3dkmthk.h> -#include <Dxgi1_6.h> +#include "dxgi_loader.h" typedef _Check_return_ NTSTATUS (APIENTRY *PFN_D3DKMTEnumAdapters2)(const D3DKMT_ENUMADAPTERS2*); typedef _Check_return_ NTSTATUS (APIENTRY *PFN_D3DKMTQueryAdapterInfo)(const D3DKMT_QUERYADAPTERINFO*); @@ -873,7 +873,7 @@ } if (is_driver) { - HRESULT hres = CreateDXGIFactory1(&IID_IDXGIFactory1, &dxgi_factory); + HRESULT hres = dyn_CreateDXGIFactory1(&IID_IDXGIFactory1, &dxgi_factory); if (hres != S_OK) { loader_log( inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, @@ -2056,7 +2056,8 @@ for (struct loader_device *dev = icd_term->logical_device_list; dev; dev = dev->next) // Value comparison of device prevents object wrapping by layers if (loader_get_dispatch(dev->icd_device) == loader_get_dispatch(device) || - loader_get_dispatch(dev->chain_device) == loader_get_dispatch(device)) { + (dev->chain_device != VK_NULL_HANDLE && + loader_get_dispatch(dev->chain_device) == loader_get_dispatch(device))) { *found_dev = dev; if (NULL != icd_index) { *icd_index = index; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/loader.h new/Vulkan-Loader-1.1.124/loader/loader.h --- old/Vulkan-Loader-1.1.123/loader/loader.h 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/loader.h 2019-10-07 18:17:08.000000000 +0200 @@ -333,6 +333,9 @@ bool wsi_ios_surface_enabled; #endif bool wsi_headless_surface_enabled; +#if defined(VK_USE_PLATFORM_METAL_EXT) + bool wsi_metal_surface_enabled; +#endif bool wsi_display_enabled; bool wsi_display_props2_enabled; }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/wsi.c new/Vulkan-Loader-1.1.124/loader/wsi.c --- old/Vulkan-Loader-1.1.123/loader/wsi.c 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/wsi.c 2019-10-07 18:17:08.000000000 +0200 @@ -1,7 +1,7 @@ /* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. + * Copyright (c) 2015-2016, 2019 The Khronos Group Inc. + * Copyright (c) 2015-2016, 2019 Valve Corporation + * Copyright (c) 2015-2016, 2019 LunarG, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,6 +19,7 @@ * Author: Jon Ashburn <[email protected]> * Author: Ian Elliott <[email protected]> * Author: Mark Lobodzinski <[email protected]> + * Author: Lenny Komow <[email protected]> */ #ifndef _GNU_SOURCE @@ -60,9 +61,11 @@ #ifdef VK_USE_PLATFORM_IOS_MVK ptr_instance->wsi_ios_surface_enabled = false; #endif // VK_USE_PLATFORM_IOS_MVK - ptr_instance->wsi_display_enabled = false; ptr_instance->wsi_display_props2_enabled = false; +#ifdef VK_USE_PLATFORM_METAL_EXT + ptr_instance->wsi_metal_surface_enabled = false; +#endif // VK_USE_PLATFORM_METAL_EXT for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) { @@ -115,6 +118,12 @@ ptr_instance->wsi_headless_surface_enabled = true; continue; } +#if defined(VK_USE_PLATFORM_METAL_EXT) + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_METAL_SURFACE_EXTENSION_NAME) == 0) { + ptr_instance->wsi_metal_surface_enabled = true; + continue; + } +#endif if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) { ptr_instance->wsi_display_enabled = true; continue; @@ -1169,6 +1178,72 @@ #endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_METAL_EXT) + +LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(VkInstance instance, + const VkMetalSurfaceCreateInfoEXT *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkSurfaceKHR *pSurface) { + const VkLayerInstanceDispatchTable *disp = loader_get_instance_layer_dispatch(instance); + return disp->CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { + VkResult result = VK_SUCCESS; + VkIcdSurface *icd_surface = NULL; + uint32_t i; + + // First, check to ensure the appropriate extension was enabled: + struct loader_instance *ptr_instance = loader_get_instance(instance); + if (!ptr_instance->wsi_metal_surface_enabled) { + loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "VK_EXT_metal_surface extension not enabled. vkCreateMetalSurfaceEXT will not be executed.\n"); + } + + // Next, if so, proceed with the implementation of this function: + icd_surface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(icd_surface->metal_surf.base), sizeof(icd_surface->metal_surf)); + if (icd_surface == NULL) { + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + + icd_surface->metal_surf.base.platform = VK_ICD_WSI_PLATFORM_METAL; + icd_surface->metal_surf.pLayer = pCreateInfo->pLayer; + + // Loop through each ICD and determine if they need to create a surface + i = 0; + for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, ++i) { + if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { + if (icd_term->dispatch.CreateMetalSurfaceEXT != NULL) { + result = icd_term->dispatch.CreateMetalSurfaceEXT(icd_term->instance, pCreateInfo, pAllocator, + &icd_surface->real_icd_surfaces[i]); + if (result != VK_SUCCESS) { + goto out; + } + } + } + } + *pSurface = (VkSurfaceKHR)icd_surface; + +out: + if (result != VK_SUCCESS && icd_surface != NULL) { + if (icd_surface->real_icd_surfaces != NULL) { + i = 0; + for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, ++i) { + if (icd_surface->real_icd_surfaces[i] == VK_NULL_HANDLE && icd_term->dispatch.DestroySurfaceKHR != NULL) { + icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, icd_surface->real_icd_surfaces[i], pAllocator); + } + } + loader_instance_heap_free(ptr_instance, icd_surface->real_icd_surfaces); + } + loader_instance_heap_free(ptr_instance, icd_surface); + } + return result; +} + +#endif + // Functions for the VK_KHR_display instance extension: LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, @@ -1882,6 +1957,14 @@ return true; } +#if defined(VK_USE_PLATFORM_METAL_EXT) + // Functions for the VK_MVK_macos_surface extension: + if (!strcmp("vkCreateMetalSurfaceEXT", name)) { + *addr = ptr_instance->wsi_metal_surface_enabled ? (void *)vkCreateMetalSurfaceEXT : NULL; + return true; + } +#endif // VK_USE_PLATFORM_METAL_EXT + // Functions for VK_KHR_display extension: if (!strcmp("vkGetPhysicalDeviceDisplayPropertiesKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR : NULL; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/loader/wsi.h new/Vulkan-Loader-1.1.124/loader/wsi.h --- old/Vulkan-Loader-1.1.123/loader/wsi.h 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/loader/wsi.h 2019-10-07 18:17:08.000000000 +0200 @@ -42,6 +42,9 @@ #ifdef VK_USE_PLATFORM_MACOS_MVK VkIcdSurfaceMacOS macos_surf; #endif // VK_USE_PLATFORM_MACOS_MVK +#ifdef VK_USE_PLATFORM_METAL_EXT + VkIcdSurfaceMetal metal_surf; +#endif // VK_USE_PLATFORM_METAL_EXT VkIcdSurfaceDisplay display_surf; VkIcdSurfaceHeadless headless_surf; }; @@ -126,6 +129,10 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); #endif +#if defined(VK_USE_PLATFORM_METAL_EXT) +VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); +#endif VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/scripts/known_good.json new/Vulkan-Loader-1.1.124/scripts/known_good.json --- old/Vulkan-Loader-1.1.123/scripts/known_good.json 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/scripts/known_good.json 2019-10-07 18:17:08.000000000 +0200 @@ -6,7 +6,7 @@ "sub_dir" : "Vulkan-Headers", "build_dir" : "Vulkan-Headers/build", "install_dir" : "Vulkan-Headers/build/install", - "commit" : "v1.1.123" + "commit" : "v1.1.124" } ], "install_names" : { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.1.123/scripts/loader_extension_generator.py new/Vulkan-Loader-1.1.124/scripts/loader_extension_generator.py --- old/Vulkan-Loader-1.1.123/scripts/loader_extension_generator.py 2019-09-17 18:58:27.000000000 +0200 +++ new/Vulkan-Loader-1.1.124/scripts/loader_extension_generator.py 2019-10-07 18:17:08.000000000 +0200 @@ -37,6 +37,7 @@ 'VK_MVK_macos_surface', 'VK_MVK_ios_surface', 'VK_EXT_headless_surface', + 'VK_EXT_metal_surface', 'VK_KHR_swapchain', 'VK_KHR_display_swapchain', 'VK_KHR_get_display_properties2']
