Hello community, here is the log from the commit of package vulkan-headers for openSUSE:Factory checked in at 2018-12-21 08:19:56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/vulkan-headers (Old) and /work/SRC/openSUSE:Factory/.vulkan-headers.new.28833 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "vulkan-headers" Fri Dec 21 08:19:56 2018 rev:3 rq:659323 version:1.1.96 Changes: -------- --- /work/SRC/openSUSE:Factory/vulkan-headers/vulkan-headers.changes 2018-12-10 12:26:29.870637278 +0100 +++ /work/SRC/openSUSE:Factory/.vulkan-headers.new.28833/vulkan-headers.changes 2018-12-21 08:19:57.733651824 +0100 @@ -1,0 +2,6 @@ +Tue Dec 18 13:08:45 UTC 2018 - Jan Engelhardt <[email protected]> + +- Update to new upstream release 1.1.96 + * No changelog was provided + +------------------------------------------------------------------- Old: ---- Vulkan-Headers-1.1.95.tar.xz New: ---- Vulkan-Headers-1.1.96.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ vulkan-headers.spec ++++++ --- /var/tmp/diff_new_pack.ATOzyM/_old 2018-12-21 08:19:59.329650331 +0100 +++ /var/tmp/diff_new_pack.ATOzyM/_new 2018-12-21 08:19:59.329650331 +0100 @@ -16,9 +16,9 @@ # -%define version_unconverted 1.1.95 +%define version_unconverted 1.1.96 Name: vulkan-headers -Version: 1.1.95 +Version: 1.1.96 Release: 0 Summary: Vulkan C and C++ API header files License: Apache-2.0 ++++++ Vulkan-Headers-1.1.95.tar.xz -> Vulkan-Headers-1.1.96.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Headers-1.1.95/CMakeLists.txt new/Vulkan-Headers-1.1.96/CMakeLists.txt --- old/Vulkan-Headers-1.1.95/CMakeLists.txt 2018-12-03 17:42:21.000000000 +0100 +++ new/Vulkan-Headers-1.1.96/CMakeLists.txt 2018-12-17 17:57:13.000000000 +0100 @@ -36,8 +36,8 @@ # -------------------------------------------------------------------------------------------------------------------------------- -install(DIRECTORY "${CMAKE_SOURCE_DIR}/include/vulkan" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) -install(DIRECTORY "${CMAKE_SOURCE_DIR}/registry" DESTINATION ${CMAKE_INSTALL_DATADIR}/vulkan) +install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) +install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/registry" DESTINATION ${CMAKE_INSTALL_DATADIR}/vulkan) # uninstall target if(NOT TARGET uninstall) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Headers-1.1.95/include/vulkan/vulkan.hpp new/Vulkan-Headers-1.1.96/include/vulkan/vulkan.hpp --- old/Vulkan-Headers-1.1.95/include/vulkan/vulkan.hpp 2018-12-03 17:42:21.000000000 +0100 +++ new/Vulkan-Headers-1.1.96/include/vulkan/vulkan.hpp 2018-12-17 17:57:13.000000000 +0100 @@ -70,7 +70,7 @@ #undef MemoryBarrier #endif -static_assert( VK_HEADER_VERSION == 95 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 96 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -18534,10 +18534,10 @@ public: void* pNext = nullptr; - uint16_t pciDomain; - uint8_t pciBus; - uint8_t pciDevice; - uint8_t pciFunction; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; }; static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" ); @@ -43199,16 +43199,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector<UniquePipeline, Allocator> pipelines; + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" ); + std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines; pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) ); Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - pipelines.push_back( UniquePipeline( buffer[i], deleter ) ); + pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" ); @@ -43216,16 +43216,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector<UniquePipeline, Allocator> pipelines( vectorAllocator ); + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" ); + std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator ); pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) ); Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - pipelines.push_back( UniquePipeline( buffer[i], deleter ) ); + pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" ); @@ -43273,16 +43273,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector<UniquePipeline, Allocator> pipelines; + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" ); + std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines; pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) ); Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - pipelines.push_back( UniquePipeline( buffer[i], deleter ) ); + pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" ); @@ -43290,16 +43290,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector<UniquePipeline, Allocator> pipelines( vectorAllocator ); + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" ); + std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator ); pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) ); Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - pipelines.push_back( UniquePipeline( buffer[i], deleter ) ); + pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" ); @@ -43589,16 +43589,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const { - static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueDescriptorSet ), "DescriptorSet is greater than UniqueDescriptorSet!" ); - std::vector<UniqueDescriptorSet, Allocator> descriptorSets; + static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" ); + std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets; descriptorSets.reserve( allocateInfo.descriptorSetCount ); - DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueDescriptorSet ) - sizeof( DescriptorSet ) ) ); + DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) ); Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) ); PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d ); for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ ) { - descriptorSets.push_back( UniqueDescriptorSet( buffer[i], deleter ) ); + descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); @@ -43606,16 +43606,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const { - static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueDescriptorSet ), "DescriptorSet is greater than UniqueDescriptorSet!" ); - std::vector<UniqueDescriptorSet, Allocator> descriptorSets( vectorAllocator ); + static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" ); + std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets( vectorAllocator ); descriptorSets.reserve( allocateInfo.descriptorSetCount ); - DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueDescriptorSet ) - sizeof( DescriptorSet ) ) ); + DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) ); Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) ); PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d ); for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ ) { - descriptorSets.push_back( UniqueDescriptorSet( buffer[i], deleter ) ); + descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); @@ -43874,16 +43874,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const { - static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueCommandBuffer ), "CommandBuffer is greater than UniqueCommandBuffer!" ); - std::vector<UniqueCommandBuffer, Allocator> commandBuffers; + static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" ); + std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers; commandBuffers.reserve( allocateInfo.commandBufferCount ); - CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueCommandBuffer ) - sizeof( CommandBuffer ) ) ); + CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) ); Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) ); PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d ); for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ ) { - commandBuffers.push_back( UniqueCommandBuffer( buffer[i], deleter ) ); + commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); @@ -43891,16 +43891,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const { - static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueCommandBuffer ), "CommandBuffer is greater than UniqueCommandBuffer!" ); - std::vector<UniqueCommandBuffer, Allocator> commandBuffers( vectorAllocator ); + static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" ); + std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers( vectorAllocator ); commandBuffers.reserve( allocateInfo.commandBufferCount ); - CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueCommandBuffer ) - sizeof( CommandBuffer ) ) ); + CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) ); Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) ); PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d ); for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ ) { - commandBuffers.push_back( UniqueCommandBuffer( buffer[i], deleter ) ); + commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); @@ -43965,16 +43965,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const { - static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueSwapchainKHR ), "SwapchainKHR is greater than UniqueSwapchainKHR!" ); - std::vector<UniqueSwapchainKHR, Allocator> swapchainKHRs; + static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" ); + std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs; swapchainKHRs.reserve( createInfos.size() ); - SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueSwapchainKHR ) - sizeof( SwapchainKHR ) ) ); + SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) ); Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - swapchainKHRs.push_back( UniqueSwapchainKHR( buffer[i], deleter ) ); + swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); @@ -43982,16 +43982,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const { - static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueSwapchainKHR ), "SwapchainKHR is greater than UniqueSwapchainKHR!" ); - std::vector<UniqueSwapchainKHR, Allocator> swapchainKHRs( vectorAllocator ); + static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" ); + std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs( vectorAllocator ); swapchainKHRs.reserve( createInfos.size() ); - SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueSwapchainKHR ) - sizeof( SwapchainKHR ) ) ); + SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) ); Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - swapchainKHRs.push_back( UniqueSwapchainKHR( buffer[i], deleter ) ); + swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); @@ -45707,16 +45707,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector<UniquePipeline, Allocator> pipelines; + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" ); + std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines; pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) ); Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - pipelines.push_back( UniquePipeline( buffer[i], deleter ) ); + pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" ); @@ -45724,16 +45724,16 @@ template <typename Allocator, typename Dispatch> VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector<UniquePipeline, Allocator> pipelines( vectorAllocator ); + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" ); + std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator ); pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) ); Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) ); ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d ); for ( size_t i=0 ; i<createInfos.size() ; i++ ) { - pipelines.push_back( UniquePipeline( buffer[i], deleter ) ); + pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) ); } return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" ); @@ -45820,8 +45820,6 @@ #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template<typename Dispatch = DispatchLoaderStatic> PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const; - template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic> - StructureChain<X, Y, Z...> getProperties(Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template<typename Dispatch = DispatchLoaderStatic> @@ -46337,14 +46335,6 @@ d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) ); return properties; } - template <typename X, typename Y, typename ...Z, typename Dispatch> - VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties(Dispatch const &d ) const - { - StructureChain<X, Y, Z...> structureChain; - PhysicalDeviceProperties& properties = structureChain.template get<PhysicalDeviceProperties>(); - d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) ); - return structureChain; - } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template<typename Dispatch> @@ -49387,7 +49377,7 @@ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties, PhysicalDeviceShadingRateImagePropertiesNV>{ enum { value = true }; }; + template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShadingRateImagePropertiesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMeshShaderPropertiesNV>{ enum { value = true }; }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Headers-1.1.95/include/vulkan/vulkan_core.h new/Vulkan-Headers-1.1.96/include/vulkan/vulkan_core.h --- old/Vulkan-Headers-1.1.95/include/vulkan/vulkan_core.h 2018-12-03 17:42:21.000000000 +0100 +++ new/Vulkan-Headers-1.1.96/include/vulkan/vulkan_core.h 2018-12-17 17:57:13.000000000 +0100 @@ -43,7 +43,7 @@ #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 95 +#define VK_HEADER_VERSION 96 #define VK_NULL_HANDLE 0 @@ -8862,16 +8862,16 @@ #endif #define VK_EXT_pci_bus_info 1 -#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 1 +#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 #define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { VkStructureType sType; void* pNext; - uint16_t pciDomain; - uint8_t pciBus; - uint8_t pciDevice; - uint8_t pciFunction; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; } VkPhysicalDevicePCIBusInfoPropertiesEXT; @@ -8917,12 +8917,12 @@ #define VK_GOOGLE_hlsl_functionality1 1 -#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 0 +#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" #define VK_GOOGLE_decorate_string 1 -#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 0 +#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1 #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Headers-1.1.95/registry/validusage.json new/Vulkan-Headers-1.1.96/registry/validusage.json --- old/Vulkan-Headers-1.1.95/registry/validusage.json 2018-12-03 17:42:21.000000000 +0100 +++ new/Vulkan-Headers-1.1.96/registry/validusage.json 2018-12-17 17:57:13.000000000 +0100 @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.1.95", - "comment": "from git branch: master commit: ef29cea94bba541fe1ec9ffc33f65af1268bacad", - "date": "2018-12-03 16:40:14Z" + "api version": "1.1.96", + "comment": "from git branch: master commit: b557dd2167a5b2c92a03a69b34ff7a4431cca7ad", + "date": "2018-12-17 16:39:53Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -198,7 +198,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", - "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverPropertiesKHR\">VkPhysicalDeviceDriverPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsPropertiesKHR\">VkPhysicalDeviceFloatControlsPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>" + "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverPropertiesKHR\">VkPhysicalDeviceDriverPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsPropertiesKHR\">VkPhysicalDeviceFloatControlsPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>" }, { "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", @@ -298,6 +298,18 @@ } ] }, + "VkPhysicalDeviceGroupProperties": { + "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ + { + "vuid": "VUID-VkPhysicalDeviceGroupProperties-sType-sType", + "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES</code>" + }, + { + "vuid": "VUID-VkPhysicalDeviceGroupProperties-pNext-pNext", + "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>" + } + ] + }, "vkCreateDevice": { "core": [ { @@ -4937,12 +4949,12 @@ "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>, the identified entry point <strong class=\"purple\">must</strong> have an <code>OpExecutionMode</code> instruction that specifies an invocation count that is greater than <code>0</code> and less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxGeometryShaderInvocations</code>" }, { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00716", - "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>, and the identified entry point writes to <code>Layer</code> for any primitive, it <strong class=\"purple\">must</strong> write the same value to <code>Layer</code> for all vertices of a given primitive" + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02596", + "text": " If <code>stage</code> is a vertex processing stage, and the identified entry point writes to <code>Layer</code> for any primitive, it <strong class=\"purple\">must</strong> write the same value to <code>Layer</code> for all vertices of a given primitive" }, { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00717", - "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>, and the identified entry point writes to <code>ViewportIndex</code> for any primitive, it <strong class=\"purple\">must</strong> write the same value to <code>ViewportIndex</code> for all vertices of a given primitive" + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02597", + "text": " If <code>stage</code> is a vertex processing stage, and the identified entry point writes to <code>ViewportIndex</code> for any primitive, it <strong class=\"purple\">must</strong> write the same value to <code>ViewportIndex</code> for all vertices of a given primitive" }, { "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00718", @@ -6086,7 +6098,7 @@ }, { "vuid": "VUID-VkMemoryAllocateInfo-pNext-02384", - "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, and the <code>pNext</code> chain does not contain an instance of <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> or <code>VkMemoryDedicatedAllocateInfo</code>::<code>image</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the Android hardware buffer <strong class=\"purple\">must</strong> have a <code>AHardwareBuffer_Desc</code>::<code>format</code> of <code>AHARDWAREBUFFER_FORMAT_BLOB</code> and a <code>AHardwareBuffer_Desc</code>::<code>usage</code> that includes <code>AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER</code>." + "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, and the <code>pNext</code> chain does not contain an instance of <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> or <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the Android hardware buffer <strong class=\"purple\">must</strong> have a <code>AHardwareBuffer_Desc</code>::<code>format</code> of <code>AHARDWAREBUFFER_FORMAT_BLOB</code> and a <code>AHardwareBuffer_Desc</code>::<code>usage</code> that includes <code>AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER</code>." }, { "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-02385", @@ -6520,6 +6532,18 @@ } ] }, + "VkMemoryFdPropertiesKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryFdPropertiesKHR-sType-sType", + "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR</code>" + }, + { + "vuid": "VUID-VkMemoryFdPropertiesKHR-pNext-pNext", + "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>" + } + ] + }, "VkImportMemoryHostPointerInfoEXT": { "(VK_EXT_external_memory_host)": [ { @@ -6641,6 +6665,18 @@ { "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883", "text": " If the <code>pNext</code> chain of the <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> used to allocate <code>memory</code> included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> with non-<code>NULL</code> <code>image</code> member, then that <code>image</code> <strong class=\"purple\">must</strong> already be bound to <code>memory</code>." + }, + { + "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-sType-sType", + "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID</code>" + }, + { + "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-pNext", + "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>" + }, + { + "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-memory-parameter", + "text": " <code>memory</code> <strong class=\"purple\">must</strong> be a valid <code>VkDeviceMemory</code> handle" } ] }, @@ -6664,6 +6700,18 @@ } ] }, + "VkAndroidHardwareBufferPropertiesANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkAndroidHardwareBufferPropertiesANDROID-sType-sType", + "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID</code>" + }, + { + "vuid": "VUID-VkAndroidHardwareBufferPropertiesANDROID-pNext-pNext", + "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkAndroidHardwareBufferFormatPropertiesANDROID\">VkAndroidHardwareBufferFormatPropertiesANDROID</a>" + } + ] + }, "VkAndroidHardwareBufferFormatPropertiesANDROID": { "(VK_ANDROID_external_memory_android_hardware_buffer)": [ { @@ -7535,10 +7583,6 @@ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure whose <code>handleTypes</code> member includes <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>mipLevels</code> <strong class=\"purple\">must</strong> either be <code>1</code> or equal to the number of levels in the complete mipmap chain based on <span class=\"eq\"><code>extent.width</code></span>, <span class=\"eq\"><code>extent.height</code></span>, and <span class=\"eq\"><code>extent.depth</code></span>." }, { - "vuid": "VUID-VkImageCreateInfo-pNext-02395", - "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure whose <code>handleTypes</code> member includes <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, and <code>format</code> is <code>VK_FORMAT_UNDEFINED</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>." - }, - { "vuid": "VUID-VkImageCreateInfo-pNext-02396", "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>, <code>flags</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>." }, @@ -9028,7 +9072,7 @@ "(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1+VK_KHR_swapchain)+!(VK_KHR_device_group+VK_KHR_swapchain)": [ { "vuid": "VUID-VkBindImageMemoryInfo-memory-01625", - "text": " <code>memory</code> <strong class=\"purple\">must</strong> be a valid <code>VkDeviceMemory</code> handle" + "text": " <code>memory</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeviceMemory\">VkDeviceMemory</a> handle" } ], "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ @@ -9060,7 +9104,7 @@ }, { "vuid": "VUID-VkBindImageMemoryInfo-pNext-01632", - "text": " If the <code>pNext</code> chain does not include an instance of <a href=\"#VkBindImageMemorySwapchainInfoKHR\">VkBindImageMemorySwapchainInfoKHR</a>, <code>memory</code> <strong class=\"purple\">must</strong> be a valid <code>VkDeviceMemory</code> handle" + "text": " If the <code>pNext</code> chain does not include an instance of <a href=\"#VkBindImageMemorySwapchainInfoKHR\">VkBindImageMemorySwapchainInfoKHR</a>, <code>memory</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeviceMemory\">VkDeviceMemory</a> handle" } ] }, @@ -9310,7 +9354,7 @@ }, { "vuid": "VUID-VkGeometryTrianglesNV-indexData-02434", - "text": " <code>indexData</code> <strong class=\"purple\">must</strong> be <code>VK_NULL_HANDLE</code> if <code>indexType</code> is <code>VK_INDEX_TYPE_NONE_NV</code>" + "text": " <code>indexData</code> <strong class=\"purple\">must</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> if <code>indexType</code> is <code>VK_INDEX_TYPE_NONE_NV</code>" }, { "vuid": "VUID-VkGeometryTrianglesNV-indexData-02435", @@ -15418,7 +15462,7 @@ }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289", - "text": " <code>vertexStride</code> must be less than or equal to <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>maxVertexInputBindingStride</code>" + "text": " <code>vertexStride</code> must be less than or equal to <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>maxTransformFeedbackBufferDataStride</code>" }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-02290", @@ -16525,6 +16569,10 @@ "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>" }, { + "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-pViewportSwizzles-parameter", + "text": " <code>pViewportSwizzles</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>viewportCount</code> valid <code>VkViewportSwizzleNV</code> structures" + }, + { "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength", "text": " <code>viewportCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>" } @@ -16557,6 +16605,10 @@ "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV</code>" }, { + "vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-pViewportWScalings-parameter", + "text": " <code>pViewportWScalings</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>viewportCount</code> <code>VkViewportWScalingNV</code> structures" + }, + { "vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength", "text": " <code>viewportCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>" } @@ -21404,7 +21456,7 @@ }, { "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02489", - "text": " If <code>update</code> is <code>VK_TRUE</code>, <code>src</code> <strong class=\"purple\">must</strong> not be <code>VK_NULL_HANDLE</code>" + "text": " If <code>update</code> is <code>VK_TRUE</code>, <code>src</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>" }, { "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02490", @@ -22310,6 +22362,14 @@ } ] }, + "VkTextureLODGatherFormatPropertiesAMD": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_AMD_texture_gather_bias_lod)": [ + { + "vuid": "VUID-VkTextureLODGatherFormatPropertiesAMD-sType-sType", + "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD</code>" + } + ] + }, "VkPhysicalDeviceExternalImageFormatInfo": { "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Headers-1.1.95/registry/vk.xml new/Vulkan-Headers-1.1.96/registry/vk.xml --- old/Vulkan-Headers-1.1.95/registry/vk.xml 2018-12-03 17:42:21.000000000 +0100 +++ new/Vulkan-Headers-1.1.96/registry/vk.xml 2018-12-17 17:57:13.000000000 +0100 @@ -146,7 +146,7 @@ <type category="define">// Vulkan 1.1 version number #define <name>VK_API_VERSION_1_1</name> <type>VK_MAKE_VERSION</type>(1, 1, 0)// Patch version should always be set to 0</type> <type category="define">// Version of this file -#define <name>VK_HEADER_VERSION</name> 95</type> +#define <name>VK_HEADER_VERSION</name> 96</type> <type category="define"> #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type> @@ -2513,7 +2513,7 @@ <member>const <type>void</type>* <name>pNext</name></member> <member><type>VkBool32</type> <name>viewportWScalingEnable</name></member> <member><type>uint32_t</type> <name>viewportCount</name></member> - <member noautovalidity="true" len="viewportCount">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></member> + <member len="viewportCount">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></member> </type> <type category="struct" name="VkViewportSwizzleNV"> <member><type>VkViewportCoordinateSwizzleNV</type> <name>x</name></member> @@ -2526,7 +2526,7 @@ <member>const <type>void</type>* <name>pNext</name></member> <member optional="true"><type>VkPipelineViewportSwizzleStateCreateFlagsNV</type> <name>flags</name></member> <member><type>uint32_t</type> <name>viewportCount</name></member> - <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewportSwizzleNV</type>* <name>pViewportSwizzles</name></member> + <member len="viewportCount">const <type>VkViewportSwizzleNV</type>* <name>pViewportSwizzles</name></member> </type> <type category="struct" name="VkPhysicalDeviceDiscardRectanglePropertiesEXT" structextends="VkPhysicalDeviceProperties2"> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member> @@ -3235,10 +3235,10 @@ <type category="struct" name="VkPhysicalDevicePCIBusInfoPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true"> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member> <member><type>void</type>* <name>pNext</name></member> - <member><type>uint16_t</type> <name>pciDomain</name></member> - <member><type>uint8_t</type> <name>pciBus</name></member> - <member><type>uint8_t</type> <name>pciDevice</name></member> - <member><type>uint8_t</type> <name>pciFunction</name></member> + <member><type>uint32_t</type> <name>pciDomain</name></member> + <member><type>uint32_t</type> <name>pciBus</name></member> + <member><type>uint32_t</type> <name>pciDevice</name></member> + <member><type>uint32_t</type> <name>pciFunction</name></member> </type> <type category="struct" name="VkImportAndroidHardwareBufferInfoANDROID" structextends="VkMemoryAllocateInfo"> <member values="VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"><type>VkStructureType</type> <name>sType</name></member> @@ -3420,7 +3420,7 @@ <member><type>VkBool32</type> <name>shadingRateImage</name></member> <member><type>VkBool32</type> <name>shadingRateCoarseSampleOrder</name></member> </type> - <type category="struct" name="VkPhysicalDeviceShadingRateImagePropertiesNV" structextends="VkPhysicalDeviceProperties" returnedonly="true"> + <type category="struct" name="VkPhysicalDeviceShadingRateImagePropertiesNV" structextends="VkPhysicalDeviceProperties2" returnedonly="true"> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member> <member><type>void</type>* <name>pNext</name></member> <member><type>VkExtent2D</type> <name>shadingRateTexelSize</name></member> @@ -10001,7 +10001,7 @@ </extension> <extension name="VK_EXT_pci_bus_info" number="213" type="device" author="EXT" requires="VK_KHR_get_physical_device_properties2" contact="Matthaeus G. Chajdas @anteru" supported="vulkan"> <require> - <enum value="1" name="VK_EXT_PCI_BUS_INFO_SPEC_VERSION"/> + <enum value="2" name="VK_EXT_PCI_BUS_INFO_SPEC_VERSION"/> <enum value=""VK_EXT_pci_bus_info"" name="VK_EXT_PCI_BUS_INFO_EXTENSION_NAME"/> <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"/> <type name="VkPhysicalDevicePCIBusInfoPropertiesEXT"/> @@ -10091,13 +10091,13 @@ </extension> <extension name="VK_GOOGLE_hlsl_functionality1" number="224" type="device" author="GOOGLE" contact="Hai Nguyen @chaoticbob" supported="vulkan"> <require> - <enum value="0" name="VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION"/> + <enum value="1" name="VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION"/> <enum value=""VK_GOOGLE_hlsl_functionality1"" name="VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME"/> </require> </extension> <extension name="VK_GOOGLE_decorate_string" number="225" type="device" author="GOOGLE" contact="Hai Nguyen @chaoticbob" supported="vulkan"> <require> - <enum value="0" name="VK_GOOGLE_DECORATE_STRING_SPEC_VERSION"/> + <enum value="1" name="VK_GOOGLE_DECORATE_STRING_SPEC_VERSION"/> <enum value=""VK_GOOGLE_decorate_string"" name="VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME"/> </require> </extension> ++++++ _service ++++++ --- /var/tmp/diff_new_pack.ATOzyM/_old 2018-12-21 08:19:59.569650106 +0100 +++ /var/tmp/diff_new_pack.ATOzyM/_new 2018-12-21 08:19:59.569650106 +0100 @@ -2,9 +2,9 @@ <service name="tar_scm" mode="disabled"> <param name="scm">git</param> <param name="url">https://github.com/KhronosGroup/Vulkan-Headers</param> - <param name="revision">1c78df8e6f43d72c328df2fe53d0f42fa570966a</param> - <param name="parent-tag">1c78df8e6f43d72c328df2fe53d0f42fa570966a</param> - <param name="versionformat">1.1.95</param> + <param name="revision">084c2624eed5ed59e33752ecf1205de63263ec9c</param> + <param name="parent-tag">084c2624eed5ed59e33752ecf1205de63263ec9c</param> + <param name="versionformat">1.1.96</param> </service> <service name="recompress" mode="disabled"> <param name="file">*.tar</param>
