From 369e6ea7f9b8cf0155b183da7e5be1b39ef6138d Mon Sep 17 00:00:00 2001 From: Shannon McPherson Date: Mon, 5 Nov 2018 13:49:46 -0700 Subject: [PATCH] headers: Update to Vulkan header version 1.1.91 Updated: - `include/vulkan/vulkan.h` - `include/vulkan/vulkan.hpp` - `include/vulkan/vulkan_core.h` - `registry/genvk.py` - `registry/validusage.json` - `registry/vk.xml` --- include/vulkan/vulkan.h | 6 - include/vulkan/vulkan.hpp | 2022 ++++++++++++++++++++++-------------------- include/vulkan/vulkan_core.h | 480 +++++----- registry/genvk.py | 5 +- registry/validusage.json | 1080 +++++++++++++++------- registry/vk.xml | 463 +++++----- 6 files changed, 2348 insertions(+), 1708 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index cf9d85a..77da637 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -39,12 +39,6 @@ #endif -#ifdef VK_USE_PLATFORM_MIR_KHR -#include -#include "vulkan_mir.h" -#endif - - #ifdef VK_USE_PLATFORM_VI_NN #include "vulkan_vi.h" #endif diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 1683876..bdc7e4d 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -70,7 +70,7 @@ #undef MemoryBarrier #endif -static_assert( VK_HEADER_VERSION == 90 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 91 , "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 @@ -1124,9 +1124,9 @@ public: { return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo); } - VkResult vkBindAccelerationStructureMemoryNVX( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos ) const + VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos ) const { - return ::vkBindAccelerationStructureMemoryNVX( device, bindInfoCount, pBindInfos); + return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos); } VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const { @@ -1208,9 +1208,9 @@ public: { return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } - void vkCmdBuildAccelerationStructureNVX( VkCommandBuffer commandBuffer, VkAccelerationStructureTypeNVX type, uint32_t instanceCount, VkBuffer instanceData, VkDeviceSize instanceOffset, uint32_t geometryCount, const VkGeometryNVX* pGeometries, VkBuildAccelerationStructureFlagsNVX flags, VkBool32 update, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkBuffer scratch, VkDeviceSize scratchOffset ) const + void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset ) const { - return ::vkCmdBuildAccelerationStructureNVX( commandBuffer, type, instanceCount, instanceData, instanceOffset, geometryCount, pGeometries, flags, update, dst, src, scratch, scratchOffset); + return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); } void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects ) const { @@ -1224,9 +1224,9 @@ public: { return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } - void vkCmdCopyAccelerationStructureNVX( VkCommandBuffer commandBuffer, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkCopyAccelerationStructureModeNVX mode ) const + void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode ) const { - return ::vkCmdCopyAccelerationStructureNVX( commandBuffer, dst, src, mode); + return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode); } void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions ) const { @@ -1484,9 +1484,9 @@ public: { return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings); } - void vkCmdTraceRaysNVX( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, uint32_t width, uint32_t height ) const + void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth ) const { - return ::vkCmdTraceRaysNVX( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, width, height); + return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); } void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData ) const { @@ -1496,9 +1496,9 @@ public: { return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } - void vkCmdWriteAccelerationStructurePropertiesNVX( VkCommandBuffer commandBuffer, VkAccelerationStructureNVX accelerationStructure, VkQueryType queryType, VkQueryPool queryPool, uint32_t query ) const + void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const { - return ::vkCmdWriteAccelerationStructurePropertiesNVX( commandBuffer, accelerationStructure, queryType, queryPool, query); + return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const { @@ -1508,13 +1508,13 @@ public: { return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query); } - VkResult vkCompileDeferredNVX( VkDevice device, VkPipeline pipeline, uint32_t shader ) const + VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const { - return ::vkCompileDeferredNVX( device, pipeline, shader); + return ::vkCompileDeferredNV( device, pipeline, shader); } - VkResult vkCreateAccelerationStructureNVX( VkDevice device, const VkAccelerationStructureCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNVX* pAccelerationStructure ) const + VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure ) const { - return ::vkCreateAccelerationStructureNVX( device, pCreateInfo, pAllocator, pAccelerationStructure); + return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure); } #ifdef VK_USE_PLATFORM_ANDROID_KHR VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const @@ -1624,12 +1624,6 @@ public: return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface); } #endif /*VK_USE_PLATFORM_MACOS_MVK*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - VkResult vkCreateMirSurfaceKHR( VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateMirSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable ) const { return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable); @@ -1646,9 +1640,9 @@ public: { return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool); } - VkResult vkCreateRaytracingPipelinesNVX( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRaytracingPipelineCreateInfoNVX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const + VkResult vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const { - return ::vkCreateRaytracingPipelinesNVX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); } VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const { @@ -1732,9 +1726,9 @@ public: { return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); } - void vkDestroyAccelerationStructureNVX( VkDevice device, VkAccelerationStructureNVX accelerationStructure, const VkAllocationCallbacks* pAllocator ) const + void vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator ) const { - return ::vkDestroyAccelerationStructureNVX( device, accelerationStructure, pAllocator); + return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator); } void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator ) const { @@ -1920,17 +1914,13 @@ public: { return ::vkFreeMemory( device, memory, pAllocator); } - VkResult vkGetAccelerationStructureHandleNVX( VkDevice device, VkAccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData ) const + VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData ) const { - return ::vkGetAccelerationStructureHandleNVX( device, accelerationStructure, dataSize, pData); + return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData); } - void vkGetAccelerationStructureMemoryRequirementsNVX( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements ) const + void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements ) const { - return ::vkGetAccelerationStructureMemoryRequirementsNVX( device, pInfo, pMemoryRequirements); - } - void vkGetAccelerationStructureScratchMemoryRequirementsNVX( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements ) const - { - return ::vkGetAccelerationStructureScratchMemoryRequirementsNVX( device, pInfo, pMemoryRequirements); + return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements); } #ifdef VK_USE_PLATFORM_ANDROID_ANDROID VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const @@ -2208,12 +2198,6 @@ public: { return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties); } -#ifdef VK_USE_PLATFORM_MIR_KHR - VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection ) const - { - return ::vkGetPhysicalDeviceMirPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection); - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties ) const { return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties); @@ -2328,9 +2312,9 @@ public: return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay); } #endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - VkResult vkGetRaytracingShaderHandlesNVX( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData ) const + VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData ) const { - return ::vkGetRaytracingShaderHandlesNVX( device, pipeline, firstGroup, groupCount, dataSize, pData); + return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData); } VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const { @@ -2815,16 +2799,6 @@ public: using AndroidSurfaceCreateFlagsKHR = Flags; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - enum class MirSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - using MirSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - #ifdef VK_USE_PLATFORM_VI_NN enum class ViSurfaceCreateFlagBitsNN { @@ -4646,72 +4620,72 @@ public: static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); - class AccelerationStructureNVX + class AccelerationStructureNV { public: - VULKAN_HPP_CONSTEXPR AccelerationStructureNVX() - : m_accelerationStructureNVX(VK_NULL_HANDLE) + VULKAN_HPP_CONSTEXPR AccelerationStructureNV() + : m_accelerationStructureNV(VK_NULL_HANDLE) {} - VULKAN_HPP_CONSTEXPR AccelerationStructureNVX( std::nullptr_t ) - : m_accelerationStructureNVX(VK_NULL_HANDLE) + VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) + : m_accelerationStructureNV(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNVX( VkAccelerationStructureNVX accelerationStructureNVX ) - : m_accelerationStructureNVX( accelerationStructureNVX ) + VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) + : m_accelerationStructureNV( accelerationStructureNV ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - AccelerationStructureNVX & operator=(VkAccelerationStructureNVX accelerationStructureNVX) + AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV) { - m_accelerationStructureNVX = accelerationStructureNVX; + m_accelerationStructureNV = accelerationStructureNV; return *this; } #endif - AccelerationStructureNVX & operator=( std::nullptr_t ) + AccelerationStructureNV & operator=( std::nullptr_t ) { - m_accelerationStructureNVX = VK_NULL_HANDLE; + m_accelerationStructureNV = VK_NULL_HANDLE; return *this; } - bool operator==( AccelerationStructureNVX const & rhs ) const + bool operator==( AccelerationStructureNV const & rhs ) const { - return m_accelerationStructureNVX == rhs.m_accelerationStructureNVX; + return m_accelerationStructureNV == rhs.m_accelerationStructureNV; } - bool operator!=(AccelerationStructureNVX const & rhs ) const + bool operator!=(AccelerationStructureNV const & rhs ) const { - return m_accelerationStructureNVX != rhs.m_accelerationStructureNVX; + return m_accelerationStructureNV != rhs.m_accelerationStructureNV; } - bool operator<(AccelerationStructureNVX const & rhs ) const + bool operator<(AccelerationStructureNV const & rhs ) const { - return m_accelerationStructureNVX < rhs.m_accelerationStructureNVX; + return m_accelerationStructureNV < rhs.m_accelerationStructureNV; } - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNVX() const + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const { - return m_accelerationStructureNVX; + return m_accelerationStructureNV; } explicit operator bool() const { - return m_accelerationStructureNVX != VK_NULL_HANDLE; + return m_accelerationStructureNV != VK_NULL_HANDLE; } bool operator!() const { - return m_accelerationStructureNVX == VK_NULL_HANDLE; + return m_accelerationStructureNV == VK_NULL_HANDLE; } private: - VkAccelerationStructureNVX m_accelerationStructureNVX; + VkAccelerationStructureNV m_accelerationStructureNV; }; - static_assert( sizeof( AccelerationStructureNVX ) == sizeof( VkAccelerationStructureNVX ), "handle and wrapper have different size!" ); + static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" ); class DisplayKHR { @@ -8213,7 +8187,7 @@ public: eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, - eAccelerationStructureNVX = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX + eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV }; struct DescriptorPoolSize @@ -8378,7 +8352,7 @@ public: ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, eTimestamp = VK_QUERY_TYPE_TIMESTAMP, eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT, - eCompactedSizeNVX = VK_QUERY_TYPE_COMPACTED_SIZE_NVX + eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV }; enum class BorderColor @@ -8395,7 +8369,7 @@ public: { eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, eCompute = VK_PIPELINE_BIND_POINT_COMPUTE, - eRaytracingNVX = VK_PIPELINE_BIND_POINT_RAYTRACING_NVX + eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV }; enum class PipelineCacheHeaderVersion @@ -8427,7 +8401,8 @@ public: enum class IndexType { eUint16 = VK_INDEX_TYPE_UINT16, - eUint32 = VK_INDEX_TYPE_UINT32 + eUint32 = VK_INDEX_TYPE_UINT32, + eNoneNV = VK_INDEX_TYPE_NONE_NV }; enum class Filter @@ -9350,7 +9325,6 @@ public: eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, - eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR, eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -9483,17 +9457,17 @@ public: ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV, - eRaytracingPipelineCreateInfoNVX = VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX, - eAccelerationStructureCreateInfoNVX = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX, - eGeometryInstanceNVX = VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX, - eGeometryNVX = VK_STRUCTURE_TYPE_GEOMETRY_NVX, - eGeometryTrianglesNVX = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX, - eGeometryAabbNVX = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX, - eBindAccelerationStructureMemoryInfoNVX = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX, - eDescriptorAccelerationStructureInfoNVX = VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX, - eAccelerationStructureMemoryRequirementsInfoNVX = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX, - ePhysicalDeviceRaytracingPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX, - eHitShaderModuleCreateInfoNVX = VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX, + eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV, + eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV, + eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV, + eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV, + eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV, + eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, + eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, + eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV, + ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, + eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV, + eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV, ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, @@ -9504,6 +9478,7 @@ public: ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, + eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, @@ -11984,88 +11959,6 @@ public: static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - struct MirSurfaceCreateInfoKHR - { - MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), - MirConnection* connection_ = nullptr, - MirSurface* mirSurface_ = nullptr ) - : flags( flags_ ) - , connection( connection_ ) - , mirSurface( mirSurface_ ) - { - } - - MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); - } - - MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); - return *this; - } - MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MirSurfaceCreateInfoKHR& setFlags( MirSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - MirSurfaceCreateInfoKHR& setConnection( MirConnection* connection_ ) - { - connection = connection_; - return *this; - } - - MirSurfaceCreateInfoKHR& setMirSurface( MirSurface* mirSurface_ ) - { - mirSurface = mirSurface_; - return *this; - } - - operator VkMirSurfaceCreateInfoKHR const&() const - { - return *reinterpret_cast(this); - } - - operator VkMirSurfaceCreateInfoKHR &() - { - return *reinterpret_cast(this); - } - - bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( connection == rhs.connection ) - && ( mirSurface == rhs.mirSurface ); - } - - bool operator!=( MirSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMirSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - MirSurfaceCreateFlagsKHR flags; - MirConnection* connection; - MirSurface* mirSurface; - }; - static_assert( sizeof( MirSurfaceCreateInfoKHR ) == sizeof( VkMirSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - #ifdef VK_USE_PLATFORM_VI_NN struct ViSurfaceCreateInfoNN { @@ -20340,19 +20233,19 @@ public: }; static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" ); - struct GeometryTrianglesNVX - { - GeometryTrianglesNVX( Buffer vertexData_ = Buffer(), - DeviceSize vertexOffset_ = 0, - uint32_t vertexCount_ = 0, - DeviceSize vertexStride_ = 0, - Format vertexFormat_ = Format::eUndefined, - Buffer indexData_ = Buffer(), - DeviceSize indexOffset_ = 0, - uint32_t indexCount_ = 0, - IndexType indexType_ = IndexType::eUint16, - Buffer transformData_ = Buffer(), - DeviceSize transformOffset_ = 0 ) + struct GeometryTrianglesNV + { + GeometryTrianglesNV( Buffer vertexData_ = Buffer(), + DeviceSize vertexOffset_ = 0, + uint32_t vertexCount_ = 0, + DeviceSize vertexStride_ = 0, + Format vertexFormat_ = Format::eUndefined, + Buffer indexData_ = Buffer(), + DeviceSize indexOffset_ = 0, + uint32_t indexCount_ = 0, + IndexType indexType_ = IndexType::eUint16, + Buffer transformData_ = Buffer(), + DeviceSize transformOffset_ = 0 ) : vertexData( vertexData_ ) , vertexOffset( vertexOffset_ ) , vertexCount( vertexCount_ ) @@ -20367,99 +20260,99 @@ public: { } - GeometryTrianglesNVX( VkGeometryTrianglesNVX const & rhs ) + GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryTrianglesNVX ) ); + memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) ); } - GeometryTrianglesNVX& operator=( VkGeometryTrianglesNVX const & rhs ) + GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryTrianglesNVX ) ); + memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) ); return *this; } - GeometryTrianglesNVX& setPNext( const void* pNext_ ) + GeometryTrianglesNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - GeometryTrianglesNVX& setVertexData( Buffer vertexData_ ) + GeometryTrianglesNV& setVertexData( Buffer vertexData_ ) { vertexData = vertexData_; return *this; } - GeometryTrianglesNVX& setVertexOffset( DeviceSize vertexOffset_ ) + GeometryTrianglesNV& setVertexOffset( DeviceSize vertexOffset_ ) { vertexOffset = vertexOffset_; return *this; } - GeometryTrianglesNVX& setVertexCount( uint32_t vertexCount_ ) + GeometryTrianglesNV& setVertexCount( uint32_t vertexCount_ ) { vertexCount = vertexCount_; return *this; } - GeometryTrianglesNVX& setVertexStride( DeviceSize vertexStride_ ) + GeometryTrianglesNV& setVertexStride( DeviceSize vertexStride_ ) { vertexStride = vertexStride_; return *this; } - GeometryTrianglesNVX& setVertexFormat( Format vertexFormat_ ) + GeometryTrianglesNV& setVertexFormat( Format vertexFormat_ ) { vertexFormat = vertexFormat_; return *this; } - GeometryTrianglesNVX& setIndexData( Buffer indexData_ ) + GeometryTrianglesNV& setIndexData( Buffer indexData_ ) { indexData = indexData_; return *this; } - GeometryTrianglesNVX& setIndexOffset( DeviceSize indexOffset_ ) + GeometryTrianglesNV& setIndexOffset( DeviceSize indexOffset_ ) { indexOffset = indexOffset_; return *this; } - GeometryTrianglesNVX& setIndexCount( uint32_t indexCount_ ) + GeometryTrianglesNV& setIndexCount( uint32_t indexCount_ ) { indexCount = indexCount_; return *this; } - GeometryTrianglesNVX& setIndexType( IndexType indexType_ ) + GeometryTrianglesNV& setIndexType( IndexType indexType_ ) { indexType = indexType_; return *this; } - GeometryTrianglesNVX& setTransformData( Buffer transformData_ ) + GeometryTrianglesNV& setTransformData( Buffer transformData_ ) { transformData = transformData_; return *this; } - GeometryTrianglesNVX& setTransformOffset( DeviceSize transformOffset_ ) + GeometryTrianglesNV& setTransformOffset( DeviceSize transformOffset_ ) { transformOffset = transformOffset_; return *this; } - operator VkGeometryTrianglesNVX const&() const + operator VkGeometryTrianglesNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkGeometryTrianglesNVX &() + operator VkGeometryTrianglesNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( GeometryTrianglesNVX const& rhs ) const + bool operator==( GeometryTrianglesNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -20476,13 +20369,13 @@ public: && ( transformOffset == rhs.transformOffset ); } - bool operator!=( GeometryTrianglesNVX const& rhs ) const + bool operator!=( GeometryTrianglesNV const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::eGeometryTrianglesNVX; + StructureType sType = StructureType::eGeometryTrianglesNV; public: const void* pNext = nullptr; @@ -20498,14 +20391,14 @@ public: Buffer transformData; DeviceSize transformOffset; }; - static_assert( sizeof( GeometryTrianglesNVX ) == sizeof( VkGeometryTrianglesNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" ); - struct GeometryAABBNVX + struct GeometryAABBNV { - GeometryAABBNVX( Buffer aabbData_ = Buffer(), - uint32_t numAABBs_ = 0, - uint32_t stride_ = 0, - DeviceSize offset_ = 0 ) + GeometryAABBNV( Buffer aabbData_ = Buffer(), + uint32_t numAABBs_ = 0, + uint32_t stride_ = 0, + DeviceSize offset_ = 0 ) : aabbData( aabbData_ ) , numAABBs( numAABBs_ ) , stride( stride_ ) @@ -20513,57 +20406,57 @@ public: { } - GeometryAABBNVX( VkGeometryAABBNVX const & rhs ) + GeometryAABBNV( VkGeometryAABBNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryAABBNVX ) ); + memcpy( this, &rhs, sizeof( GeometryAABBNV ) ); } - GeometryAABBNVX& operator=( VkGeometryAABBNVX const & rhs ) + GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryAABBNVX ) ); + memcpy( this, &rhs, sizeof( GeometryAABBNV ) ); return *this; } - GeometryAABBNVX& setPNext( const void* pNext_ ) + GeometryAABBNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - GeometryAABBNVX& setAabbData( Buffer aabbData_ ) + GeometryAABBNV& setAabbData( Buffer aabbData_ ) { aabbData = aabbData_; return *this; } - GeometryAABBNVX& setNumAABBs( uint32_t numAABBs_ ) + GeometryAABBNV& setNumAABBs( uint32_t numAABBs_ ) { numAABBs = numAABBs_; return *this; } - GeometryAABBNVX& setStride( uint32_t stride_ ) + GeometryAABBNV& setStride( uint32_t stride_ ) { stride = stride_; return *this; } - GeometryAABBNVX& setOffset( DeviceSize offset_ ) + GeometryAABBNV& setOffset( DeviceSize offset_ ) { offset = offset_; return *this; } - operator VkGeometryAABBNVX const&() const + operator VkGeometryAABBNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkGeometryAABBNVX &() + operator VkGeometryAABBNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( GeometryAABBNVX const& rhs ) const + bool operator==( GeometryAABBNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -20573,13 +20466,13 @@ public: && ( offset == rhs.offset ); } - bool operator!=( GeometryAABBNVX const& rhs ) const + bool operator!=( GeometryAABBNV const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::eGeometryAabbNVX; + StructureType sType = StructureType::eGeometryAabbNV; public: const void* pNext = nullptr; @@ -20588,72 +20481,72 @@ public: uint32_t stride; DeviceSize offset; }; - static_assert( sizeof( GeometryAABBNVX ) == sizeof( VkGeometryAABBNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); - struct GeometryDataNVX + struct GeometryDataNV { - GeometryDataNVX( GeometryTrianglesNVX triangles_ = GeometryTrianglesNVX(), - GeometryAABBNVX aabbs_ = GeometryAABBNVX() ) + GeometryDataNV( GeometryTrianglesNV triangles_ = GeometryTrianglesNV(), + GeometryAABBNV aabbs_ = GeometryAABBNV() ) : triangles( triangles_ ) , aabbs( aabbs_ ) { } - GeometryDataNVX( VkGeometryDataNVX const & rhs ) + GeometryDataNV( VkGeometryDataNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryDataNVX ) ); + memcpy( this, &rhs, sizeof( GeometryDataNV ) ); } - GeometryDataNVX& operator=( VkGeometryDataNVX const & rhs ) + GeometryDataNV& operator=( VkGeometryDataNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryDataNVX ) ); + memcpy( this, &rhs, sizeof( GeometryDataNV ) ); return *this; } - GeometryDataNVX& setTriangles( GeometryTrianglesNVX triangles_ ) + GeometryDataNV& setTriangles( GeometryTrianglesNV triangles_ ) { triangles = triangles_; return *this; } - GeometryDataNVX& setAabbs( GeometryAABBNVX aabbs_ ) + GeometryDataNV& setAabbs( GeometryAABBNV aabbs_ ) { aabbs = aabbs_; return *this; } - operator VkGeometryDataNVX const&() const + operator VkGeometryDataNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkGeometryDataNVX &() + operator VkGeometryDataNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( GeometryDataNVX const& rhs ) const + bool operator==( GeometryDataNV const& rhs ) const { return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs ); } - bool operator!=( GeometryDataNVX const& rhs ) const + bool operator!=( GeometryDataNV const& rhs ) const { return !operator==( rhs ); } - GeometryTrianglesNVX triangles; - GeometryAABBNVX aabbs; + GeometryTrianglesNV triangles; + GeometryAABBNV aabbs; }; - static_assert( sizeof( GeometryDataNVX ) == sizeof( VkGeometryDataNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" ); - struct BindAccelerationStructureMemoryInfoNVX + struct BindAccelerationStructureMemoryInfoNV { - BindAccelerationStructureMemoryInfoNVX( AccelerationStructureNVX accelerationStructure_ = AccelerationStructureNVX(), - DeviceMemory memory_ = DeviceMemory(), - DeviceSize memoryOffset_ = 0, - uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr ) + BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV(), + DeviceMemory memory_ = DeviceMemory(), + DeviceSize memoryOffset_ = 0, + uint32_t deviceIndexCount_ = 0, + const uint32_t* pDeviceIndices_ = nullptr ) : accelerationStructure( accelerationStructure_ ) , memory( memory_ ) , memoryOffset( memoryOffset_ ) @@ -20662,63 +20555,63 @@ public: { } - BindAccelerationStructureMemoryInfoNVX( VkBindAccelerationStructureMemoryInfoNVX const & rhs ) + BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNVX ) ); + memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) ); } - BindAccelerationStructureMemoryInfoNVX& operator=( VkBindAccelerationStructureMemoryInfoNVX const & rhs ) + BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNVX ) ); + memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) ); return *this; } - BindAccelerationStructureMemoryInfoNVX& setPNext( const void* pNext_ ) + BindAccelerationStructureMemoryInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - BindAccelerationStructureMemoryInfoNVX& setAccelerationStructure( AccelerationStructureNVX accelerationStructure_ ) + BindAccelerationStructureMemoryInfoNV& setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) { accelerationStructure = accelerationStructure_; return *this; } - BindAccelerationStructureMemoryInfoNVX& setMemory( DeviceMemory memory_ ) + BindAccelerationStructureMemoryInfoNV& setMemory( DeviceMemory memory_ ) { memory = memory_; return *this; } - BindAccelerationStructureMemoryInfoNVX& setMemoryOffset( DeviceSize memoryOffset_ ) + BindAccelerationStructureMemoryInfoNV& setMemoryOffset( DeviceSize memoryOffset_ ) { memoryOffset = memoryOffset_; return *this; } - BindAccelerationStructureMemoryInfoNVX& setDeviceIndexCount( uint32_t deviceIndexCount_ ) + BindAccelerationStructureMemoryInfoNV& setDeviceIndexCount( uint32_t deviceIndexCount_ ) { deviceIndexCount = deviceIndexCount_; return *this; } - BindAccelerationStructureMemoryInfoNVX& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) + BindAccelerationStructureMemoryInfoNV& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) { pDeviceIndices = pDeviceIndices_; return *this; } - operator VkBindAccelerationStructureMemoryInfoNVX const&() const + operator VkBindAccelerationStructureMemoryInfoNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkBindAccelerationStructureMemoryInfoNVX &() + operator VkBindAccelerationStructureMemoryInfoNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( BindAccelerationStructureMemoryInfoNVX const& rhs ) const + bool operator==( BindAccelerationStructureMemoryInfoNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -20729,72 +20622,72 @@ public: && ( pDeviceIndices == rhs.pDeviceIndices ); } - bool operator!=( BindAccelerationStructureMemoryInfoNVX const& rhs ) const + bool operator!=( BindAccelerationStructureMemoryInfoNV const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNVX; + StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; public: const void* pNext = nullptr; - AccelerationStructureNVX accelerationStructure; + AccelerationStructureNV accelerationStructure; DeviceMemory memory; DeviceSize memoryOffset; uint32_t deviceIndexCount; const uint32_t* pDeviceIndices; }; - static_assert( sizeof( BindAccelerationStructureMemoryInfoNVX ) == sizeof( VkBindAccelerationStructureMemoryInfoNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" ); - struct DescriptorAccelerationStructureInfoNVX + struct WriteDescriptorSetAccelerationStructureNV { - DescriptorAccelerationStructureInfoNVX( uint32_t accelerationStructureCount_ = 0, - const AccelerationStructureNVX* pAccelerationStructures_ = nullptr ) + WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0, + const AccelerationStructureNV* pAccelerationStructures_ = nullptr ) : accelerationStructureCount( accelerationStructureCount_ ) , pAccelerationStructures( pAccelerationStructures_ ) { } - DescriptorAccelerationStructureInfoNVX( VkDescriptorAccelerationStructureInfoNVX const & rhs ) + WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) { - memcpy( this, &rhs, sizeof( DescriptorAccelerationStructureInfoNVX ) ); + memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) ); } - DescriptorAccelerationStructureInfoNVX& operator=( VkDescriptorAccelerationStructureInfoNVX const & rhs ) + WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) { - memcpy( this, &rhs, sizeof( DescriptorAccelerationStructureInfoNVX ) ); + memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) ); return *this; } - DescriptorAccelerationStructureInfoNVX& setPNext( const void* pNext_ ) + WriteDescriptorSetAccelerationStructureNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - DescriptorAccelerationStructureInfoNVX& setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) + WriteDescriptorSetAccelerationStructureNV& setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) { accelerationStructureCount = accelerationStructureCount_; return *this; } - DescriptorAccelerationStructureInfoNVX& setPAccelerationStructures( const AccelerationStructureNVX* pAccelerationStructures_ ) + WriteDescriptorSetAccelerationStructureNV& setPAccelerationStructures( const AccelerationStructureNV* pAccelerationStructures_ ) { pAccelerationStructures = pAccelerationStructures_; return *this; } - operator VkDescriptorAccelerationStructureInfoNVX const&() const + operator VkWriteDescriptorSetAccelerationStructureNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkDescriptorAccelerationStructureInfoNVX &() + operator VkWriteDescriptorSetAccelerationStructureNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DescriptorAccelerationStructureInfoNVX const& rhs ) const + bool operator==( WriteDescriptorSetAccelerationStructureNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -20802,160 +20695,150 @@ public: && ( pAccelerationStructures == rhs.pAccelerationStructures ); } - bool operator!=( DescriptorAccelerationStructureInfoNVX const& rhs ) const + bool operator!=( WriteDescriptorSetAccelerationStructureNV const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::eDescriptorAccelerationStructureInfoNVX; + StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; public: const void* pNext = nullptr; uint32_t accelerationStructureCount; - const AccelerationStructureNVX* pAccelerationStructures; + const AccelerationStructureNV* pAccelerationStructures; }; - static_assert( sizeof( DescriptorAccelerationStructureInfoNVX ) == sizeof( VkDescriptorAccelerationStructureInfoNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" ); - struct AccelerationStructureMemoryRequirementsInfoNVX + struct PhysicalDeviceRayTracingPropertiesNV { - AccelerationStructureMemoryRequirementsInfoNVX( AccelerationStructureNVX accelerationStructure_ = AccelerationStructureNVX() ) - : accelerationStructure( accelerationStructure_ ) + PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = 0, + uint32_t maxRecursionDepth_ = 0, + uint32_t maxShaderGroupStride_ = 0, + uint32_t shaderGroupBaseAlignment_ = 0, + uint64_t maxGeometryCount_ = 0, + uint64_t maxInstanceCount_ = 0, + uint64_t maxTriangleCount_ = 0, + uint32_t maxDescriptorSetAccelerationStructures_ = 0 ) + : shaderGroupHandleSize( shaderGroupHandleSize_ ) + , maxRecursionDepth( maxRecursionDepth_ ) + , maxShaderGroupStride( maxShaderGroupStride_ ) + , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ ) + , maxGeometryCount( maxGeometryCount_ ) + , maxInstanceCount( maxInstanceCount_ ) + , maxTriangleCount( maxTriangleCount_ ) + , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ ) { } - AccelerationStructureMemoryRequirementsInfoNVX( VkAccelerationStructureMemoryRequirementsInfoNVX const & rhs ) + PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) { - memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNVX ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) ); } - AccelerationStructureMemoryRequirementsInfoNVX& operator=( VkAccelerationStructureMemoryRequirementsInfoNVX const & rhs ) + PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) { - memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNVX ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) ); return *this; } - AccelerationStructureMemoryRequirementsInfoNVX& setPNext( const void* pNext_ ) + PhysicalDeviceRayTracingPropertiesNV& setPNext( void* pNext_ ) { pNext = pNext_; return *this; } - AccelerationStructureMemoryRequirementsInfoNVX& setAccelerationStructure( AccelerationStructureNVX accelerationStructure_ ) + PhysicalDeviceRayTracingPropertiesNV& setShaderGroupHandleSize( uint32_t shaderGroupHandleSize_ ) { - accelerationStructure = accelerationStructure_; + shaderGroupHandleSize = shaderGroupHandleSize_; return *this; } - operator VkAccelerationStructureMemoryRequirementsInfoNVX const&() const - { - return *reinterpret_cast(this); - } - - operator VkAccelerationStructureMemoryRequirementsInfoNVX &() - { - return *reinterpret_cast(this); - } - - bool operator==( AccelerationStructureMemoryRequirementsInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( accelerationStructure == rhs.accelerationStructure ); - } - - bool operator!=( AccelerationStructureMemoryRequirementsInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNVX; - - public: - const void* pNext = nullptr; - AccelerationStructureNVX accelerationStructure; - }; - static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNVX ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNVX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceRaytracingPropertiesNVX - { - PhysicalDeviceRaytracingPropertiesNVX( uint32_t shaderHeaderSize_ = 0, - uint32_t maxRecursionDepth_ = 0, - uint32_t maxGeometryCount_ = 0 ) - : shaderHeaderSize( shaderHeaderSize_ ) - , maxRecursionDepth( maxRecursionDepth_ ) - , maxGeometryCount( maxGeometryCount_ ) + PhysicalDeviceRayTracingPropertiesNV& setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) { + maxRecursionDepth = maxRecursionDepth_; + return *this; } - PhysicalDeviceRaytracingPropertiesNVX( VkPhysicalDeviceRaytracingPropertiesNVX const & rhs ) + PhysicalDeviceRayTracingPropertiesNV& setMaxShaderGroupStride( uint32_t maxShaderGroupStride_ ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceRaytracingPropertiesNVX ) ); + maxShaderGroupStride = maxShaderGroupStride_; + return *this; } - PhysicalDeviceRaytracingPropertiesNVX& operator=( VkPhysicalDeviceRaytracingPropertiesNVX const & rhs ) + PhysicalDeviceRayTracingPropertiesNV& setShaderGroupBaseAlignment( uint32_t shaderGroupBaseAlignment_ ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceRaytracingPropertiesNVX ) ); + shaderGroupBaseAlignment = shaderGroupBaseAlignment_; return *this; } - PhysicalDeviceRaytracingPropertiesNVX& setPNext( void* pNext_ ) + + PhysicalDeviceRayTracingPropertiesNV& setMaxGeometryCount( uint64_t maxGeometryCount_ ) { - pNext = pNext_; + maxGeometryCount = maxGeometryCount_; return *this; } - PhysicalDeviceRaytracingPropertiesNVX& setShaderHeaderSize( uint32_t shaderHeaderSize_ ) + PhysicalDeviceRayTracingPropertiesNV& setMaxInstanceCount( uint64_t maxInstanceCount_ ) { - shaderHeaderSize = shaderHeaderSize_; + maxInstanceCount = maxInstanceCount_; return *this; } - PhysicalDeviceRaytracingPropertiesNVX& setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) + PhysicalDeviceRayTracingPropertiesNV& setMaxTriangleCount( uint64_t maxTriangleCount_ ) { - maxRecursionDepth = maxRecursionDepth_; + maxTriangleCount = maxTriangleCount_; return *this; } - PhysicalDeviceRaytracingPropertiesNVX& setMaxGeometryCount( uint32_t maxGeometryCount_ ) + PhysicalDeviceRayTracingPropertiesNV& setMaxDescriptorSetAccelerationStructures( uint32_t maxDescriptorSetAccelerationStructures_ ) { - maxGeometryCount = maxGeometryCount_; + maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures_; return *this; } - operator VkPhysicalDeviceRaytracingPropertiesNVX const&() const + operator VkPhysicalDeviceRayTracingPropertiesNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkPhysicalDeviceRaytracingPropertiesNVX &() + operator VkPhysicalDeviceRayTracingPropertiesNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceRaytracingPropertiesNVX const& rhs ) const + bool operator==( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( shaderHeaderSize == rhs.shaderHeaderSize ) + && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) - && ( maxGeometryCount == rhs.maxGeometryCount ); + && ( maxShaderGroupStride == rhs.maxShaderGroupStride ) + && ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) + && ( maxGeometryCount == rhs.maxGeometryCount ) + && ( maxInstanceCount == rhs.maxInstanceCount ) + && ( maxTriangleCount == rhs.maxTriangleCount ) + && ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ); } - bool operator!=( PhysicalDeviceRaytracingPropertiesNVX const& rhs ) const + bool operator!=( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::ePhysicalDeviceRaytracingPropertiesNVX; + StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; public: void* pNext = nullptr; - uint32_t shaderHeaderSize; + uint32_t shaderGroupHandleSize; uint32_t maxRecursionDepth; - uint32_t maxGeometryCount; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; }; - static_assert( sizeof( PhysicalDeviceRaytracingPropertiesNVX ) == sizeof( VkPhysicalDeviceRaytracingPropertiesNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" ); struct PhysicalDeviceImageDrmFormatModifierInfoEXT { @@ -21685,7 +21568,7 @@ public: eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX, eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, - eAccelerationStructureNVX = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX + eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV }; struct DebugUtilsObjectNameInfoEXT @@ -22646,8 +22529,8 @@ public: eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV, - eAccelerationStructureReadNVX = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NVX, - eAccelerationStructureWriteNVX = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NVX + eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV, + eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV }; using AccessFlags = Flags; @@ -22666,7 +22549,7 @@ public: { enum { - allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNVX) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNVX) + allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV) }; }; @@ -22874,7 +22757,7 @@ public: eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, - eRaytracingNVX = VK_BUFFER_USAGE_RAYTRACING_BIT_NVX + eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV }; using BufferUsageFlags = Flags; @@ -22893,7 +22776,7 @@ public: { enum { - allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRaytracingNVX) + allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV) }; }; @@ -23045,12 +22928,12 @@ public: eCompute = VK_SHADER_STAGE_COMPUTE_BIT, eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, eAll = VK_SHADER_STAGE_ALL, - eRaygenNVX = VK_SHADER_STAGE_RAYGEN_BIT_NVX, - eAnyHitNVX = VK_SHADER_STAGE_ANY_HIT_BIT_NVX, - eClosestHitNVX = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NVX, - eMissNVX = VK_SHADER_STAGE_MISS_BIT_NVX, - eIntersectionNVX = VK_SHADER_STAGE_INTERSECTION_BIT_NVX, - eCallableNVX = VK_SHADER_STAGE_CALLABLE_BIT_NVX, + eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV, + eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV, + eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV, + eMissNV = VK_SHADER_STAGE_MISS_BIT_NV, + eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV, + eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV, eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV, eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV }; @@ -23071,7 +22954,7 @@ public: { enum { - allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) | VkFlags(ShaderStageFlagBits::eRaygenNVX) | VkFlags(ShaderStageFlagBits::eAnyHitNVX) | VkFlags(ShaderStageFlagBits::eClosestHitNVX) | VkFlags(ShaderStageFlagBits::eMissNVX) | VkFlags(ShaderStageFlagBits::eIntersectionNVX) | VkFlags(ShaderStageFlagBits::eCallableNVX) | VkFlags(ShaderStageFlagBits::eTaskNV) | VkFlags(ShaderStageFlagBits::eMeshNV) + allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) | VkFlags(ShaderStageFlagBits::eRaygenNV) | VkFlags(ShaderStageFlagBits::eAnyHitNV) | VkFlags(ShaderStageFlagBits::eClosestHitNV) | VkFlags(ShaderStageFlagBits::eMissNV) | VkFlags(ShaderStageFlagBits::eIntersectionNV) | VkFlags(ShaderStageFlagBits::eCallableNV) | VkFlags(ShaderStageFlagBits::eTaskNV) | VkFlags(ShaderStageFlagBits::eMeshNV) }; }; @@ -23750,7 +23633,7 @@ public: eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE, eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE, - eDeferCompileNVX = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX + eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV }; using PipelineCreateFlags = Flags; @@ -23769,7 +23652,7 @@ public: { enum { - allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNVX) + allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV) }; }; @@ -23873,136 +23756,6 @@ public: }; static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); - struct RaytracingPipelineCreateInfoNVX - { - RaytracingPipelineCreateInfoNVX( PipelineCreateFlags flags_ = PipelineCreateFlags(), - uint32_t stageCount_ = 0, - const PipelineShaderStageCreateInfo* pStages_ = nullptr, - const uint32_t* pGroupNumbers_ = nullptr, - uint32_t maxRecursionDepth_ = 0, - PipelineLayout layout_ = PipelineLayout(), - Pipeline basePipelineHandle_ = Pipeline(), - int32_t basePipelineIndex_ = 0 ) - : flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , pGroupNumbers( pGroupNumbers_ ) - , maxRecursionDepth( maxRecursionDepth_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } - - RaytracingPipelineCreateInfoNVX( VkRaytracingPipelineCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( RaytracingPipelineCreateInfoNVX ) ); - } - - RaytracingPipelineCreateInfoNVX& operator=( VkRaytracingPipelineCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( RaytracingPipelineCreateInfoNVX ) ); - return *this; - } - RaytracingPipelineCreateInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setFlags( PipelineCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setStageCount( uint32_t stageCount_ ) - { - stageCount = stageCount_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setPStages( const PipelineShaderStageCreateInfo* pStages_ ) - { - pStages = pStages_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setPGroupNumbers( const uint32_t* pGroupNumbers_ ) - { - pGroupNumbers = pGroupNumbers_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) - { - maxRecursionDepth = maxRecursionDepth_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setLayout( PipelineLayout layout_ ) - { - layout = layout_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setBasePipelineHandle( Pipeline basePipelineHandle_ ) - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - RaytracingPipelineCreateInfoNVX& setBasePipelineIndex( int32_t basePipelineIndex_ ) - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - operator VkRaytracingPipelineCreateInfoNVX const&() const - { - return *reinterpret_cast(this); - } - - operator VkRaytracingPipelineCreateInfoNVX &() - { - return *reinterpret_cast(this); - } - - bool operator==( RaytracingPipelineCreateInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stageCount == rhs.stageCount ) - && ( pStages == rhs.pStages ) - && ( pGroupNumbers == rhs.pGroupNumbers ) - && ( maxRecursionDepth == rhs.maxRecursionDepth ) - && ( layout == rhs.layout ) - && ( basePipelineHandle == rhs.basePipelineHandle ) - && ( basePipelineIndex == rhs.basePipelineIndex ); - } - - bool operator!=( RaytracingPipelineCreateInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRaytracingPipelineCreateInfoNVX; - - public: - const void* pNext = nullptr; - PipelineCreateFlags flags; - uint32_t stageCount; - const PipelineShaderStageCreateInfo* pStages; - const uint32_t* pGroupNumbers; - uint32_t maxRecursionDepth; - PipelineLayout layout; - Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( RaytracingPipelineCreateInfoNVX ) == sizeof( VkRaytracingPipelineCreateInfoNVX ), "struct and wrapper have different size!" ); - enum class ColorComponentFlagBits { eR = VK_COLOR_COMPONENT_R_BIT, @@ -26951,7 +26704,8 @@ public: eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX, eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV, - eRaytracingNVX = VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX, + eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV, + eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV, eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV }; @@ -26972,7 +26726,7 @@ public: { enum { - allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRaytracingNVX) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV) + allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRayTracingShaderNV) | VkFlags(PipelineStageFlagBits::eAccelerationStructureBuildNV) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV) }; }; @@ -30084,7 +29838,7 @@ public: eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, - eAccelerationStructureNVX = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT + eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT }; struct DebugMarkerObjectNameInfoEXT @@ -37074,163 +36828,163 @@ public: }; static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" ); - enum class GeometryInstanceFlagBitsNVX + enum class GeometryInstanceFlagBitsNV { - eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NVX, - eTriangleCullFlipWinding = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_FLIP_WINDING_BIT_NVX, - eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NVX, - eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NVX + eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV, + eTriangleFrontCounterclockwise = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV, + eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV, + eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV }; - using GeometryInstanceFlagsNVX = Flags; + using GeometryInstanceFlagsNV = Flags; - VULKAN_HPP_INLINE GeometryInstanceFlagsNVX operator|( GeometryInstanceFlagBitsNVX bit0, GeometryInstanceFlagBitsNVX bit1 ) + VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator|( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 ) { - return GeometryInstanceFlagsNVX( bit0 ) | bit1; + return GeometryInstanceFlagsNV( bit0 ) | bit1; } - VULKAN_HPP_INLINE GeometryInstanceFlagsNVX operator~( GeometryInstanceFlagBitsNVX bits ) + VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator~( GeometryInstanceFlagBitsNV bits ) { - return ~( GeometryInstanceFlagsNVX( bits ) ); + return ~( GeometryInstanceFlagsNV( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(GeometryInstanceFlagBitsNVX::eTriangleCullDisable) | VkFlags(GeometryInstanceFlagBitsNVX::eTriangleCullFlipWinding) | VkFlags(GeometryInstanceFlagBitsNVX::eForceOpaque) | VkFlags(GeometryInstanceFlagBitsNVX::eForceNoOpaque) + allFlags = VkFlags(GeometryInstanceFlagBitsNV::eTriangleCullDisable) | VkFlags(GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) | VkFlags(GeometryInstanceFlagBitsNV::eForceOpaque) | VkFlags(GeometryInstanceFlagBitsNV::eForceNoOpaque) }; }; - enum class GeometryFlagBitsNVX + enum class GeometryFlagBitsNV { - eOpaque = VK_GEOMETRY_OPAQUE_BIT_NVX, - eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX + eOpaque = VK_GEOMETRY_OPAQUE_BIT_NV, + eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV }; - using GeometryFlagsNVX = Flags; + using GeometryFlagsNV = Flags; - VULKAN_HPP_INLINE GeometryFlagsNVX operator|( GeometryFlagBitsNVX bit0, GeometryFlagBitsNVX bit1 ) + VULKAN_HPP_INLINE GeometryFlagsNV operator|( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 ) { - return GeometryFlagsNVX( bit0 ) | bit1; + return GeometryFlagsNV( bit0 ) | bit1; } - VULKAN_HPP_INLINE GeometryFlagsNVX operator~( GeometryFlagBitsNVX bits ) + VULKAN_HPP_INLINE GeometryFlagsNV operator~( GeometryFlagBitsNV bits ) { - return ~( GeometryFlagsNVX( bits ) ); + return ~( GeometryFlagsNV( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(GeometryFlagBitsNVX::eOpaque) | VkFlags(GeometryFlagBitsNVX::eNoDuplicateAnyHitInvocation) + allFlags = VkFlags(GeometryFlagBitsNV::eOpaque) | VkFlags(GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation) }; }; - enum class BuildAccelerationStructureFlagBitsNVX + enum class BuildAccelerationStructureFlagBitsNV { - eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NVX, - eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NVX, - ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NVX, - ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NVX, - eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NVX + eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV, + eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV, + ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV, + ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV, + eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV }; - using BuildAccelerationStructureFlagsNVX = Flags; + using BuildAccelerationStructureFlagsNV = Flags; - VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNVX operator|( BuildAccelerationStructureFlagBitsNVX bit0, BuildAccelerationStructureFlagBitsNVX bit1 ) + VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 ) { - return BuildAccelerationStructureFlagsNVX( bit0 ) | bit1; + return BuildAccelerationStructureFlagsNV( bit0 ) | bit1; } - VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNVX operator~( BuildAccelerationStructureFlagBitsNVX bits ) + VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits ) { - return ~( BuildAccelerationStructureFlagsNVX( bits ) ); + return ~( BuildAccelerationStructureFlagsNV( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(BuildAccelerationStructureFlagBitsNVX::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNVX::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNVX::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNVX::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNVX::eLowMemory) + allFlags = VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNV::eLowMemory) }; }; - enum class CopyAccelerationStructureModeNVX + enum class CopyAccelerationStructureModeNV { - eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX, - eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX + eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV, + eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV }; - enum class AccelerationStructureTypeNVX + enum class AccelerationStructureTypeNV { - eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX, - eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX + eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, + eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV }; - enum class GeometryTypeNVX + enum class GeometryTypeNV { - eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NVX, - eAabbs = VK_GEOMETRY_TYPE_AABBS_NVX + eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV, + eAabbs = VK_GEOMETRY_TYPE_AABBS_NV }; - struct GeometryNVX + struct GeometryNV { - GeometryNVX( GeometryTypeNVX geometryType_ = GeometryTypeNVX::eTriangles, - GeometryDataNVX geometry_ = GeometryDataNVX(), - GeometryFlagsNVX flags_ = GeometryFlagsNVX() ) + GeometryNV( GeometryTypeNV geometryType_ = GeometryTypeNV::eTriangles, + GeometryDataNV geometry_ = GeometryDataNV(), + GeometryFlagsNV flags_ = GeometryFlagsNV() ) : geometryType( geometryType_ ) , geometry( geometry_ ) , flags( flags_ ) { } - GeometryNVX( VkGeometryNVX const & rhs ) + GeometryNV( VkGeometryNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryNVX ) ); + memcpy( this, &rhs, sizeof( GeometryNV ) ); } - GeometryNVX& operator=( VkGeometryNVX const & rhs ) + GeometryNV& operator=( VkGeometryNV const & rhs ) { - memcpy( this, &rhs, sizeof( GeometryNVX ) ); + memcpy( this, &rhs, sizeof( GeometryNV ) ); return *this; } - GeometryNVX& setPNext( const void* pNext_ ) + GeometryNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - GeometryNVX& setGeometryType( GeometryTypeNVX geometryType_ ) + GeometryNV& setGeometryType( GeometryTypeNV geometryType_ ) { geometryType = geometryType_; return *this; } - GeometryNVX& setGeometry( GeometryDataNVX geometry_ ) + GeometryNV& setGeometry( GeometryDataNV geometry_ ) { geometry = geometry_; return *this; } - GeometryNVX& setFlags( GeometryFlagsNVX flags_ ) + GeometryNV& setFlags( GeometryFlagsNV flags_ ) { flags = flags_; return *this; } - operator VkGeometryNVX const&() const + operator VkGeometryNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkGeometryNVX &() + operator VkGeometryNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( GeometryNVX const& rhs ) const + bool operator==( GeometryNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -37239,131 +36993,582 @@ public: && ( flags == rhs.flags ); } - bool operator!=( GeometryNVX const& rhs ) const + bool operator!=( GeometryNV const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::eGeometryNVX; + StructureType sType = StructureType::eGeometryNV; public: const void* pNext = nullptr; - GeometryTypeNVX geometryType; - GeometryDataNVX geometry; - GeometryFlagsNVX flags; + GeometryTypeNV geometryType; + GeometryDataNV geometry; + GeometryFlagsNV flags; }; - static_assert( sizeof( GeometryNVX ) == sizeof( VkGeometryNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); - struct AccelerationStructureCreateInfoNVX + struct AccelerationStructureInfoNV { - AccelerationStructureCreateInfoNVX( AccelerationStructureTypeNVX type_ = AccelerationStructureTypeNVX::eTopLevel, - BuildAccelerationStructureFlagsNVX flags_ = BuildAccelerationStructureFlagsNVX(), - DeviceSize compactedSize_ = 0, - uint32_t instanceCount_ = 0, - uint32_t geometryCount_ = 0, - const GeometryNVX* pGeometries_ = nullptr ) + AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = AccelerationStructureTypeNV::eTopLevel, + BuildAccelerationStructureFlagsNV flags_ = BuildAccelerationStructureFlagsNV(), + uint32_t instanceCount_ = 0, + uint32_t geometryCount_ = 0, + const GeometryNV* pGeometries_ = nullptr ) : type( type_ ) , flags( flags_ ) - , compactedSize( compactedSize_ ) , instanceCount( instanceCount_ ) , geometryCount( geometryCount_ ) , pGeometries( pGeometries_ ) { } - AccelerationStructureCreateInfoNVX( VkAccelerationStructureCreateInfoNVX const & rhs ) + AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNVX ) ); + memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) ); } - AccelerationStructureCreateInfoNVX& operator=( VkAccelerationStructureCreateInfoNVX const & rhs ) + AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNVX ) ); + memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) ); return *this; } - AccelerationStructureCreateInfoNVX& setPNext( const void* pNext_ ) + AccelerationStructureInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - AccelerationStructureCreateInfoNVX& setType( AccelerationStructureTypeNVX type_ ) + AccelerationStructureInfoNV& setType( AccelerationStructureTypeNV type_ ) { type = type_; return *this; } - AccelerationStructureCreateInfoNVX& setFlags( BuildAccelerationStructureFlagsNVX flags_ ) + AccelerationStructureInfoNV& setFlags( BuildAccelerationStructureFlagsNV flags_ ) { flags = flags_; return *this; } - AccelerationStructureCreateInfoNVX& setCompactedSize( DeviceSize compactedSize_ ) - { - compactedSize = compactedSize_; - return *this; - } - - AccelerationStructureCreateInfoNVX& setInstanceCount( uint32_t instanceCount_ ) + AccelerationStructureInfoNV& setInstanceCount( uint32_t instanceCount_ ) { instanceCount = instanceCount_; return *this; } - AccelerationStructureCreateInfoNVX& setGeometryCount( uint32_t geometryCount_ ) + AccelerationStructureInfoNV& setGeometryCount( uint32_t geometryCount_ ) { geometryCount = geometryCount_; return *this; } - AccelerationStructureCreateInfoNVX& setPGeometries( const GeometryNVX* pGeometries_ ) + AccelerationStructureInfoNV& setPGeometries( const GeometryNV* pGeometries_ ) { pGeometries = pGeometries_; return *this; } - operator VkAccelerationStructureCreateInfoNVX const&() const + operator VkAccelerationStructureInfoNV const&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - operator VkAccelerationStructureCreateInfoNVX &() + operator VkAccelerationStructureInfoNV &() { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( AccelerationStructureCreateInfoNVX const& rhs ) const + bool operator==( AccelerationStructureInfoNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) - && ( compactedSize == rhs.compactedSize ) && ( instanceCount == rhs.instanceCount ) && ( geometryCount == rhs.geometryCount ) && ( pGeometries == rhs.pGeometries ); } - bool operator!=( AccelerationStructureCreateInfoNVX const& rhs ) const + bool operator!=( AccelerationStructureInfoNV const& rhs ) const { return !operator==( rhs ); } private: - StructureType sType = StructureType::eAccelerationStructureCreateInfoNVX; + StructureType sType = StructureType::eAccelerationStructureInfoNV; public: const void* pNext = nullptr; - AccelerationStructureTypeNVX type; - BuildAccelerationStructureFlagsNVX flags; - DeviceSize compactedSize; + AccelerationStructureTypeNV type; + BuildAccelerationStructureFlagsNV flags; uint32_t instanceCount; uint32_t geometryCount; - const GeometryNVX* pGeometries; + const GeometryNV* pGeometries; + }; + static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" ); + + struct AccelerationStructureCreateInfoNV + { + AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = 0, + AccelerationStructureInfoNV info_ = AccelerationStructureInfoNV() ) + : compactedSize( compactedSize_ ) + , info( info_ ) + { + } + + AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) ); + } + + AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) ); + return *this; + } + AccelerationStructureCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AccelerationStructureCreateInfoNV& setCompactedSize( DeviceSize compactedSize_ ) + { + compactedSize = compactedSize_; + return *this; + } + + AccelerationStructureCreateInfoNV& setInfo( AccelerationStructureInfoNV info_ ) + { + info = info_; + return *this; + } + + operator VkAccelerationStructureCreateInfoNV const&() const + { + return *reinterpret_cast(this); + } + + operator VkAccelerationStructureCreateInfoNV &() + { + return *reinterpret_cast(this); + } + + bool operator==( AccelerationStructureCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( compactedSize == rhs.compactedSize ) + && ( info == rhs.info ); + } + + bool operator!=( AccelerationStructureCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; + + public: + const void* pNext = nullptr; + DeviceSize compactedSize; + AccelerationStructureInfoNV info; + }; + static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" ); + + enum class AccelerationStructureMemoryRequirementsTypeNV + { + eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, + eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV, + eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV + }; + + struct AccelerationStructureMemoryRequirementsInfoNV + { + AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject, + AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() ) + : type( type_ ) + , accelerationStructure( accelerationStructure_ ) + { + } + + AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) ); + } + + AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) ); + return *this; + } + AccelerationStructureMemoryRequirementsInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AccelerationStructureMemoryRequirementsInfoNV& setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) + { + type = type_; + return *this; + } + + AccelerationStructureMemoryRequirementsInfoNV& setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) + { + accelerationStructure = accelerationStructure_; + return *this; + } + + operator VkAccelerationStructureMemoryRequirementsInfoNV const&() const + { + return *reinterpret_cast(this); + } + + operator VkAccelerationStructureMemoryRequirementsInfoNV &() + { + return *reinterpret_cast(this); + } + + bool operator==( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( type == rhs.type ) + && ( accelerationStructure == rhs.accelerationStructure ); + } + + bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + + public: + const void* pNext = nullptr; + AccelerationStructureMemoryRequirementsTypeNV type; + AccelerationStructureNV accelerationStructure; + }; + static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" ); + + enum class RayTracingShaderGroupTypeNV + { + eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV, + eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV, + eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV + }; + + struct RayTracingShaderGroupCreateInfoNV + { + RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeNV type_ = RayTracingShaderGroupTypeNV::eGeneral, + uint32_t generalShader_ = 0, + uint32_t closestHitShader_ = 0, + uint32_t anyHitShader_ = 0, + uint32_t intersectionShader_ = 0 ) + : type( type_ ) + , generalShader( generalShader_ ) + , closestHitShader( closestHitShader_ ) + , anyHitShader( anyHitShader_ ) + , intersectionShader( intersectionShader_ ) + { + } + + RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) ); + } + + RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) ); + return *this; + } + RayTracingShaderGroupCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV& setType( RayTracingShaderGroupTypeNV type_ ) + { + type = type_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV& setGeneralShader( uint32_t generalShader_ ) + { + generalShader = generalShader_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV& setClosestHitShader( uint32_t closestHitShader_ ) + { + closestHitShader = closestHitShader_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV& setAnyHitShader( uint32_t anyHitShader_ ) + { + anyHitShader = anyHitShader_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV& setIntersectionShader( uint32_t intersectionShader_ ) + { + intersectionShader = intersectionShader_; + return *this; + } + + operator VkRayTracingShaderGroupCreateInfoNV const&() const + { + return *reinterpret_cast(this); + } + + operator VkRayTracingShaderGroupCreateInfoNV &() + { + return *reinterpret_cast(this); + } + + bool operator==( RayTracingShaderGroupCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( type == rhs.type ) + && ( generalShader == rhs.generalShader ) + && ( closestHitShader == rhs.closestHitShader ) + && ( anyHitShader == rhs.anyHitShader ) + && ( intersectionShader == rhs.intersectionShader ); + } + + bool operator!=( RayTracingShaderGroupCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; + + public: + const void* pNext = nullptr; + RayTracingShaderGroupTypeNV type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + }; + static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" ); + + struct RayTracingPipelineCreateInfoNV + { + RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = PipelineCreateFlags(), + uint32_t stageCount_ = 0, + const PipelineShaderStageCreateInfo* pStages_ = nullptr, + uint32_t groupCount_ = 0, + const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr, + uint32_t maxRecursionDepth_ = 0, + PipelineLayout layout_ = PipelineLayout(), + Pipeline basePipelineHandle_ = Pipeline(), + int32_t basePipelineIndex_ = 0 ) + : flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , groupCount( groupCount_ ) + , pGroups( pGroups_ ) + , maxRecursionDepth( maxRecursionDepth_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } + + RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) ); + } + + RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) ); + return *this; + } + RayTracingPipelineCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setFlags( PipelineCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setStageCount( uint32_t stageCount_ ) + { + stageCount = stageCount_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setPStages( const PipelineShaderStageCreateInfo* pStages_ ) + { + pStages = pStages_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setGroupCount( uint32_t groupCount_ ) + { + groupCount = groupCount_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setPGroups( const RayTracingShaderGroupCreateInfoNV* pGroups_ ) + { + pGroups = pGroups_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) + { + maxRecursionDepth = maxRecursionDepth_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setLayout( PipelineLayout layout_ ) + { + layout = layout_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setBasePipelineHandle( Pipeline basePipelineHandle_ ) + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + RayTracingPipelineCreateInfoNV& setBasePipelineIndex( int32_t basePipelineIndex_ ) + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + operator VkRayTracingPipelineCreateInfoNV const&() const + { + return *reinterpret_cast(this); + } + + operator VkRayTracingPipelineCreateInfoNV &() + { + return *reinterpret_cast(this); + } + + bool operator==( RayTracingPipelineCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( stageCount == rhs.stageCount ) + && ( pStages == rhs.pStages ) + && ( groupCount == rhs.groupCount ) + && ( pGroups == rhs.pGroups ) + && ( maxRecursionDepth == rhs.maxRecursionDepth ) + && ( layout == rhs.layout ) + && ( basePipelineHandle == rhs.basePipelineHandle ) + && ( basePipelineIndex == rhs.basePipelineIndex ); + } + + bool operator!=( RayTracingPipelineCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; + + public: + const void* pNext = nullptr; + PipelineCreateFlags flags; + uint32_t stageCount; + const PipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const RayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + PipelineLayout layout; + Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; - static_assert( sizeof( AccelerationStructureCreateInfoNVX ) == sizeof( VkAccelerationStructureCreateInfoNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" ); + + enum class MemoryOverallocationBehaviorAMD + { + eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD, + eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD, + eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD + }; + + struct DeviceMemoryOverallocationCreateInfoAMD + { + DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault ) + : overallocationBehavior( overallocationBehavior_ ) + { + } + + DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) ); + } + + DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) ); + return *this; + } + DeviceMemoryOverallocationCreateInfoAMD& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceMemoryOverallocationCreateInfoAMD& setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ ) + { + overallocationBehavior = overallocationBehavior_; + return *this; + } + + operator VkDeviceMemoryOverallocationCreateInfoAMD const&() const + { + return *reinterpret_cast(this); + } + + operator VkDeviceMemoryOverallocationCreateInfoAMD &() + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( overallocationBehavior == rhs.overallocationBehavior ); + } + + bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + + public: + const void* pNext = nullptr; + MemoryOverallocationBehaviorAMD overallocationBehavior; + }; + static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" ); template Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() ); @@ -37982,20 +38187,24 @@ public: void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; template - void copyAccelerationStructureNVX( AccelerationStructureNVX dst, AccelerationStructureNVX src, CopyAccelerationStructureModeNVX mode, Dispatch const &d = Dispatch() ) const; + void copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d = Dispatch() ) const; template - void writeAccelerationStructurePropertiesNVX( AccelerationStructureNVX accelerationStructure, QueryType queryType, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const; + void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void writeAccelerationStructuresPropertiesNV( ArrayProxy accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - void buildAccelerationStructureNVX( AccelerationStructureTypeNVX type, uint32_t instanceCount, Buffer instanceData, DeviceSize instanceOffset, uint32_t geometryCount, const GeometryNVX* pGeometries, BuildAccelerationStructureFlagsNVX flags, Bool32 update, AccelerationStructureNVX dst, AccelerationStructureNVX src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const; + void buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - void buildAccelerationStructureNVX( AccelerationStructureTypeNVX type, uint32_t instanceCount, Buffer instanceData, DeviceSize instanceOffset, ArrayProxy geometries, BuildAccelerationStructureFlagsNVX flags, Bool32 update, AccelerationStructureNVX dst, AccelerationStructureNVX src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const; + void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - void traceRaysNVX( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, uint32_t width, uint32_t height, Dispatch const &d = Dispatch() ) const; + void traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const; @@ -39265,56 +39474,55 @@ public: #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNVX( AccelerationStructureNVX dst, AccelerationStructureNVX src, CopyAccelerationStructureModeNVX mode, Dispatch const &d) const + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d) const { - d.vkCmdCopyAccelerationStructureNVX( m_commandBuffer, static_cast( dst ), static_cast( src ), static_cast( mode ) ); + d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast( dst ), static_cast( src ), static_cast( mode ) ); } #else template - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNVX( AccelerationStructureNVX dst, AccelerationStructureNVX src, CopyAccelerationStructureModeNVX mode, Dispatch const &d ) const + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d ) const { - d.vkCmdCopyAccelerationStructureNVX( m_commandBuffer, static_cast( dst ), static_cast( src ), static_cast( mode ) ); + d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast( dst ), static_cast( src ), static_cast( mode ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructurePropertiesNVX( AccelerationStructureNVX accelerationStructure, QueryType queryType, QueryPool queryPool, uint32_t query, Dispatch const &d) const + VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const { - d.vkCmdWriteAccelerationStructurePropertiesNVX( m_commandBuffer, static_cast( accelerationStructure ), static_cast( queryType ), static_cast( queryPool ), query ); + d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast( pAccelerationStructures ), static_cast( queryType ), static_cast( queryPool ), firstQuery ); } -#else +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructurePropertiesNVX( AccelerationStructureNVX accelerationStructure, QueryType queryType, QueryPool queryPool, uint32_t query, Dispatch const &d ) const + VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const { - d.vkCmdWriteAccelerationStructurePropertiesNVX( m_commandBuffer, static_cast( accelerationStructure ), static_cast( queryType ), static_cast( queryPool ), query ); + d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast( accelerationStructures.data() ), static_cast( queryType ), static_cast( queryPool ), firstQuery ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNVX( AccelerationStructureTypeNVX type, uint32_t instanceCount, Buffer instanceData, DeviceSize instanceOffset, uint32_t geometryCount, const GeometryNVX* pGeometries, BuildAccelerationStructureFlagsNVX flags, Bool32 update, AccelerationStructureNVX dst, AccelerationStructureNVX src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const { - d.vkCmdBuildAccelerationStructureNVX( m_commandBuffer, static_cast( type ), instanceCount, static_cast( instanceData ), instanceOffset, geometryCount, reinterpret_cast( pGeometries ), static_cast( flags ), update, static_cast( dst ), static_cast( src ), static_cast( scratch ), scratchOffset ); + d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast( pInfo ), static_cast( instanceData ), instanceOffset, update, static_cast( dst ), static_cast( src ), static_cast( scratch ), scratchOffset ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNVX( AccelerationStructureTypeNVX type, uint32_t instanceCount, Buffer instanceData, DeviceSize instanceOffset, ArrayProxy geometries, BuildAccelerationStructureFlagsNVX flags, Bool32 update, AccelerationStructureNVX dst, AccelerationStructureNVX src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const { - d.vkCmdBuildAccelerationStructureNVX( m_commandBuffer, static_cast( type ), instanceCount, static_cast( instanceData ), instanceOffset, geometries.size() , reinterpret_cast( geometries.data() ), static_cast( flags ), update, static_cast( dst ), static_cast( src ), static_cast( scratch ), scratchOffset ); + d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast( &info ), static_cast( instanceData ), instanceOffset, update, static_cast( dst ), static_cast( src ), static_cast( scratch ), scratchOffset ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void CommandBuffer::traceRaysNVX( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, uint32_t width, uint32_t height, Dispatch const &d) const + VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const { - d.vkCmdTraceRaysNVX( m_commandBuffer, static_cast( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, width, height ); + d.vkCmdTraceRaysNV( m_commandBuffer, static_cast( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth ); } #else template - VULKAN_HPP_INLINE void CommandBuffer::traceRaysNVX( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, uint32_t width, uint32_t height, Dispatch const &d ) const + VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const { - d.vkCmdTraceRaysNVX( m_commandBuffer, static_cast( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, width, height ); + d.vkCmdTraceRaysNV( m_commandBuffer, static_cast( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -39688,8 +39896,8 @@ public: #ifndef VULKAN_HPP_NO_SMART_HANDLE class Device; - template class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueAccelerationStructureNVX = UniqueHandle; + template class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueAccelerationStructureNV = UniqueHandle; template class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; using UniqueBuffer = UniqueHandle; template class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; @@ -41193,88 +41401,81 @@ public: #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template - Result compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const; + Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const; #else template - ResultValueType::type compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const; + ResultValueType::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - Result createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNVX* pAccelerationStructure, Dispatch const &d = Dispatch() ) const; + Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - ResultValueType::type createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + ResultValueType::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_NO_SMART_HANDLE template - typename ResultValueType>::type createAccelerationStructureNVXUnique( const AccelerationStructureCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + typename ResultValueType>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - void destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; + void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - void destroy( AccelerationStructureNVX accelerationStructure, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - void getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; + void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d = Dispatch() ) const; + void destroy( AccelerationStructureNV accelerationStructure, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - void getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; + void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - MemoryRequirements2KHR getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d = Dispatch() ) const; + MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - Result bindAccelerationStructureMemoryNVX( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNVX* pBindInfos, Dispatch const &d = Dispatch() ) const; + Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - ResultValueType::type bindAccelerationStructureMemoryNVX( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; + ResultValueType::type bindAccelerationStructureMemoryNV( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - Result getRaytracingShaderHandlesNVX( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const; + Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - ResultValueType::type getRaytracingShaderHandlesNVX( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy data, Dispatch const &d = Dispatch() ) const; + ResultValueType::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy data, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - Result getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const; + Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - ResultValueType::type getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, ArrayProxy data, Dispatch const &d = Dispatch() ) const; + ResultValueType::type getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy data, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - Result createRaytracingPipelinesNVX( PipelineCache pipelineCache, uint32_t createInfoCount, const RaytracingPipelineCreateInfoNVX* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const; + Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createRaytracingPipelinesNVX( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + typename ResultValueType>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createRaytracingPipelinesNVX( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + typename ResultValueType>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; template - ResultValueType::type createRaytracingPipelineNVX( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + ResultValueType::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_NO_SMART_HANDLE template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType,Allocator>>::type createRaytracingPipelinesNVXUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + typename ResultValueType,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType,Allocator>>::type createRaytracingPipelinesNVXUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + typename ResultValueType,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; template - typename ResultValueType>::type createRaytracingPipelineNVXUnique( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + typename ResultValueType>::type createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -44635,179 +44836,164 @@ public: #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE Result Device::compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d) const + VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const { - return static_cast( d.vkCompileDeferredNVX( m_device, static_cast( pipeline ), shader ) ); + return static_cast( d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ) ); } #else template - VULKAN_HPP_INLINE ResultValueType::type Device::compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const + VULKAN_HPP_INLINE ResultValueType::type Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const { - Result result = static_cast( d.vkCompileDeferredNVX( m_device, static_cast( pipeline ), shader ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNVX" ); + Result result = static_cast( d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE Result Device::createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNVX* pAccelerationStructure, Dispatch const &d) const + VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const { - return static_cast( d.vkCreateAccelerationStructureNVX( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pAccelerationStructure ) ) ); + return static_cast( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pAccelerationStructure ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE ResultValueType::type Device::createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE ResultValueType::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const { - AccelerationStructureNVX accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ) ); - return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVX" ); + AccelerationStructureNV accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ) ); + return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" ); } #ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createAccelerationStructureNVXUnique( const AccelerationStructureCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const { - AccelerationStructureNVX accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ) ); + AccelerationStructureNV accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ) ); ObjectDestroy deleter( *this, allocator, d ); - return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVXUnique", deleter ); + return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVUnique", deleter ); } #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const { - d.vkDestroyAccelerationStructureNVX( m_device, static_cast( accelerationStructure ), reinterpret_cast( pAllocator ) ); + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( pAllocator ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional allocator, Dispatch const &d ) const { - d.vkDestroyAccelerationStructureNVX( m_device, static_cast( accelerationStructure ), reinterpret_cast( static_cast( allocator ) ) ); + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( static_cast( allocator ) ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const + VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const { - d.vkDestroyAccelerationStructureNVX( m_device, static_cast( accelerationStructure ), reinterpret_cast( pAllocator ) ); + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( pAllocator ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNVX accelerationStructure, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional allocator, Dispatch const &d ) const { - d.vkDestroyAccelerationStructureNVX( m_device, static_cast( accelerationStructure ), reinterpret_cast( static_cast( allocator ) ) ); + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( static_cast( allocator ) ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const + VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const { - d.vkGetAccelerationStructureMemoryRequirementsNVX( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d ) const + VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const { MemoryRequirements2KHR memoryRequirements; - d.vkGetAccelerationStructureMemoryRequirementsNVX( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); return memoryRequirements; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE void Device::getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const + VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const { - d.vkGetAccelerationStructureScratchMemoryRequirementsNVX( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + return static_cast( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d ) const + VULKAN_HPP_INLINE ResultValueType::type Device::bindAccelerationStructureMemoryNV( ArrayProxy bindInfos, Dispatch const &d ) const { - MemoryRequirements2KHR memoryRequirements; - d.vkGetAccelerationStructureScratchMemoryRequirementsNVX( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return memoryRequirements; + Result result = static_cast( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNVX( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNVX* pBindInfos, Dispatch const &d) const + VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const { - return static_cast( d.vkBindAccelerationStructureMemoryNVX( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::bindAccelerationStructureMemoryNVX( ArrayProxy bindInfos, Dispatch const &d ) const - { - Result result = static_cast( d.vkBindAccelerationStructureMemoryNVX( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNVX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getRaytracingShaderHandlesNVX( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const - { - return static_cast( d.vkGetRaytracingShaderHandlesNVX( m_device, static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); + return static_cast( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE ResultValueType::type Device::getRaytracingShaderHandlesNVX( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy data, Dispatch const &d ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy data, Dispatch const &d ) const { - Result result = static_cast( d.vkGetRaytracingShaderHandlesNVX( m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRaytracingShaderHandlesNVX" ); + Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const + VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const { - return static_cast( d.vkGetAccelerationStructureHandleNVX( m_device, static_cast( accelerationStructure ), dataSize, pData ) ); + return static_cast( d.vkGetAccelerationStructureHandleNV( m_device, static_cast( accelerationStructure ), dataSize, pData ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE ResultValueType::type Device::getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, ArrayProxy data, Dispatch const &d ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy data, Dispatch const &d ) const { - Result result = static_cast( d.vkGetAccelerationStructureHandleNVX( m_device, static_cast( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNVX" ); + Result result = static_cast( d.vkGetAccelerationStructureHandleNV( m_device, static_cast( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_INLINE Result Device::createRaytracingPipelinesNVX( PipelineCache pipelineCache, uint32_t createInfoCount, const RaytracingPipelineCreateInfoNVX* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const + VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const { - return static_cast( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); + return static_cast( d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRaytracingPipelinesNVX( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const { std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); - return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRaytracingPipelinesNVX" ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" ); } template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRaytracingPipelinesNVX( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const { std::vector pipelines( createInfos.size(), vectorAllocator ); - Result result = static_cast( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); - return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRaytracingPipelinesNVX" ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" ); } template - VULKAN_HPP_INLINE ResultValueType::type Device::createRaytracingPipelineNVX( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE ResultValueType::type Device::createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const { Pipeline pipeline; - Result result = static_cast( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); - return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRaytracingPipelineNVX" ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); + return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNV" ); } #ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createRaytracingPipelinesNVXUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const { static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); std::vector pipelines; pipelines.reserve( createInfos.size() ); Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); - Result result = static_cast(d.vkCreateRaytracingPipelinesNVX( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); + Result result = static_cast(d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); ObjectDestroy deleter( *this, allocator, d ); for ( size_t i=0 ; i - VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createRaytracingPipelinesNVXUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const { static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); std::vector pipelines; pipelines.reserve( createInfos.size() ); Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); - Result result = static_cast(d.vkCreateRaytracingPipelinesNVX( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); + Result result = static_cast(d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); ObjectDestroy deleter( *this, allocator, d ); for ( size_t i=0 ; i - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRaytracingPipelineNVXUnique( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const { Pipeline pipeline; - Result result = static_cast( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); ObjectDestroy deleter( *this, allocator, d ); - return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRaytracingPipelineNVXUnique", deleter ); + return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNVUnique", deleter ); } #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -45045,15 +45231,6 @@ public: ResultValueType::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - template - Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - template Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -45900,21 +46077,6 @@ public: } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d) const - { - return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d ) const - { - return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - template VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const { @@ -47228,19 +47390,6 @@ public: #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - template - Result createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - typename ResultValueType>::type createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - template void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -47590,34 +47739,6 @@ public: #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - template - VULKAN_HPP_INLINE Result Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator, d ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - template VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const { @@ -48446,8 +48567,8 @@ public: template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -48506,6 +48627,7 @@ public: template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits) { @@ -48801,20 +48923,6 @@ public: } #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - #ifdef VK_USE_PLATFORM_VI_NN VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN) { @@ -49148,7 +49256,7 @@ public: case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic"; case DescriptorType::eInputAttachment: return "InputAttachment"; case DescriptorType::eInlineUniformBlockEXT: return "InlineUniformBlockEXT"; - case DescriptorType::eAccelerationStructureNVX: return "AccelerationStructureNVX"; + case DescriptorType::eAccelerationStructureNV: return "AccelerationStructureNV"; default: return "invalid"; } } @@ -49161,7 +49269,7 @@ public: case QueryType::ePipelineStatistics: return "PipelineStatistics"; case QueryType::eTimestamp: return "Timestamp"; case QueryType::eTransformFeedbackStreamEXT: return "TransformFeedbackStreamEXT"; - case QueryType::eCompactedSizeNVX: return "CompactedSizeNVX"; + case QueryType::eAccelerationStructureCompactedSizeNV: return "AccelerationStructureCompactedSizeNV"; default: return "invalid"; } } @@ -49186,7 +49294,7 @@ public: { case PipelineBindPoint::eGraphics: return "Graphics"; case PipelineBindPoint::eCompute: return "Compute"; - case PipelineBindPoint::eRaytracingNVX: return "RaytracingNVX"; + case PipelineBindPoint::eRayTracingNV: return "RayTracingNV"; default: return "invalid"; } } @@ -49235,6 +49343,7 @@ public: { case IndexType::eUint16: return "Uint16"; case IndexType::eUint32: return "Uint32"; + case IndexType::eNoneNV: return "NoneNV"; default: return "invalid"; } } @@ -49872,7 +49981,6 @@ public: case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR"; case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR"; case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR"; - case StructureType::eMirSurfaceCreateInfoKHR: return "MirSurfaceCreateInfoKHR"; case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR"; case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR"; case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT"; @@ -50004,17 +50112,17 @@ public: case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV: return "PhysicalDeviceShadingRateImageFeaturesNV"; case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV: return "PhysicalDeviceShadingRateImagePropertiesNV"; case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV: return "PipelineViewportCoarseSampleOrderStateCreateInfoNV"; - case StructureType::eRaytracingPipelineCreateInfoNVX: return "RaytracingPipelineCreateInfoNVX"; - case StructureType::eAccelerationStructureCreateInfoNVX: return "AccelerationStructureCreateInfoNVX"; - case StructureType::eGeometryInstanceNVX: return "GeometryInstanceNVX"; - case StructureType::eGeometryNVX: return "GeometryNVX"; - case StructureType::eGeometryTrianglesNVX: return "GeometryTrianglesNVX"; - case StructureType::eGeometryAabbNVX: return "GeometryAabbNVX"; - case StructureType::eBindAccelerationStructureMemoryInfoNVX: return "BindAccelerationStructureMemoryInfoNVX"; - case StructureType::eDescriptorAccelerationStructureInfoNVX: return "DescriptorAccelerationStructureInfoNVX"; - case StructureType::eAccelerationStructureMemoryRequirementsInfoNVX: return "AccelerationStructureMemoryRequirementsInfoNVX"; - case StructureType::ePhysicalDeviceRaytracingPropertiesNVX: return "PhysicalDeviceRaytracingPropertiesNVX"; - case StructureType::eHitShaderModuleCreateInfoNVX: return "HitShaderModuleCreateInfoNVX"; + case StructureType::eRayTracingPipelineCreateInfoNV: return "RayTracingPipelineCreateInfoNV"; + case StructureType::eAccelerationStructureCreateInfoNV: return "AccelerationStructureCreateInfoNV"; + case StructureType::eGeometryNV: return "GeometryNV"; + case StructureType::eGeometryTrianglesNV: return "GeometryTrianglesNV"; + case StructureType::eGeometryAabbNV: return "GeometryAabbNV"; + case StructureType::eBindAccelerationStructureMemoryInfoNV: return "BindAccelerationStructureMemoryInfoNV"; + case StructureType::eWriteDescriptorSetAccelerationStructureNV: return "WriteDescriptorSetAccelerationStructureNV"; + case StructureType::eAccelerationStructureMemoryRequirementsInfoNV: return "AccelerationStructureMemoryRequirementsInfoNV"; + case StructureType::ePhysicalDeviceRayTracingPropertiesNV: return "PhysicalDeviceRayTracingPropertiesNV"; + case StructureType::eRayTracingShaderGroupCreateInfoNV: return "RayTracingShaderGroupCreateInfoNV"; + case StructureType::eAccelerationStructureInfoNV: return "AccelerationStructureInfoNV"; case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV: return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV"; case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV"; case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT"; @@ -50025,6 +50133,7 @@ public: case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR: return "PhysicalDeviceShaderAtomicInt64FeaturesKHR"; case StructureType::eCalibratedTimestampInfoEXT: return "CalibratedTimestampInfoEXT"; case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD"; + case StructureType::eDeviceMemoryOverallocationCreateInfoAMD: return "DeviceMemoryOverallocationCreateInfoAMD"; case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT"; case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT: return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT"; @@ -50129,7 +50238,7 @@ public: case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX"; case ObjectType::eDebugUtilsMessengerEXT: return "DebugUtilsMessengerEXT"; case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT"; - case ObjectType::eAccelerationStructureNVX: return "AccelerationStructureNVX"; + case ObjectType::eAccelerationStructureNV: return "AccelerationStructureNV"; default: return "invalid"; } } @@ -50251,8 +50360,8 @@ public: case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX"; case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT"; case AccessFlagBits::eShadingRateImageReadNV: return "ShadingRateImageReadNV"; - case AccessFlagBits::eAccelerationStructureReadNVX: return "AccelerationStructureReadNVX"; - case AccessFlagBits::eAccelerationStructureWriteNVX: return "AccelerationStructureWriteNVX"; + case AccessFlagBits::eAccelerationStructureReadNV: return "AccelerationStructureReadNV"; + case AccessFlagBits::eAccelerationStructureWriteNV: return "AccelerationStructureWriteNV"; default: return "invalid"; } } @@ -50286,8 +50395,8 @@ public: if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | "; if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | "; if (value & AccessFlagBits::eShadingRateImageReadNV) result += "ShadingRateImageReadNV | "; - if (value & AccessFlagBits::eAccelerationStructureReadNVX) result += "AccelerationStructureReadNVX | "; - if (value & AccessFlagBits::eAccelerationStructureWriteNVX) result += "AccelerationStructureWriteNVX | "; + if (value & AccessFlagBits::eAccelerationStructureReadNV) result += "AccelerationStructureReadNV | "; + if (value & AccessFlagBits::eAccelerationStructureWriteNV) result += "AccelerationStructureWriteNV | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -50307,7 +50416,7 @@ public: case BufferUsageFlagBits::eTransformFeedbackBufferEXT: return "TransformFeedbackBufferEXT"; case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT"; case BufferUsageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT"; - case BufferUsageFlagBits::eRaytracingNVX: return "RaytracingNVX"; + case BufferUsageFlagBits::eRayTracingNV: return "RayTracingNV"; default: return "invalid"; } } @@ -50328,7 +50437,7 @@ public: if (value & BufferUsageFlagBits::eTransformFeedbackBufferEXT) result += "TransformFeedbackBufferEXT | "; if (value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) result += "TransformFeedbackCounterBufferEXT | "; if (value & BufferUsageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | "; - if (value & BufferUsageFlagBits::eRaytracingNVX) result += "RaytracingNVX | "; + if (value & BufferUsageFlagBits::eRayTracingNV) result += "RayTracingNV | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -50367,12 +50476,12 @@ public: case ShaderStageFlagBits::eCompute: return "Compute"; case ShaderStageFlagBits::eAllGraphics: return "AllGraphics"; case ShaderStageFlagBits::eAll: return "All"; - case ShaderStageFlagBits::eRaygenNVX: return "RaygenNVX"; - case ShaderStageFlagBits::eAnyHitNVX: return "AnyHitNVX"; - case ShaderStageFlagBits::eClosestHitNVX: return "ClosestHitNVX"; - case ShaderStageFlagBits::eMissNVX: return "MissNVX"; - case ShaderStageFlagBits::eIntersectionNVX: return "IntersectionNVX"; - case ShaderStageFlagBits::eCallableNVX: return "CallableNVX"; + case ShaderStageFlagBits::eRaygenNV: return "RaygenNV"; + case ShaderStageFlagBits::eAnyHitNV: return "AnyHitNV"; + case ShaderStageFlagBits::eClosestHitNV: return "ClosestHitNV"; + case ShaderStageFlagBits::eMissNV: return "MissNV"; + case ShaderStageFlagBits::eIntersectionNV: return "IntersectionNV"; + case ShaderStageFlagBits::eCallableNV: return "CallableNV"; case ShaderStageFlagBits::eTaskNV: return "TaskNV"; case ShaderStageFlagBits::eMeshNV: return "MeshNV"; default: return "invalid"; @@ -50391,12 +50500,12 @@ public: if (value & ShaderStageFlagBits::eCompute) result += "Compute | "; if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | "; if (value & ShaderStageFlagBits::eAll) result += "All | "; - if (value & ShaderStageFlagBits::eRaygenNVX) result += "RaygenNVX | "; - if (value & ShaderStageFlagBits::eAnyHitNVX) result += "AnyHitNVX | "; - if (value & ShaderStageFlagBits::eClosestHitNVX) result += "ClosestHitNVX | "; - if (value & ShaderStageFlagBits::eMissNVX) result += "MissNVX | "; - if (value & ShaderStageFlagBits::eIntersectionNVX) result += "IntersectionNVX | "; - if (value & ShaderStageFlagBits::eCallableNVX) result += "CallableNVX | "; + if (value & ShaderStageFlagBits::eRaygenNV) result += "RaygenNV | "; + if (value & ShaderStageFlagBits::eAnyHitNV) result += "AnyHitNV | "; + if (value & ShaderStageFlagBits::eClosestHitNV) result += "ClosestHitNV | "; + if (value & ShaderStageFlagBits::eMissNV) result += "MissNV | "; + if (value & ShaderStageFlagBits::eIntersectionNV) result += "IntersectionNV | "; + if (value & ShaderStageFlagBits::eCallableNV) result += "CallableNV | "; if (value & ShaderStageFlagBits::eTaskNV) result += "TaskNV | "; if (value & ShaderStageFlagBits::eMeshNV) result += "MeshNV | "; return "{" + result.substr(0, result.size() - 3) + "}"; @@ -50487,7 +50596,7 @@ public: case PipelineCreateFlagBits::eDerivative: return "Derivative"; case PipelineCreateFlagBits::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex"; case PipelineCreateFlagBits::eDispatchBase: return "DispatchBase"; - case PipelineCreateFlagBits::eDeferCompileNVX: return "DeferCompileNVX"; + case PipelineCreateFlagBits::eDeferCompileNV: return "DeferCompileNV"; default: return "invalid"; } } @@ -50501,7 +50610,7 @@ public: if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | "; if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex) result += "ViewIndexFromDeviceIndex | "; if (value & PipelineCreateFlagBits::eDispatchBase) result += "DispatchBase | "; - if (value & PipelineCreateFlagBits::eDeferCompileNVX) result += "DeferCompileNVX | "; + if (value & PipelineCreateFlagBits::eDeferCompileNV) result += "DeferCompileNV | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -50806,7 +50915,8 @@ public: case PipelineStageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT"; case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX"; case PipelineStageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV"; - case PipelineStageFlagBits::eRaytracingNVX: return "RaytracingNVX"; + case PipelineStageFlagBits::eRayTracingShaderNV: return "RayTracingShaderNV"; + case PipelineStageFlagBits::eAccelerationStructureBuildNV: return "AccelerationStructureBuildNV"; case PipelineStageFlagBits::eTaskShaderNV: return "TaskShaderNV"; case PipelineStageFlagBits::eMeshShaderNV: return "MeshShaderNV"; default: return "invalid"; @@ -50838,7 +50948,8 @@ public: if (value & PipelineStageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | "; if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | "; if (value & PipelineStageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | "; - if (value & PipelineStageFlagBits::eRaytracingNVX) result += "RaytracingNVX | "; + if (value & PipelineStageFlagBits::eRayTracingShaderNV) result += "RayTracingShaderNV | "; + if (value & PipelineStageFlagBits::eAccelerationStructureBuildNV) result += "AccelerationStructureBuildNV | "; if (value & PipelineStageFlagBits::eTaskShaderNV) result += "TaskShaderNV | "; if (value & PipelineStageFlagBits::eMeshShaderNV) result += "MeshShaderNV | "; return "{" + result.substr(0, result.size() - 3) + "}"; @@ -51199,7 +51310,7 @@ public: case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt"; case DebugReportObjectTypeEXT::eSamplerYcbcrConversion: return "SamplerYcbcrConversion"; case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate"; - case DebugReportObjectTypeEXT::eAccelerationStructureNVX: return "AccelerationStructureNVX"; + case DebugReportObjectTypeEXT::eAccelerationStructureNV: return "AccelerationStructureNV"; default: return "invalid"; } } @@ -52016,99 +52127,132 @@ public: } } - VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagBitsNVX value) + VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagBitsNV value) { switch (value) { - case GeometryInstanceFlagBitsNVX::eTriangleCullDisable: return "TriangleCullDisable"; - case GeometryInstanceFlagBitsNVX::eTriangleCullFlipWinding: return "TriangleCullFlipWinding"; - case GeometryInstanceFlagBitsNVX::eForceOpaque: return "ForceOpaque"; - case GeometryInstanceFlagBitsNVX::eForceNoOpaque: return "ForceNoOpaque"; + case GeometryInstanceFlagBitsNV::eTriangleCullDisable: return "TriangleCullDisable"; + case GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise: return "TriangleFrontCounterclockwise"; + case GeometryInstanceFlagBitsNV::eForceOpaque: return "ForceOpaque"; + case GeometryInstanceFlagBitsNV::eForceNoOpaque: return "ForceNoOpaque"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagsNVX value) + VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagsNV value) { if (!value) return "{}"; std::string result; - if (value & GeometryInstanceFlagBitsNVX::eTriangleCullDisable) result += "TriangleCullDisable | "; - if (value & GeometryInstanceFlagBitsNVX::eTriangleCullFlipWinding) result += "TriangleCullFlipWinding | "; - if (value & GeometryInstanceFlagBitsNVX::eForceOpaque) result += "ForceOpaque | "; - if (value & GeometryInstanceFlagBitsNVX::eForceNoOpaque) result += "ForceNoOpaque | "; + if (value & GeometryInstanceFlagBitsNV::eTriangleCullDisable) result += "TriangleCullDisable | "; + if (value & GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) result += "TriangleFrontCounterclockwise | "; + if (value & GeometryInstanceFlagBitsNV::eForceOpaque) result += "ForceOpaque | "; + if (value & GeometryInstanceFlagBitsNV::eForceNoOpaque) result += "ForceNoOpaque | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(GeometryFlagBitsNVX value) + VULKAN_HPP_INLINE std::string to_string(GeometryFlagBitsNV value) { switch (value) { - case GeometryFlagBitsNVX::eOpaque: return "Opaque"; - case GeometryFlagBitsNVX::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation"; + case GeometryFlagBitsNV::eOpaque: return "Opaque"; + case GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(GeometryFlagsNVX value) + VULKAN_HPP_INLINE std::string to_string(GeometryFlagsNV value) { if (!value) return "{}"; std::string result; - if (value & GeometryFlagBitsNVX::eOpaque) result += "Opaque | "; - if (value & GeometryFlagBitsNVX::eNoDuplicateAnyHitInvocation) result += "NoDuplicateAnyHitInvocation | "; + if (value & GeometryFlagBitsNV::eOpaque) result += "Opaque | "; + if (value & GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation) result += "NoDuplicateAnyHitInvocation | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagBitsNVX value) + VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagBitsNV value) { switch (value) { - case BuildAccelerationStructureFlagBitsNVX::eAllowUpdate: return "AllowUpdate"; - case BuildAccelerationStructureFlagBitsNVX::eAllowCompaction: return "AllowCompaction"; - case BuildAccelerationStructureFlagBitsNVX::ePreferFastTrace: return "PreferFastTrace"; - case BuildAccelerationStructureFlagBitsNVX::ePreferFastBuild: return "PreferFastBuild"; - case BuildAccelerationStructureFlagBitsNVX::eLowMemory: return "LowMemory"; + case BuildAccelerationStructureFlagBitsNV::eAllowUpdate: return "AllowUpdate"; + case BuildAccelerationStructureFlagBitsNV::eAllowCompaction: return "AllowCompaction"; + case BuildAccelerationStructureFlagBitsNV::ePreferFastTrace: return "PreferFastTrace"; + case BuildAccelerationStructureFlagBitsNV::ePreferFastBuild: return "PreferFastBuild"; + case BuildAccelerationStructureFlagBitsNV::eLowMemory: return "LowMemory"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagsNVX value) + VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagsNV value) { if (!value) return "{}"; std::string result; - if (value & BuildAccelerationStructureFlagBitsNVX::eAllowUpdate) result += "AllowUpdate | "; - if (value & BuildAccelerationStructureFlagBitsNVX::eAllowCompaction) result += "AllowCompaction | "; - if (value & BuildAccelerationStructureFlagBitsNVX::ePreferFastTrace) result += "PreferFastTrace | "; - if (value & BuildAccelerationStructureFlagBitsNVX::ePreferFastBuild) result += "PreferFastBuild | "; - if (value & BuildAccelerationStructureFlagBitsNVX::eLowMemory) result += "LowMemory | "; + if (value & BuildAccelerationStructureFlagBitsNV::eAllowUpdate) result += "AllowUpdate | "; + if (value & BuildAccelerationStructureFlagBitsNV::eAllowCompaction) result += "AllowCompaction | "; + if (value & BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) result += "PreferFastTrace | "; + if (value & BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) result += "PreferFastBuild | "; + if (value & BuildAccelerationStructureFlagBitsNV::eLowMemory) result += "LowMemory | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(CopyAccelerationStructureModeNVX value) + VULKAN_HPP_INLINE std::string to_string(CopyAccelerationStructureModeNV value) + { + switch (value) + { + case CopyAccelerationStructureModeNV::eClone: return "Clone"; + case CopyAccelerationStructureModeNV::eCompact: return "Compact"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(AccelerationStructureTypeNV value) + { + switch (value) + { + case AccelerationStructureTypeNV::eTopLevel: return "TopLevel"; + case AccelerationStructureTypeNV::eBottomLevel: return "BottomLevel"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(GeometryTypeNV value) + { + switch (value) + { + case GeometryTypeNV::eTriangles: return "Triangles"; + case GeometryTypeNV::eAabbs: return "Aabbs"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(AccelerationStructureMemoryRequirementsTypeNV value) { switch (value) { - case CopyAccelerationStructureModeNVX::eClone: return "Clone"; - case CopyAccelerationStructureModeNVX::eCompact: return "Compact"; + case AccelerationStructureMemoryRequirementsTypeNV::eObject: return "Object"; + case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch: return "BuildScratch"; + case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch: return "UpdateScratch"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(AccelerationStructureTypeNVX value) + VULKAN_HPP_INLINE std::string to_string(RayTracingShaderGroupTypeNV value) { switch (value) { - case AccelerationStructureTypeNVX::eTopLevel: return "TopLevel"; - case AccelerationStructureTypeNVX::eBottomLevel: return "BottomLevel"; + case RayTracingShaderGroupTypeNV::eGeneral: return "General"; + case RayTracingShaderGroupTypeNV::eTrianglesHitGroup: return "TrianglesHitGroup"; + case RayTracingShaderGroupTypeNV::eProceduralHitGroup: return "ProceduralHitGroup"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(GeometryTypeNVX value) + VULKAN_HPP_INLINE std::string to_string(MemoryOverallocationBehaviorAMD value) { switch (value) { - case GeometryTypeNVX::eTriangles: return "Triangles"; - case GeometryTypeNVX::eAabbs: return "Aabbs"; + case MemoryOverallocationBehaviorAMD::eDefault: return "Default"; + case MemoryOverallocationBehaviorAMD::eAllowed: return "Allowed"; + case MemoryOverallocationBehaviorAMD::eDisallowed: return "Disallowed"; default: return "invalid"; } } @@ -52125,7 +52269,7 @@ public: PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; PFN_vkAllocateMemory vkAllocateMemory = 0; PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; - PFN_vkBindAccelerationStructureMemoryNVX vkBindAccelerationStructureMemoryNVX = 0; + PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; PFN_vkBindBufferMemory vkBindBufferMemory = 0; PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; @@ -52146,11 +52290,11 @@ public: PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; PFN_vkCmdBlitImage vkCmdBlitImage = 0; - PFN_vkCmdBuildAccelerationStructureNVX vkCmdBuildAccelerationStructureNVX = 0; + PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; - PFN_vkCmdCopyAccelerationStructureNVX vkCmdCopyAccelerationStructureNVX = 0; + PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; PFN_vkCmdCopyImage vkCmdCopyImage = 0; @@ -52215,14 +52359,14 @@ public: PFN_vkCmdSetViewport vkCmdSetViewport = 0; PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; - PFN_vkCmdTraceRaysNVX vkCmdTraceRaysNVX = 0; + PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; - PFN_vkCmdWriteAccelerationStructurePropertiesNVX vkCmdWriteAccelerationStructurePropertiesNVX = 0; + PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; - PFN_vkCompileDeferredNVX vkCompileDeferredNVX = 0; - PFN_vkCreateAccelerationStructureNVX vkCreateAccelerationStructureNVX = 0; + PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; + PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; #ifdef VK_USE_PLATFORM_ANDROID_KHR PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ @@ -52256,14 +52400,11 @@ public: #ifdef VK_USE_PLATFORM_MACOS_MVK PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; #endif /*VK_USE_PLATFORM_MACOS_MVK*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR = 0; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX = 0; PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; PFN_vkCreateQueryPool vkCreateQueryPool = 0; - PFN_vkCreateRaytracingPipelinesNVX vkCreateRaytracingPipelinesNVX = 0; + PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; PFN_vkCreateRenderPass vkCreateRenderPass = 0; PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; PFN_vkCreateSampler vkCreateSampler = 0; @@ -52292,7 +52433,7 @@ public: PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; - PFN_vkDestroyAccelerationStructureNVX vkDestroyAccelerationStructureNVX = 0; + PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; PFN_vkDestroyBuffer vkDestroyBuffer = 0; PFN_vkDestroyBufferView vkDestroyBufferView = 0; PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; @@ -52339,9 +52480,8 @@ public: PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; PFN_vkFreeMemory vkFreeMemory = 0; - PFN_vkGetAccelerationStructureHandleNVX vkGetAccelerationStructureHandleNVX = 0; - PFN_vkGetAccelerationStructureMemoryRequirementsNVX vkGetAccelerationStructureMemoryRequirementsNVX = 0; - PFN_vkGetAccelerationStructureScratchMemoryRequirementsNVX vkGetAccelerationStructureScratchMemoryRequirementsNVX = 0; + PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; + PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; #ifdef VK_USE_PLATFORM_ANDROID_ANDROID PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; #endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ @@ -52420,9 +52560,6 @@ public: PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; -#ifdef VK_USE_PLATFORM_MIR_KHR - PFN_vkGetPhysicalDeviceMirPresentationSupportKHR vkGetPhysicalDeviceMirPresentationSupportKHR = 0; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; @@ -52459,7 +52596,7 @@ public: #ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; #endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - PFN_vkGetRaytracingShaderHandlesNVX vkGetRaytracingShaderHandlesNVX = 0; + PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; @@ -52532,7 +52669,7 @@ public: vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(device ? device.getProcAddr( "vkAllocateDescriptorSets") : instance.getProcAddr( "vkAllocateDescriptorSets")); vkAllocateMemory = PFN_vkAllocateMemory(device ? device.getProcAddr( "vkAllocateMemory") : instance.getProcAddr( "vkAllocateMemory")); vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(device ? device.getProcAddr( "vkBeginCommandBuffer") : instance.getProcAddr( "vkBeginCommandBuffer")); - vkBindAccelerationStructureMemoryNVX = PFN_vkBindAccelerationStructureMemoryNVX(device ? device.getProcAddr( "vkBindAccelerationStructureMemoryNVX") : instance.getProcAddr( "vkBindAccelerationStructureMemoryNVX")); + vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(device ? device.getProcAddr( "vkBindAccelerationStructureMemoryNV") : instance.getProcAddr( "vkBindAccelerationStructureMemoryNV")); vkBindBufferMemory = PFN_vkBindBufferMemory(device ? device.getProcAddr( "vkBindBufferMemory") : instance.getProcAddr( "vkBindBufferMemory")); vkBindBufferMemory2 = PFN_vkBindBufferMemory2(device ? device.getProcAddr( "vkBindBufferMemory2") : instance.getProcAddr( "vkBindBufferMemory2")); vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(device ? device.getProcAddr( "vkBindBufferMemory2KHR") : instance.getProcAddr( "vkBindBufferMemory2KHR")); @@ -52553,11 +52690,11 @@ public: vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT(device ? device.getProcAddr( "vkCmdBindTransformFeedbackBuffersEXT") : instance.getProcAddr( "vkCmdBindTransformFeedbackBuffersEXT")); vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(device ? device.getProcAddr( "vkCmdBindVertexBuffers") : instance.getProcAddr( "vkCmdBindVertexBuffers")); vkCmdBlitImage = PFN_vkCmdBlitImage(device ? device.getProcAddr( "vkCmdBlitImage") : instance.getProcAddr( "vkCmdBlitImage")); - vkCmdBuildAccelerationStructureNVX = PFN_vkCmdBuildAccelerationStructureNVX(device ? device.getProcAddr( "vkCmdBuildAccelerationStructureNVX") : instance.getProcAddr( "vkCmdBuildAccelerationStructureNVX")); + vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(device ? device.getProcAddr( "vkCmdBuildAccelerationStructureNV") : instance.getProcAddr( "vkCmdBuildAccelerationStructureNV")); vkCmdClearAttachments = PFN_vkCmdClearAttachments(device ? device.getProcAddr( "vkCmdClearAttachments") : instance.getProcAddr( "vkCmdClearAttachments")); vkCmdClearColorImage = PFN_vkCmdClearColorImage(device ? device.getProcAddr( "vkCmdClearColorImage") : instance.getProcAddr( "vkCmdClearColorImage")); vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(device ? device.getProcAddr( "vkCmdClearDepthStencilImage") : instance.getProcAddr( "vkCmdClearDepthStencilImage")); - vkCmdCopyAccelerationStructureNVX = PFN_vkCmdCopyAccelerationStructureNVX(device ? device.getProcAddr( "vkCmdCopyAccelerationStructureNVX") : instance.getProcAddr( "vkCmdCopyAccelerationStructureNVX")); + vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(device ? device.getProcAddr( "vkCmdCopyAccelerationStructureNV") : instance.getProcAddr( "vkCmdCopyAccelerationStructureNV")); vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(device ? device.getProcAddr( "vkCmdCopyBuffer") : instance.getProcAddr( "vkCmdCopyBuffer")); vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(device ? device.getProcAddr( "vkCmdCopyBufferToImage") : instance.getProcAddr( "vkCmdCopyBufferToImage")); vkCmdCopyImage = PFN_vkCmdCopyImage(device ? device.getProcAddr( "vkCmdCopyImage") : instance.getProcAddr( "vkCmdCopyImage")); @@ -52622,14 +52759,14 @@ public: vkCmdSetViewport = PFN_vkCmdSetViewport(device ? device.getProcAddr( "vkCmdSetViewport") : instance.getProcAddr( "vkCmdSetViewport")); vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV(device ? device.getProcAddr( "vkCmdSetViewportShadingRatePaletteNV") : instance.getProcAddr( "vkCmdSetViewportShadingRatePaletteNV")); vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(device ? device.getProcAddr( "vkCmdSetViewportWScalingNV") : instance.getProcAddr( "vkCmdSetViewportWScalingNV")); - vkCmdTraceRaysNVX = PFN_vkCmdTraceRaysNVX(device ? device.getProcAddr( "vkCmdTraceRaysNVX") : instance.getProcAddr( "vkCmdTraceRaysNVX")); + vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(device ? device.getProcAddr( "vkCmdTraceRaysNV") : instance.getProcAddr( "vkCmdTraceRaysNV")); vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(device ? device.getProcAddr( "vkCmdUpdateBuffer") : instance.getProcAddr( "vkCmdUpdateBuffer")); vkCmdWaitEvents = PFN_vkCmdWaitEvents(device ? device.getProcAddr( "vkCmdWaitEvents") : instance.getProcAddr( "vkCmdWaitEvents")); - vkCmdWriteAccelerationStructurePropertiesNVX = PFN_vkCmdWriteAccelerationStructurePropertiesNVX(device ? device.getProcAddr( "vkCmdWriteAccelerationStructurePropertiesNVX") : instance.getProcAddr( "vkCmdWriteAccelerationStructurePropertiesNVX")); + vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(device ? device.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV") : instance.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV")); vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(device ? device.getProcAddr( "vkCmdWriteBufferMarkerAMD") : instance.getProcAddr( "vkCmdWriteBufferMarkerAMD")); vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(device ? device.getProcAddr( "vkCmdWriteTimestamp") : instance.getProcAddr( "vkCmdWriteTimestamp")); - vkCompileDeferredNVX = PFN_vkCompileDeferredNVX(device ? device.getProcAddr( "vkCompileDeferredNVX") : instance.getProcAddr( "vkCompileDeferredNVX")); - vkCreateAccelerationStructureNVX = PFN_vkCreateAccelerationStructureNVX(device ? device.getProcAddr( "vkCreateAccelerationStructureNVX") : instance.getProcAddr( "vkCreateAccelerationStructureNVX")); + vkCompileDeferredNV = PFN_vkCompileDeferredNV(device ? device.getProcAddr( "vkCompileDeferredNV") : instance.getProcAddr( "vkCompileDeferredNV")); + vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(device ? device.getProcAddr( "vkCreateAccelerationStructureNV") : instance.getProcAddr( "vkCreateAccelerationStructureNV")); #ifdef VK_USE_PLATFORM_ANDROID_KHR vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR")); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ @@ -52663,14 +52800,11 @@ public: #ifdef VK_USE_PLATFORM_MACOS_MVK vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(instance.getProcAddr( "vkCreateMacOSSurfaceMVK")); #endif /*VK_USE_PLATFORM_MACOS_MVK*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - vkCreateMirSurfaceKHR = PFN_vkCreateMirSurfaceKHR(instance.getProcAddr( "vkCreateMirSurfaceKHR")); -#endif /*VK_USE_PLATFORM_MIR_KHR*/ vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX(device ? device.getProcAddr( "vkCreateObjectTableNVX") : instance.getProcAddr( "vkCreateObjectTableNVX")); vkCreatePipelineCache = PFN_vkCreatePipelineCache(device ? device.getProcAddr( "vkCreatePipelineCache") : instance.getProcAddr( "vkCreatePipelineCache")); vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(device ? device.getProcAddr( "vkCreatePipelineLayout") : instance.getProcAddr( "vkCreatePipelineLayout")); vkCreateQueryPool = PFN_vkCreateQueryPool(device ? device.getProcAddr( "vkCreateQueryPool") : instance.getProcAddr( "vkCreateQueryPool")); - vkCreateRaytracingPipelinesNVX = PFN_vkCreateRaytracingPipelinesNVX(device ? device.getProcAddr( "vkCreateRaytracingPipelinesNVX") : instance.getProcAddr( "vkCreateRaytracingPipelinesNVX")); + vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(device ? device.getProcAddr( "vkCreateRayTracingPipelinesNV") : instance.getProcAddr( "vkCreateRayTracingPipelinesNV")); vkCreateRenderPass = PFN_vkCreateRenderPass(device ? device.getProcAddr( "vkCreateRenderPass") : instance.getProcAddr( "vkCreateRenderPass")); vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(device ? device.getProcAddr( "vkCreateRenderPass2KHR") : instance.getProcAddr( "vkCreateRenderPass2KHR")); vkCreateSampler = PFN_vkCreateSampler(device ? device.getProcAddr( "vkCreateSampler") : instance.getProcAddr( "vkCreateSampler")); @@ -52699,7 +52833,7 @@ public: vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectNameEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectNameEXT")); vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectTagEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectTagEXT")); vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(instance.getProcAddr( "vkDebugReportMessageEXT")); - vkDestroyAccelerationStructureNVX = PFN_vkDestroyAccelerationStructureNVX(device ? device.getProcAddr( "vkDestroyAccelerationStructureNVX") : instance.getProcAddr( "vkDestroyAccelerationStructureNVX")); + vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(device ? device.getProcAddr( "vkDestroyAccelerationStructureNV") : instance.getProcAddr( "vkDestroyAccelerationStructureNV")); vkDestroyBuffer = PFN_vkDestroyBuffer(device ? device.getProcAddr( "vkDestroyBuffer") : instance.getProcAddr( "vkDestroyBuffer")); vkDestroyBufferView = PFN_vkDestroyBufferView(device ? device.getProcAddr( "vkDestroyBufferView") : instance.getProcAddr( "vkDestroyBufferView")); vkDestroyCommandPool = PFN_vkDestroyCommandPool(device ? device.getProcAddr( "vkDestroyCommandPool") : instance.getProcAddr( "vkDestroyCommandPool")); @@ -52746,9 +52880,8 @@ public: vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(device ? device.getProcAddr( "vkFreeCommandBuffers") : instance.getProcAddr( "vkFreeCommandBuffers")); vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(device ? device.getProcAddr( "vkFreeDescriptorSets") : instance.getProcAddr( "vkFreeDescriptorSets")); vkFreeMemory = PFN_vkFreeMemory(device ? device.getProcAddr( "vkFreeMemory") : instance.getProcAddr( "vkFreeMemory")); - vkGetAccelerationStructureHandleNVX = PFN_vkGetAccelerationStructureHandleNVX(device ? device.getProcAddr( "vkGetAccelerationStructureHandleNVX") : instance.getProcAddr( "vkGetAccelerationStructureHandleNVX")); - vkGetAccelerationStructureMemoryRequirementsNVX = PFN_vkGetAccelerationStructureMemoryRequirementsNVX(device ? device.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNVX") : instance.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNVX")); - vkGetAccelerationStructureScratchMemoryRequirementsNVX = PFN_vkGetAccelerationStructureScratchMemoryRequirementsNVX(device ? device.getProcAddr( "vkGetAccelerationStructureScratchMemoryRequirementsNVX") : instance.getProcAddr( "vkGetAccelerationStructureScratchMemoryRequirementsNVX")); + vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(device ? device.getProcAddr( "vkGetAccelerationStructureHandleNV") : instance.getProcAddr( "vkGetAccelerationStructureHandleNV")); + vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV(device ? device.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNV") : instance.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNV")); #ifdef VK_USE_PLATFORM_ANDROID_ANDROID vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(device ? device.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID") : instance.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID")); #endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ @@ -52827,9 +52960,6 @@ public: vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties")); vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2")); vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR")); -#ifdef VK_USE_PLATFORM_MIR_KHR - vkGetPhysicalDeviceMirPresentationSupportKHR = PFN_vkGetPhysicalDeviceMirPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceMirPresentationSupportKHR")); -#endif /*VK_USE_PLATFORM_MIR_KHR*/ vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(instance.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT")); vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR(instance.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR")); vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(instance.getProcAddr( "vkGetPhysicalDeviceProperties")); @@ -52866,7 +52996,7 @@ public: #ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(instance.getProcAddr( "vkGetRandROutputDisplayEXT")); #endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - vkGetRaytracingShaderHandlesNVX = PFN_vkGetRaytracingShaderHandlesNVX(device ? device.getProcAddr( "vkGetRaytracingShaderHandlesNVX") : instance.getProcAddr( "vkGetRaytracingShaderHandlesNVX")); + vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(device ? device.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV") : instance.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV")); vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(device ? device.getProcAddr( "vkGetRefreshCycleDurationGOOGLE") : instance.getProcAddr( "vkGetRefreshCycleDurationGOOGLE")); vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(device ? device.getProcAddr( "vkGetRenderAreaGranularity") : instance.getProcAddr( "vkGetRenderAreaGranularity")); vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(device ? device.getProcAddr( "vkGetSemaphoreFdKHR") : instance.getProcAddr( "vkGetSemaphoreFdKHR")); diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index ac9bb66..4cd8ed5 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -43,13 +43,12 @@ extern "C" { #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 90 +#define VK_HEADER_VERSION 91 #define VK_NULL_HANDLE 0 - #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -62,7 +61,6 @@ extern "C" { #endif - typedef uint32_t VkFlags; typedef uint32_t VkBool32; typedef uint64_t VkDeviceSize; @@ -287,7 +285,6 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, @@ -419,17 +416,17 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, - VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX = 1000165000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX = 1000165001, - VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX = 1000165002, - VK_STRUCTURE_TYPE_GEOMETRY_NVX = 1000165003, - VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX = 1000165004, - VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX = 1000165005, - VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX = 1000165006, - VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX = 1000165007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX = 1000165008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX = 1000165009, - VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX = 1000165010, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, @@ -440,6 +437,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000, VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, @@ -848,7 +846,7 @@ typedef enum VkQueryType { VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, VK_QUERY_TYPE_TIMESTAMP = 2, VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, - VK_QUERY_TYPE_COMPACTED_SIZE_NVX = 1000165000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), @@ -1178,7 +1176,7 @@ typedef enum VkDescriptorType { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX = 1000165000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), @@ -1207,7 +1205,7 @@ typedef enum VkAttachmentStoreOp { typedef enum VkPipelineBindPoint { VK_PIPELINE_BIND_POINT_GRAPHICS = 0, VK_PIPELINE_BIND_POINT_COMPUTE = 1, - VK_PIPELINE_BIND_POINT_RAYTRACING_NVX = 1000165000, + VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = 1000165000, VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), @@ -1226,6 +1224,7 @@ typedef enum VkCommandBufferLevel { typedef enum VkIndexType { VK_INDEX_TYPE_UINT16 = 0, VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_NONE_NV = 1000165000, VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), @@ -1279,7 +1278,7 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX = 1000165000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, @@ -1447,7 +1446,8 @@ typedef enum VkPipelineStageFlagBits { VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000, - VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX = 0x00200000, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 0x00200000, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -1544,7 +1544,7 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, - VK_BUFFER_USAGE_RAYTRACING_BIT_NVX = 0x00000400, + VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400, VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkBufferUsageFlagBits; typedef VkFlags VkBufferUsageFlags; @@ -1559,7 +1559,7 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, - VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX = 0x00000020, + VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -1576,12 +1576,12 @@ typedef enum VkShaderStageFlagBits { VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, VK_SHADER_STAGE_ALL = 0x7FFFFFFF, - VK_SHADER_STAGE_RAYGEN_BIT_NVX = 0x00000100, - VK_SHADER_STAGE_ANY_HIT_BIT_NVX = 0x00000200, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_NVX = 0x00000400, - VK_SHADER_STAGE_MISS_BIT_NVX = 0x00000800, - VK_SHADER_STAGE_INTERSECTION_BIT_NVX = 0x00001000, - VK_SHADER_STAGE_CALLABLE_BIT_NVX = 0x00002000, + VK_SHADER_STAGE_RAYGEN_BIT_NV = 0x00000100, + VK_SHADER_STAGE_ANY_HIT_BIT_NV = 0x00000200, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = 0x00000400, + VK_SHADER_STAGE_MISS_BIT_NV = 0x00000800, + VK_SHADER_STAGE_INTERSECTION_BIT_NV = 0x00001000, + VK_SHADER_STAGE_CALLABLE_BIT_NV = 0x00002000, VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040, VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080, VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -1673,8 +1673,8 @@ typedef enum VkAccessFlagBits { VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000, - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NVX = 0x00200000, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NVX = 0x00400000, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000, VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkAccessFlagBits; typedef VkFlags VkAccessFlags; @@ -6182,7 +6182,7 @@ typedef enum VkDebugReportObjectTypeEXT { VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT = 1000165000, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, @@ -8113,81 +8113,113 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); #endif -#define VK_NVX_raytracing 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNVX) - -#define VK_NVX_RAYTRACING_SPEC_VERSION 1 -#define VK_NVX_RAYTRACING_EXTENSION_NAME "VK_NVX_raytracing" - - -typedef enum VkGeometryTypeNVX { - VK_GEOMETRY_TYPE_TRIANGLES_NVX = 0, - VK_GEOMETRY_TYPE_AABBS_NVX = 1, - VK_GEOMETRY_TYPE_BEGIN_RANGE_NVX = VK_GEOMETRY_TYPE_TRIANGLES_NVX, - VK_GEOMETRY_TYPE_END_RANGE_NVX = VK_GEOMETRY_TYPE_AABBS_NVX, - VK_GEOMETRY_TYPE_RANGE_SIZE_NVX = (VK_GEOMETRY_TYPE_AABBS_NVX - VK_GEOMETRY_TYPE_TRIANGLES_NVX + 1), - VK_GEOMETRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF -} VkGeometryTypeNVX; - -typedef enum VkAccelerationStructureTypeNVX { - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX = 0, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX = 1, - VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NVX = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX, - VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NVX = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX, - VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NVX = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX + 1), - VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF -} VkAccelerationStructureTypeNVX; - -typedef enum VkCopyAccelerationStructureModeNVX { - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX = 0, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX = 1, - VK_COPY_ACCELERATION_STRUCTURE_MODE_BEGIN_RANGE_NVX = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX, - VK_COPY_ACCELERATION_STRUCTURE_MODE_END_RANGE_NVX = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX, - VK_COPY_ACCELERATION_STRUCTURE_MODE_RANGE_SIZE_NVX = (VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX + 1), - VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_NVX = 0x7FFFFFFF -} VkCopyAccelerationStructureModeNVX; - - -typedef enum VkGeometryFlagBitsNVX { - VK_GEOMETRY_OPAQUE_BIT_NVX = 0x00000001, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX = 0x00000002, - VK_GEOMETRY_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF -} VkGeometryFlagBitsNVX; -typedef VkFlags VkGeometryFlagsNVX; - -typedef enum VkGeometryInstanceFlagBitsNVX { - VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NVX = 0x00000001, - VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_FLIP_WINDING_BIT_NVX = 0x00000002, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NVX = 0x00000004, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NVX = 0x00000008, - VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF -} VkGeometryInstanceFlagBitsNVX; -typedef VkFlags VkGeometryInstanceFlagsNVX; - -typedef enum VkBuildAccelerationStructureFlagBitsNVX { - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NVX = 0x00000001, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NVX = 0x00000002, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NVX = 0x00000004, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NVX = 0x00000008, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NVX = 0x00000010, - VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF -} VkBuildAccelerationStructureFlagBitsNVX; -typedef VkFlags VkBuildAccelerationStructureFlagsNVX; - -typedef struct VkRaytracingPipelineCreateInfoNVX { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const uint32_t* pGroupNumbers; - uint32_t maxRecursionDepth; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkRaytracingPipelineCreateInfoNVX; - -typedef struct VkGeometryTrianglesNVX { +#define VK_NV_ray_tracing 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) + +#define VK_NV_RAY_TRACING_SPEC_VERSION 2 +#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" +#define VK_SHADER_UNUSED_NV (~0U) + + +typedef enum VkRayTracingShaderGroupTypeNV { + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = 2, + VK_RAY_TRACING_SHADER_GROUP_TYPE_BEGIN_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV, + VK_RAY_TRACING_SHADER_GROUP_TYPE_END_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV, + VK_RAY_TRACING_SHADER_GROUP_TYPE_RANGE_SIZE_NV = (VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV + 1), + VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkRayTracingShaderGroupTypeNV; + +typedef enum VkGeometryTypeNV { + VK_GEOMETRY_TYPE_TRIANGLES_NV = 0, + VK_GEOMETRY_TYPE_AABBS_NV = 1, + VK_GEOMETRY_TYPE_BEGIN_RANGE_NV = VK_GEOMETRY_TYPE_TRIANGLES_NV, + VK_GEOMETRY_TYPE_END_RANGE_NV = VK_GEOMETRY_TYPE_AABBS_NV, + VK_GEOMETRY_TYPE_RANGE_SIZE_NV = (VK_GEOMETRY_TYPE_AABBS_NV - VK_GEOMETRY_TYPE_TRIANGLES_NV + 1), + VK_GEOMETRY_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkGeometryTypeNV; + +typedef enum VkAccelerationStructureTypeNV { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1, + VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, + VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV, + VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1), + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureTypeNV; + +typedef enum VkCopyAccelerationStructureModeNV { + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1, + VK_COPY_ACCELERATION_STRUCTURE_MODE_BEGIN_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV, + VK_COPY_ACCELERATION_STRUCTURE_MODE_END_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV, + VK_COPY_ACCELERATION_STRUCTURE_MODE_RANGE_SIZE_NV = (VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV + 1), + VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCopyAccelerationStructureModeNV; + +typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV + 1), + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMemoryRequirementsTypeNV; + + +typedef enum VkGeometryFlagBitsNV { + VK_GEOMETRY_OPAQUE_BIT_NV = 0x00000001, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = 0x00000002, + VK_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkGeometryFlagBitsNV; +typedef VkFlags VkGeometryFlagsNV; + +typedef enum VkGeometryInstanceFlagBitsNV { + VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = 0x00000001, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = 0x00000002, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = 0x00000004, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = 0x00000008, + VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkGeometryInstanceFlagBitsNV; +typedef VkFlags VkGeometryInstanceFlagsNV; + +typedef enum VkBuildAccelerationStructureFlagBitsNV { + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = 0x00000001, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = 0x00000002, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = 0x00000004, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = 0x00000008, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = 0x00000010, + VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkBuildAccelerationStructureFlagBitsNV; +typedef VkFlags VkBuildAccelerationStructureFlagsNV; + +typedef struct VkRayTracingShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeNV type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; +} VkRayTracingShaderGroupCreateInfoNV; + +typedef struct VkRayTracingPipelineCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoNV; + +typedef struct VkGeometryTrianglesNV { VkStructureType sType; const void* pNext; VkBuffer vertexData; @@ -8201,136 +8233,138 @@ typedef struct VkGeometryTrianglesNVX { VkIndexType indexType; VkBuffer transformData; VkDeviceSize transformOffset; -} VkGeometryTrianglesNVX; +} VkGeometryTrianglesNV; -typedef struct VkGeometryAABBNVX { +typedef struct VkGeometryAABBNV { VkStructureType sType; const void* pNext; VkBuffer aabbData; uint32_t numAABBs; uint32_t stride; VkDeviceSize offset; -} VkGeometryAABBNVX; - -typedef struct VkGeometryDataNVX { - VkGeometryTrianglesNVX triangles; - VkGeometryAABBNVX aabbs; -} VkGeometryDataNVX; +} VkGeometryAABBNV; -typedef struct VkGeometryNVX { - VkStructureType sType; - const void* pNext; - VkGeometryTypeNVX geometryType; - VkGeometryDataNVX geometry; - VkGeometryFlagsNVX flags; -} VkGeometryNVX; +typedef struct VkGeometryDataNV { + VkGeometryTrianglesNV triangles; + VkGeometryAABBNV aabbs; +} VkGeometryDataNV; -typedef struct VkAccelerationStructureCreateInfoNVX { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeNVX type; - VkBuildAccelerationStructureFlagsNVX flags; - VkDeviceSize compactedSize; - uint32_t instanceCount; - uint32_t geometryCount; - const VkGeometryNVX* pGeometries; -} VkAccelerationStructureCreateInfoNVX; - -typedef struct VkBindAccelerationStructureMemoryInfoNVX { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureNVX accelerationStructure; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindAccelerationStructureMemoryInfoNVX; - -typedef struct VkDescriptorAccelerationStructureInfoNVX { - VkStructureType sType; - const void* pNext; - uint32_t accelerationStructureCount; - const VkAccelerationStructureNVX* pAccelerationStructures; -} VkDescriptorAccelerationStructureInfoNVX; +typedef struct VkGeometryNV { + VkStructureType sType; + const void* pNext; + VkGeometryTypeNV geometryType; + VkGeometryDataNV geometry; + VkGeometryFlagsNV flags; +} VkGeometryNV; -typedef struct VkAccelerationStructureMemoryRequirementsInfoNVX { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureNVX accelerationStructure; -} VkAccelerationStructureMemoryRequirementsInfoNVX; +typedef struct VkAccelerationStructureInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const VkGeometryNV* pGeometries; +} VkAccelerationStructureInfoNV; + +typedef struct VkAccelerationStructureCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceSize compactedSize; + VkAccelerationStructureInfoNV info; +} VkAccelerationStructureCreateInfoNV; -typedef struct VkPhysicalDeviceRaytracingPropertiesNVX { +typedef struct VkBindAccelerationStructureMemoryInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureNV accelerationStructure; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindAccelerationStructureMemoryInfoNV; + +typedef struct VkWriteDescriptorSetAccelerationStructureNV { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureNV* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureNV; + +typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureMemoryRequirementsTypeNV type; + VkAccelerationStructureNV accelerationStructure; +} VkAccelerationStructureMemoryRequirementsInfoNV; + +typedef struct VkPhysicalDeviceRayTracingPropertiesNV { VkStructureType sType; void* pNext; - uint32_t shaderHeaderSize; + uint32_t shaderGroupHandleSize; uint32_t maxRecursionDepth; - uint32_t maxGeometryCount; -} VkPhysicalDeviceRaytracingPropertiesNVX; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNVX)(VkDevice device, const VkAccelerationStructureCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNVX* pAccelerationStructure); -typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNVX)(VkDevice device, VkAccelerationStructureNVX accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNVX)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureScratchMemoryRequirementsNVX)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); -typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNVX)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNVX)(VkCommandBuffer commandBuffer, VkAccelerationStructureTypeNVX type, uint32_t instanceCount, VkBuffer instanceData, VkDeviceSize instanceOffset, uint32_t geometryCount, const VkGeometryNVX* pGeometries, VkBuildAccelerationStructureFlagsNVX flags, VkBool32 update, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkBuffer scratch, VkDeviceSize scratchOffset); -typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNVX)(VkCommandBuffer commandBuffer, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkCopyAccelerationStructureModeNVX mode); -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNVX)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, uint32_t width, uint32_t height); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRaytracingPipelinesNVX)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRaytracingPipelineCreateInfoNVX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkGetRaytracingShaderHandlesNVX)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNVX)(VkDevice device, VkAccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructurePropertiesNVX)(VkCommandBuffer commandBuffer, VkAccelerationStructureNVX accelerationStructure, VkQueryType queryType, VkQueryPool queryPool, uint32_t query); -typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNVX)(VkDevice device, VkPipeline pipeline, uint32_t shader); + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; +} VkPhysicalDeviceRayTracingPropertiesNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); +typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode); +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); #ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNVX( +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV( VkDevice device, - const VkAccelerationStructureCreateInfoNVX* pCreateInfo, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureNVX* pAccelerationStructure); + VkAccelerationStructureNV* pAccelerationStructure); -VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNVX( +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( VkDevice device, - VkAccelerationStructureNVX accelerationStructure, + VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNVX( - VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureScratchMemoryRequirementsNVX( +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); -VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNVX( +VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos); + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); -VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNVX( +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, - VkAccelerationStructureTypeNVX type, - uint32_t instanceCount, + const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, - uint32_t geometryCount, - const VkGeometryNVX* pGeometries, - VkBuildAccelerationStructureFlagsNVX flags, VkBool32 update, - VkAccelerationStructureNVX dst, - VkAccelerationStructureNVX src, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); -VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNVX( +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, - VkAccelerationStructureNVX dst, - VkAccelerationStructureNVX src, - VkCopyAccelerationStructureModeNVX mode); + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeNV mode); -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNVX( +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, @@ -8340,18 +8374,22 @@ VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNVX( VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, uint32_t width, - uint32_t height); + uint32_t height, + uint32_t depth); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRaytracingPipelinesNVX( +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, - const VkRaytracingPipelineCreateInfoNVX* pCreateInfos, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -VKAPI_ATTR VkResult VKAPI_CALL vkGetRaytracingShaderHandlesNVX( +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, @@ -8359,20 +8397,21 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetRaytracingShaderHandlesNVX( size_t dataSize, void* pData); -VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNVX( +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV( VkDevice device, - VkAccelerationStructureNVX accelerationStructure, + VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); -VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructurePropertiesNVX( +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, - VkAccelerationStructureNVX accelerationStructure, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, - uint32_t query); + uint32_t firstQuery); -VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNVX( +VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader); @@ -8534,6 +8573,29 @@ typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { +#define VK_AMD_memory_overallocation_behavior 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior" + + +typedef enum VkMemoryOverallocationBehaviorAMD { + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_BEGIN_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_END_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_RANGE_SIZE_AMD = (VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD + 1), + VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF +} VkMemoryOverallocationBehaviorAMD; + +typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkMemoryOverallocationBehaviorAMD overallocationBehavior; +} VkDeviceMemoryOverallocationCreateInfoAMD; + + + #define VK_EXT_vertex_attribute_divisor 1 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" diff --git a/registry/genvk.py b/registry/genvk.py index cdbf938..72c6c8f 100644 --- a/registry/genvk.py +++ b/registry/genvk.py @@ -30,11 +30,11 @@ startTime = None def startTimer(timeit): global startTime - startTime = time.clock() + startTime = time.process_time() def endTimer(timeit, msg): global startTime - endTime = time.clock() + endTime = time.process_time() if (timeit): write(msg, endTime - startTime, file=sys.stderr) startTime = None @@ -257,7 +257,6 @@ def makeGenOpts(args): [ 'vulkan_fuchsia.h', [ 'VK_FUCHSIA_imagepipe_surface'], commonSuppressExtensions ], [ 'vulkan_ios.h', [ 'VK_MVK_ios_surface' ], commonSuppressExtensions ], [ 'vulkan_macos.h', [ 'VK_MVK_macos_surface' ], commonSuppressExtensions ], - [ 'vulkan_mir.h', [ 'VK_KHR_mir_surface' ], commonSuppressExtensions ], [ 'vulkan_vi.h', [ 'VK_NN_vi_surface' ], commonSuppressExtensions ], [ 'vulkan_wayland.h', [ 'VK_KHR_wayland_surface' ], commonSuppressExtensions ], [ 'vulkan_win32.h', [ 'VK_.*_win32(|_.*)' ], commonSuppressExtensions + [ 'VK_KHR_external_semaphore', 'VK_KHR_external_memory_capabilities', 'VK_KHR_external_fence', 'VK_KHR_external_fence_capabilities', 'VK_NV_external_memory_capabilities' ] ], diff --git a/registry/validusage.json b/registry/validusage.json index d99804d..34287d4 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.1.90", - "comment": "from git branch: master commit: 894211de5fe395af42ce6f2ce1d97ff70e212380", - "date": "2018-10-29 20:26:11Z" + "api version": "1.1.91", + "comment": "from git branch: master commit: c2ef675dac74b77abdaf4c3de679381f2e3b276c", + "date": "2018-11-05 17:16:43Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -198,7 +198,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRaytracingPropertiesNVX, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" }, { "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", @@ -334,7 +334,7 @@ }, { "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDrawParameterFeatures, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceVariablePointerFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, or VkPhysicalDeviceVulkanMemoryModelFeaturesKHR" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDrawParameterFeatures, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceVariablePointerFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, or VkPhysicalDeviceVulkanMemoryModelFeaturesKHR" }, { "vuid": "VUID-VkDeviceCreateInfo-sType-unique", @@ -408,6 +408,18 @@ } ] }, + "VkDeviceMemoryOverallocationCreateInfoAMD": { + "(VK_AMD_memory_overallocation_behavior)": [ + { + "vuid": "VUID-VkDeviceMemoryOverallocationCreateInfoAMD-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD" + }, + { + "vuid": "VUID-VkDeviceMemoryOverallocationCreateInfoAMD-overallocationBehavior-parameter", + "text": " overallocationBehavior must be a valid VkMemoryOverallocationBehaviorAMD value" + } + ] + }, "vkDestroyDevice": { "core": [ { @@ -2536,7 +2548,7 @@ }, { "vuid": "VUID-vkCmdPipelineBarrier-pDependencies-02285", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with at least one VkSubpassDependency instance in VkRenderPassCreateInfo::pDependencies that expresses a dependency from the current subpass to itself, and for which srcStageMask contains a subset of the bit values in VkSubpassDependency::srcStageMask, dstStageMask contains a subset of the bit values in VkSubpassDependency::dstStageMask, dependencyFlags is equal to VkSubpassDependency::dependencyFlags, srcAccessMask member of each each element of pMemoryBarriers and pImageMemoryBarriers contains a subset of the bit values in VkSubpassDependency::srcAccessMask, and dstAccessMask member of each element of pMemoryBarriers and pImageMemoryBarriers contains a subset of the bit values in VkSubpassDependency::dstAccessMask" + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with at least one VkSubpassDependency instance in VkRenderPassCreateInfo::pDependencies that expresses a dependency from the current subpass to itself, and for which srcStageMask contains a subset of the bit values in VkSubpassDependency::srcStageMask, dstStageMask contains a subset of the bit values in VkSubpassDependency::dstStageMask, dependencyFlags is equal to VkSubpassDependency::dependencyFlags, srcAccessMask member of each element of pMemoryBarriers and pImageMemoryBarriers contains a subset of the bit values in VkSubpassDependency::srcAccessMask, and dstAccessMask member of each element of pMemoryBarriers and pImageMemoryBarriers contains a subset of the bit values in VkSubpassDependency::dstAccessMask" }, { "vuid": "VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178", @@ -5564,6 +5576,16 @@ "vuid": "VUID-vkCmdBindPipeline-None-02323", "text": " This command must not be recorded when transform feedback is active" } + ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-02391", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-02392", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, the pipeline must be a ray tracing pipeline" + } ] }, "vkGetShaderInfoAMD": { @@ -5598,118 +5620,214 @@ } ] }, - "vkCreateRaytracingPipelinesNVX": { - "(VK_NVX_raytracing)": [ + "vkCreateRayTracingPipelinesNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkCreateRaytracingPipelinesNVX-device-parameter", + "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-02402", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" + }, + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-02403", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + }, + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pipelineCache-parameter", + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parameter", "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" }, { - "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pCreateInfos-parameter", - "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkRaytracingPipelineCreateInfoNVX structures" + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkRayTracingPipelineCreateInfoNV structures" }, { - "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pAllocator-parameter", + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pAllocator-parameter", "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" }, { - "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pPipelines-parameter", + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pPipelines-parameter", "text": " pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles" }, { - "vuid": "VUID-vkCreateRaytracingPipelinesNVX-createInfoCount-arraylength", + "vuid": "VUID-vkCreateRayTracingPipelinesNV-createInfoCount-arraylength", "text": " createInfoCount must be greater than 0" }, { - "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pipelineCache-parent", + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parent", "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" } ] }, - "VkRaytracingPipelineCreateInfoNVX": { - "(VK_NVX_raytracing)": [ + "VkRayTracingPipelineCreateInfoNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-02404", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a ray tracing VkPipeline" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-02405", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-02406", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-02407", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-stage-02408", + "text": " The stage member of one element of pStages must be VK_SHADER_STAGE_RAYGEN_BIT_NV" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-pStages-02409", + "text": " The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter" + }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX" + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-layout-02410", + "text": " layout must be consistent with all shaders specified in pStages" }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-pNext-pNext", + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-layout-02411", + "text": " The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-maxRecursionDepth-02412", + "text": " maxRecursionDepth must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxRecursionDepth" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-pNext-pNext", "text": " pNext must be NULL" }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-flags-parameter", + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-parameter", "text": " flags must be a valid combination of VkPipelineCreateFlagBits values" }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-pStages-parameter", + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-pStages-parameter", "text": " pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures" }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-pGroupNumbers-parameter", - "text": " pGroupNumbers must be a valid pointer to an array of stageCount uint32_t values" + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-pGroups-parameter", + "text": " pGroups must be a valid pointer to an array of groupCount valid VkRayTracingShaderGroupCreateInfoNV structures" }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-layout-parameter", + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-layout-parameter", "text": " layout must be a valid VkPipelineLayout handle" }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-stageCount-arraylength", + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-stageCount-arraylength", "text": " stageCount must be greater than 0" }, { - "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-commonparent", + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-groupCount-arraylength", + "text": " groupCount must be greater than 0" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-commonparent", "text": " Both of basePipelineHandle, and layout that are valid handles must have been created, allocated, or retrieved from the same VkDevice" } ] }, - "vkGetRaytracingShaderHandlesNVX": { - "(VK_NVX_raytracing)": [ + "VkRayTracingShaderGroupCreateInfoNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-device-parameter", + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02413", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV then generalShader must be a valid index into pStages referring to a shader of VK_SHADER_STAGE_RAYGEN_BIT_NV, VK_SHADER_STAGE_MISS_BIT_NV, or VK_SHADER_STAGE_CALLABLE_BIT_NV." + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02414", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV then closestHitShader, anyHitShader, and intersectionShader must be VK_SHADER_UNUSED_NV." + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02415", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV then intersectionShader must be a valid index into pStages referring to a shader of VK_SHADER_STAGE_INTERSECTION_BIT_NV." + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02416", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV then intersectionShader must be VK_SHADER_UNUSED_NV." + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-closestHitShader-02417", + "text": " closestHitShader must be either VK_SHADER_UNUSED_NV or a valid index into pStages referring to a shader of VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV." + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-anyHitShader-02418", + "text": " anyHitShader must be either VK_SHADER_UNUSED_NV or a valid index into pStages referring to a shader of VK_SHADER_STAGE_ANY_HIT_BIT_NV." + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-parameter", + "text": " type must be a valid VkRayTracingShaderGroupTypeNV value" + } + ] + }, + "vkGetRayTracingShaderGroupHandlesNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesNV-firstGroup-02419", + "text": " The sum of firstGroup and groupCount must be less than the number of shader groups in pipeline." + }, + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesNV-dataSize-02420", + "text": " dataSize must be at least VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize {times} groupCount" + }, + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-pipeline-parameter", + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesNV-pipeline-parameter", "text": " pipeline must be a valid VkPipeline handle" }, { - "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-pData-parameter", + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesNV-pData-parameter", "text": " pData must be a valid pointer to an array of dataSize bytes" }, { - "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-dataSize-arraylength", + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesNV-dataSize-arraylength", "text": " dataSize must be greater than 0" }, { - "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-pipeline-parent", + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesNV-pipeline-parent", "text": " pipeline must have been created, allocated, or retrieved from device" } ] }, - "vkCompileDeferredNVX": { - "(VK_NVX_raytracing)": [ + "vkCompileDeferredNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkCompileDeferredNVX-pipeline-02237", - "text": " pipeline must have been created with VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX." + "vuid": "VUID-vkCompileDeferredNV-pipeline-02237", + "text": " pipeline must have been created with VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV." }, { - "vuid": "VUID-vkCompileDeferredNVX-shader-02238", + "vuid": "VUID-vkCompileDeferredNV-shader-02238", "text": " shader must not have been called as a deferred compile before." }, { - "vuid": "VUID-vkCompileDeferredNVX-device-parameter", + "vuid": "VUID-vkCompileDeferredNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkCompileDeferredNVX-pipeline-parameter", + "vuid": "VUID-vkCompileDeferredNV-pipeline-parameter", "text": " pipeline must be a valid VkPipeline handle" }, { - "vuid": "VUID-vkCompileDeferredNVX-pipeline-parent", + "vuid": "VUID-vkCompileDeferredNV-pipeline-parent", "text": " pipeline must have been created, allocated, or retrieved from device" } ] @@ -5879,16 +5997,40 @@ ], "(VK_ANDROID_external_memory_android_hardware_buffer)": [ { - "vuid": "VUID-VkMemoryAllocateInfo-None-01873", - "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:" + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-02383", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, allocationSize must be the size returned by vkGetAndroidHardwareBufferPropertiesANDROID for the Android hardware buffer." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02384", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, and the pNext chain does not contain an instance of VkMemoryDedicatedAllocateInfo or VkMemoryDedicatedAllocateInfo::image is VK_NULL_HANDLE, the Android hardware buffer must have a AHardwareBuffer_Desc::format of AHARDWAREBUFFER_FORMAT_BLOB and a AHardwareBuffer_Desc::usage that includes AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-02385", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, memoryTypeIndex must be one of those returned by vkGetAndroidHardwareBufferPropertiesANDROID for the Android hardware buffer." }, { "vuid": "VUID-VkMemoryAllocateInfo-pNext-01874", "text": " If the parameters do not define an import operation, and the pNext chain contains an instance of VkExportMemoryAllocateInfo with VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID included in its handleTypes member, and the pNext contains an instance of VkMemoryDedicatedAllocateInfo with image not equal to VK_NULL_HANDLE, then allocationSize must be 0, otherwise allocationSize must be greater than 0." }, { - "vuid": "VUID-VkMemoryAllocateInfo-pNext-01875", - "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE:" + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02386", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, the Android hardware buffer’s AHardwareBuffer::usage must include at least one of AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT or AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02387", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, the format of image must be VK_FORMAT_UNDEFINED or the format returned by vkGetAndroidHardwareBufferPropertiesANDROID in VkAndroidHardwareBufferFormatPropertiesANDROID::format for the Android hardware buffer." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02388", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, the width, height, and array layer dimensions of image and the Android hardware buffer’s AHardwareBuffer_Desc must be identical." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02389", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, and the Android hardware buffer’s AHardwareBuffer::usage includes AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE, the image must either have a complete mipmap chain, or it must have exactly 1 mip level." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02390", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, each bit set in the usage of image must be listed in AHardwareBuffer Usage Equivalence, and if there is a corresponding AHARDWAREBUFFER_USAGE bit listed that bit must be included in the Android hardware buffer’s AHardwareBuffer_Desc::usage." } ], "core": [ @@ -6362,7 +6504,7 @@ }, { "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881", - "text": " If buffer is not NULL, it must be a valid Android hardware buffer object with format and usage compatible with Vulkan as described by VkExternalMemoryHandleTypeFlagBits." + "text": " If buffer is not NULL, it must be a valid Android hardware buffer object with AHardwareBuffer_Desc::format and AHardwareBuffer_Desc::usage compatible with Vulkan as described in Android Hardware Buffers." }, { "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType", @@ -6406,7 +6548,7 @@ "(VK_ANDROID_external_memory_android_hardware_buffer)": [ { "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884", - "text": " buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags." + "text": " buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* flags in its AHardwareBuffer_Desc::usage" }, { "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter", @@ -7285,12 +7427,28 @@ "text": " If the pNext chain does not contain an instance of VkExternalFormatANDROID, or does and its member externalFormat is 0 the format must not be VK_FORMAT_UNDEFINED." }, { - "vuid": "VUID-VkImageCreateInfo-pNext-01892", - "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:" + "vuid": "VUID-VkImageCreateInfo-pNext-02393", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, imageType must be VK_IMAGE_TYPE_2D." }, { - "vuid": "VUID-VkImageCreateInfo-pNext-01893", - "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0:" + "vuid": "VUID-VkImageCreateInfo-pNext-02394", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, mipLevels must either be 1 or equal to the number of levels in the complete mipmap chain based on extent.width, extent.height, and extent.depth." + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02395", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, and format is VK_FORMAT_UNDEFINED, then the pNext chain must include a VkExternalFormatANDROID structure whose externalFormat member is not 0." + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02396", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, flags must not include VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT." + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02397", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, usage must not include any usages except VK_IMAGE_USAGE_SAMPLED_BIT." + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02398", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, tiling must be VK_IMAGE_TILING_OPTIMAL." } ], "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ @@ -7927,8 +8085,16 @@ ], "(VK_ANDROID_external_memory_android_hardware_buffer)": [ { - "vuid": "VUID-VkImageViewCreateInfo-image-01896", - "text": " If image has an external format:" + "vuid": "VUID-VkImageViewCreateInfo-image-02399", + "text": " If image has an external format, format must be VK_FORMAT_UNDEFINED." + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-02400", + "text": " If image has an external format, the pNext chain must contain an instance of VkSamplerYcbcrConversionInfo with a conversion object created with the same external format as image." + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-02401", + "text": " If image has an external format, all members of components must be VK_COMPONENT_SWIZZLE_IDENTITY." } ] }, @@ -8776,278 +8942,414 @@ } ] }, - "vkCreateAccelerationStructureNVX": { - "(VK_NVX_raytracing)": [ + "vkCreateAccelerationStructureNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkCreateAccelerationStructureNVX-device-parameter", + "vuid": "VUID-vkCreateAccelerationStructureNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkCreateAccelerationStructureNVX-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkAccelerationStructureCreateInfoNVX structure" + "vuid": "VUID-vkCreateAccelerationStructureNV-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkAccelerationStructureCreateInfoNV structure" }, { - "vuid": "VUID-vkCreateAccelerationStructureNVX-pAllocator-parameter", + "vuid": "VUID-vkCreateAccelerationStructureNV-pAllocator-parameter", "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" }, { - "vuid": "VUID-vkCreateAccelerationStructureNVX-pAccelerationStructure-parameter", - "text": " pAccelerationStructure must be a valid pointer to a VkAccelerationStructureNVX handle" + "vuid": "VUID-vkCreateAccelerationStructureNV-pAccelerationStructure-parameter", + "text": " pAccelerationStructure must be a valid pointer to a VkAccelerationStructureNV handle" } ] }, - "VkAccelerationStructureCreateInfoNVX": { - "(VK_NVX_raytracing)": [ + "VkAccelerationStructureCreateInfoNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-geometryCount-02239", - "text": " geometryCount must be less than or equal to VkPhysicalDeviceRaytracingPropertiesNVX::maxGeometryCount" + "vuid": "VUID-VkAccelerationStructureCreateInfoNV-compactedSize-02421", + "text": " If compactedSize is not 0 then both info::geometryCount and info::instanceCount must be 0" }, { - "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX" + "vuid": "VUID-VkAccelerationStructureCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV" }, { - "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-pNext-pNext", + "vuid": "VUID-VkAccelerationStructureCreateInfoNV-pNext-pNext", "text": " pNext must be NULL" }, { - "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-type-parameter", - "text": " type must be a valid VkAccelerationStructureTypeNVX value" + "vuid": "VUID-VkAccelerationStructureCreateInfoNV-info-parameter", + "text": " info must be a valid VkAccelerationStructureInfoNV structure" + } + ] + }, + "VkAccelerationStructureInfoNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkAccelerationStructureInfoNV-geometryCount-02422", + "text": " geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-instanceCount-02423", + "text": " instanceCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxInstanceCount" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424", + "text": " The total number of triangles in all geometries must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxTriangleCount" }, { - "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-flags-parameter", - "text": " flags must be a valid combination of VkBuildAccelerationStructureFlagBitsNVX values" + "vuid": "VUID-VkAccelerationStructureInfoNV-type-02425", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV then geometryCount must be 0." }, { - "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-pGeometries-parameter", - "text": " If geometryCount is not 0, pGeometries must be a valid pointer to an array of geometryCount valid VkGeometryNVX structures" + "vuid": "VUID-VkAccelerationStructureInfoNV-type-02426", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then instanceCount must be 0." + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-compactedSize-02427", + "text": " If compactedSize is not 0 then both geometryCount and instanceCount must be 0" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-type-parameter", + "text": " type must be a valid VkAccelerationStructureTypeNV value" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-flags-parameter", + "text": " flags must be a valid combination of VkBuildAccelerationStructureFlagBitsNV values" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-pGeometries-parameter", + "text": " If geometryCount is not 0, pGeometries must be a valid pointer to an array of geometryCount valid VkGeometryNV structures" } ] }, - "VkGeometryNVX": { - "(VK_NVX_raytracing)": [ + "VkGeometryNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-VkGeometryNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_GEOMETRY_NVX" + "vuid": "VUID-VkGeometryNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_GEOMETRY_NV" }, { - "vuid": "VUID-VkGeometryNVX-pNext-pNext", + "vuid": "VUID-VkGeometryNV-pNext-pNext", "text": " pNext must be NULL" }, { - "vuid": "VUID-VkGeometryNVX-geometryType-parameter", - "text": " geometryType must be a valid VkGeometryTypeNVX value" + "vuid": "VUID-VkGeometryNV-geometryType-parameter", + "text": " geometryType must be a valid VkGeometryTypeNV value" }, { - "vuid": "VUID-VkGeometryNVX-geometry-parameter", - "text": " geometry must be a valid VkGeometryDataNVX structure" + "vuid": "VUID-VkGeometryNV-geometry-parameter", + "text": " geometry must be a valid VkGeometryDataNV structure" }, { - "vuid": "VUID-VkGeometryNVX-flags-parameter", - "text": " flags must be a valid combination of VkGeometryFlagBitsNVX values" + "vuid": "VUID-VkGeometryNV-flags-parameter", + "text": " flags must be a valid combination of VkGeometryFlagBitsNV values" } ] }, - "VkGeometryDataNVX": { - "(VK_NVX_raytracing)": [ + "VkGeometryDataNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-VkGeometryDataNVX-triangles-parameter", - "text": " triangles must be a valid VkGeometryTrianglesNVX structure" + "vuid": "VUID-VkGeometryDataNV-triangles-parameter", + "text": " triangles must be a valid VkGeometryTrianglesNV structure" }, { - "vuid": "VUID-VkGeometryDataNVX-aabbs-parameter", - "text": " aabbs must be a valid VkGeometryAABBNVX structure" + "vuid": "VUID-VkGeometryDataNV-aabbs-parameter", + "text": " aabbs must be a valid VkGeometryAABBNV structure" } ] }, - "VkGeometryTrianglesNVX": { - "(VK_NVX_raytracing)": [ + "VkGeometryTrianglesNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-VkGeometryTrianglesNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX" + "vuid": "VUID-VkGeometryTrianglesNV-vertexOffset-02428", + "text": " vertexOffset must be less than the size of vertexData" }, { - "vuid": "VUID-VkGeometryTrianglesNVX-pNext-pNext", + "vuid": "VUID-VkGeometryTrianglesNV-vertexOffset-02429", + "text": " vertexOffset must be a multiple of the component size of vertexFormat." + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-vertexFormat-02430", + "text": " vertexFormat must be one of VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R16G16B16_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16_SNORM, or VK_FORMAT_R16G16B16_SNORM" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexOffset-02431", + "text": " indexOffset must be less than the size of indexData" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexOffset-02432", + "text": " indexOffset must be a multiple of the element size of indexType" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexType-02433", + "text": " indexType must be VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, or VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexData-02434", + "text": " indexData must be VK_NULL_HANDLE if indexType is VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexData-02435", + "text": " indexData must be a valid handle if indexType is not VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexCount-02436", + "text": " indexCount must be 0 if indexType is VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-transformOffset-02437", + "text": " transformOffset must be less than the size of transformData" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-transformOffset-02438", + "text": " transformOffset must be a multiple of 16" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-pNext-pNext", "text": " pNext must be NULL" }, { - "vuid": "VUID-VkGeometryTrianglesNVX-vertexData-parameter", + "vuid": "VUID-VkGeometryTrianglesNV-vertexData-parameter", "text": " If vertexData is not VK_NULL_HANDLE, vertexData must be a valid VkBuffer handle" }, { - "vuid": "VUID-VkGeometryTrianglesNVX-vertexFormat-parameter", + "vuid": "VUID-VkGeometryTrianglesNV-vertexFormat-parameter", "text": " vertexFormat must be a valid VkFormat value" }, { - "vuid": "VUID-VkGeometryTrianglesNVX-indexData-parameter", + "vuid": "VUID-VkGeometryTrianglesNV-indexData-parameter", "text": " If indexData is not VK_NULL_HANDLE, indexData must be a valid VkBuffer handle" }, { - "vuid": "VUID-VkGeometryTrianglesNVX-indexType-parameter", + "vuid": "VUID-VkGeometryTrianglesNV-indexType-parameter", "text": " indexType must be a valid VkIndexType value" }, { - "vuid": "VUID-VkGeometryTrianglesNVX-transformData-parameter", + "vuid": "VUID-VkGeometryTrianglesNV-transformData-parameter", "text": " If transformData is not VK_NULL_HANDLE, transformData must be a valid VkBuffer handle" }, { - "vuid": "VUID-VkGeometryTrianglesNVX-commonparent", + "vuid": "VUID-VkGeometryTrianglesNV-commonparent", "text": " Each of indexData, transformData, and vertexData that are valid handles must have been created, allocated, or retrieved from the same VkDevice" } ] }, - "VkGeometryAABBNVX": { - "(VK_NVX_raytracing)": [ + "VkGeometryAABBNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkGeometryAABBNV-offset-02439", + "text": " offset must be less than the size of aabbData" + }, + { + "vuid": "VUID-VkGeometryAABBNV-offset-02440", + "text": " offset must be a multiple of 8." + }, { - "vuid": "VUID-VkGeometryAABBNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX" + "vuid": "VUID-VkGeometryAABBNV-stride-02441", + "text": " stride must be a multiple of 8." }, { - "vuid": "VUID-VkGeometryAABBNVX-pNext-pNext", + "vuid": "VUID-VkGeometryAABBNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV" + }, + { + "vuid": "VUID-VkGeometryAABBNV-pNext-pNext", "text": " pNext must be NULL" }, { - "vuid": "VUID-VkGeometryAABBNVX-aabbData-parameter", + "vuid": "VUID-VkGeometryAABBNV-aabbData-parameter", "text": " If aabbData is not VK_NULL_HANDLE, aabbData must be a valid VkBuffer handle" } ] }, - "vkDestroyAccelerationStructureNVX": { - "(VK_NVX_raytracing)": [ + "vkDestroyAccelerationStructureNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-02442", + "text": " All submitted commands that refer to accelerationStructure must have completed execution" + }, + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-02443", + "text": " If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here" + }, { - "vuid": "VUID-vkDestroyAccelerationStructureNVX-device-parameter", + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-02444", + "text": " If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkDestroyAccelerationStructureNVX-accelerationStructure-parameter", - "text": " accelerationStructure must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-parameter", + "text": " accelerationStructure must be a valid VkAccelerationStructureNV handle" }, { - "vuid": "VUID-vkDestroyAccelerationStructureNVX-pAllocator-parameter", + "vuid": "VUID-vkDestroyAccelerationStructureNV-pAllocator-parameter", "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" }, { - "vuid": "VUID-vkDestroyAccelerationStructureNVX-accelerationStructure-parent", + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-parent", "text": " accelerationStructure must have been created, allocated, or retrieved from device" } ] }, - "vkGetAccelerationStructureMemoryRequirementsNVX": { - "(VK_NVX_raytracing)": [ + "vkGetAccelerationStructureMemoryRequirementsNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNVX-device-parameter", + "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNVX-pInfo-parameter", - "text": " pInfo must be a valid pointer to a valid VkAccelerationStructureMemoryRequirementsInfoNVX structure" + "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNV-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkAccelerationStructureMemoryRequirementsInfoNV structure" }, { - "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNVX-pMemoryRequirements-parameter", + "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNV-pMemoryRequirements-parameter", "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2KHR structure" } ] }, - "vkGetAccelerationStructureScratchMemoryRequirementsNVX": { - "(VK_NVX_raytracing)": [ + "VkAccelerationStructureMemoryRequirementsInfoNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkGetAccelerationStructureScratchMemoryRequirementsNVX-device-parameter", - "text": " device must be a valid VkDevice handle" + "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV" }, { - "vuid": "VUID-vkGetAccelerationStructureScratchMemoryRequirementsNVX-pInfo-parameter", - "text": " pInfo must be a valid pointer to a valid VkAccelerationStructureMemoryRequirementsInfoNVX structure" + "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNV-pNext-pNext", + "text": " pNext must be NULL" }, { - "vuid": "VUID-vkGetAccelerationStructureScratchMemoryRequirementsNVX-pMemoryRequirements-parameter", - "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2KHR structure" + "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNV-type-parameter", + "text": " type must be a valid VkAccelerationStructureMemoryRequirementsTypeNV value" + }, + { + "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNV-accelerationStructure-parameter", + "text": " accelerationStructure must be a valid VkAccelerationStructureNV handle" } ] }, - "VkAccelerationStructureMemoryRequirementsInfoNVX": { - "(VK_NVX_raytracing)": [ + "vkBindAccelerationStructureMemoryNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX" + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-accelerationStructure-02445", + "text": " accelerationStructure must not already be backed by a memory object" }, { - "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNVX-pNext-pNext", - "text": " pNext must be NULL" + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-memoryOffset-02446", + "text": " memoryOffset must be less than the size of memory" }, { - "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNVX-accelerationStructure-parameter", - "text": " accelerationStructure must be a valid VkAccelerationStructureNVX handle" - } - ] - }, - "vkBindAccelerationStructureMemoryNVX": { - "(VK_NVX_raytracing)": [ + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-memory-02447", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV" + }, { - "vuid": "VUID-vkBindAccelerationStructureMemoryNVX-device-parameter", + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-memoryOffset-02448", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV" + }, + { + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-size-02449", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV must be less than or equal to the size of memory minus memoryOffset" + }, + { + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkBindAccelerationStructureMemoryNVX-pBindInfos-parameter", - "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindAccelerationStructureMemoryInfoNVX structures" + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-pBindInfos-parameter", + "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindAccelerationStructureMemoryInfoNV structures" }, { - "vuid": "VUID-vkBindAccelerationStructureMemoryNVX-bindInfoCount-arraylength", + "vuid": "VUID-vkBindAccelerationStructureMemoryNV-bindInfoCount-arraylength", "text": " bindInfoCount must be greater than 0" } ] }, - "VkBindAccelerationStructureMemoryInfoNVX": { - "(VK_NVX_raytracing)": [ + "VkBindAccelerationStructureMemoryInfoNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-02450", + "text": " accelerationStructure must not already be backed by a memory object" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-02451", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-memory-02452", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-02453", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-size-02454", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure must be less than or equal to the size of memory minus memoryOffset" + }, { - "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX" + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV" }, { - "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-pNext-pNext", + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-pNext-pNext", "text": " pNext must be NULL" }, { - "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-accelerationStructure-parameter", - "text": " accelerationStructure must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-parameter", + "text": " accelerationStructure must be a valid VkAccelerationStructureNV handle" }, { - "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-memory-parameter", + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-memory-parameter", "text": " memory must be a valid VkDeviceMemory handle" }, { - "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-pDeviceIndices-parameter", + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-pDeviceIndices-parameter", "text": " If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values" }, { - "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-commonparent", + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-commonparent", "text": " Both of accelerationStructure, and memory must have been created, allocated, or retrieved from the same VkDevice" } ] }, - "vkGetAccelerationStructureHandleNVX": { - "(VK_NVX_raytracing)": [ + "vkGetAccelerationStructureHandleNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkGetAccelerationStructureHandleNVX-dataSize-02240", + "vuid": "VUID-vkGetAccelerationStructureHandleNV-dataSize-02240", "text": " dataSize must be large enough to contain the result of the query, as described above" }, { - "vuid": "VUID-vkGetAccelerationStructureHandleNVX-device-parameter", + "vuid": "VUID-vkGetAccelerationStructureHandleNV-device-parameter", "text": " device must be a valid VkDevice handle" }, { - "vuid": "VUID-vkGetAccelerationStructureHandleNVX-accelerationStructure-parameter", - "text": " accelerationStructure must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parameter", + "text": " accelerationStructure must be a valid VkAccelerationStructureNV handle" }, { - "vuid": "VUID-vkGetAccelerationStructureHandleNVX-pData-parameter", + "vuid": "VUID-vkGetAccelerationStructureHandleNV-pData-parameter", "text": " pData must be a valid pointer to an array of dataSize bytes" }, { - "vuid": "VUID-vkGetAccelerationStructureHandleNVX-dataSize-arraylength", + "vuid": "VUID-vkGetAccelerationStructureHandleNV-dataSize-arraylength", "text": " dataSize must be greater than 0" }, { - "vuid": "VUID-vkGetAccelerationStructureHandleNVX-accelerationStructure-parent", + "vuid": "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parent", "text": " accelerationStructure must have been created, allocated, or retrieved from device" } ] @@ -9882,6 +10184,12 @@ "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293", "text": " pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set" } + ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02381", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxDescriptorSetAccelerationStructures" + } ] }, "VkPushConstantRange": { @@ -10360,7 +10668,7 @@ }, { "vuid": "VUID-VkWriteDescriptorSet-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDescriptorAccelerationStructureInfoNVX or VkWriteDescriptorSetInlineUniformBlockEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkWriteDescriptorSetAccelerationStructureNV or VkWriteDescriptorSetInlineUniformBlockEXT" }, { "vuid": "VUID-VkWriteDescriptorSet-sType-unique", @@ -10393,6 +10701,12 @@ "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, the pNext chain must include a VkWriteDescriptorSetInlineUniformBlockEXT structure whose dataSize member equals descriptorCount" } ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02382", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, the pNext chain must include a VkWriteDescriptorSetAccelerationStructureNV structure whose accelerationStructureCount member equals descriptorCount" + } + ], "(VK_EXT_descriptor_indexing)": [ { "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-03048", @@ -10468,6 +10782,26 @@ } ] }, + "VkWriteDescriptorSetAccelerationStructureNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-02236", + "text": " accelerationStructureCount must be equal to descriptorCount in the extended structure." + }, + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV" + }, + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-parameter", + "text": " pAccelerationStructures must be a valid pointer to an array of accelerationStructureCount valid VkAccelerationStructureNV handles" + }, + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-arraylength", + "text": " accelerationStructureCount must be greater than 0" + } + ] + }, "VkCopyDescriptorSet": { "core": [ { @@ -10912,26 +11246,6 @@ } ] }, - "VkDescriptorAccelerationStructureInfoNVX": { - "(VK_NVX_raytracing)": [ - { - "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-accelerationStructureCount-02236", - "text": " accelerationStructureCount must be equal to descriptorCount in the extended structure." - }, - { - "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX" - }, - { - "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-pAccelerationStructures-parameter", - "text": " pAccelerationStructures must be a valid pointer to an array of accelerationStructureCount valid VkAccelerationStructureNVX handles" - }, - { - "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-accelerationStructureCount-arraylength", - "text": " accelerationStructureCount must be greater than 0" - } - ] - }, "vkCreateQueryPool": { "core": [ { @@ -14870,7 +15184,7 @@ }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02305", - "text": " If a VkImageView is sampled with with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + "text": " If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-parameter", @@ -14900,7 +15214,7 @@ "(VK_EXT_transform_feedback)+(VK_IMG_filter_cubic)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02306", - "text": " If a VkImageView is sampled with with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG" + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG" }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02307", @@ -17288,7 +17602,7 @@ }, { "vuid": "VUID-vkCmdDispatch-None-02005", - "text": " If a VkImageView is sampled with with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT." + "text": " If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT." }, { "vuid": "VUID-vkCmdDispatch-commandBuffer-parameter", @@ -17310,7 +17624,7 @@ "(VK_IMG_filter_cubic)": [ { "vuid": "VUID-vkCmdDispatch-None-02006", - "text": " If a VkImageView is sampled with with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG." + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG." }, { "vuid": "VUID-vkCmdDispatch-None-00400", @@ -17394,7 +17708,7 @@ }, { "vuid": "VUID-vkCmdDispatchIndirect-None-02007", - "text": " If a VkImageView is sampled with with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT." + "text": " If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT." }, { "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-parameter", @@ -17424,7 +17738,7 @@ "(VK_IMG_filter_cubic)": [ { "vuid": "VUID-vkCmdDispatchIndirect-None-02008", - "text": " If a VkImageView is sampled with with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG." + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG." }, { "vuid": "VUID-vkCmdDispatchIndirect-None-00416", @@ -18700,50 +19014,6 @@ } ] }, - "vkCreateMirSurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ - { - "vuid": "VUID-vkCreateMirSurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateMirSurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkMirSurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateMirSurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateMirSurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkMirSurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-connection-01263", - "text": " connection must point to a valid MirConnection." - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-surface-01264", - "text": " surface must point to a valid MirSurface." - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, "vkCreateWaylandSurfaceKHR": { "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ { @@ -19560,22 +19830,6 @@ } ] }, - "vkGetPhysicalDeviceMirPresentationSupportKHR": { - "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-queueFamilyIndex-01265", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-connection-parameter", - "text": " connection must be a valid pointer to a MirConnection value" - } - ] - }, "vkGetPhysicalDeviceWaylandPresentationSupportKHR": { "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ { @@ -20644,162 +20898,332 @@ } ] }, - "VkPhysicalDeviceRaytracingPropertiesNVX": { - "(VK_NVX_raytracing)": [ + "vkCmdTraceRaysNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-VkPhysicalDeviceRaytracingPropertiesNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX" - } - ] - }, - "vkCmdTraceRaysNVX": { - "(VK_NVX_raytracing)": [ + "vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02455", + "text": " raygenShaderBindingOffset must be less than the size of raygenShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02456", + "text": " raygenShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment." + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingOffset-02457", + "text": " missShaderBindingOffset must be less than the size of missShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingOffset-02458", + "text": " missShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment." + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingOffset-02459", + "text": " hitShaderBindingOffset must be less than the size of hitShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingOffset-02460", + "text": " hitShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment." + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingOffset-02461", + "text": " callableShaderBindingOffset must be less than the size of callableShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingOffset-02462", + "text": " callableShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment." + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingStride-02463", + "text": " missShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingStride-02464", + "text": " hitShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingStride-02465", + "text": " callableShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingStride-02466", + "text": " missShaderBindingStride must be a less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingStride-02467", + "text": " hitShaderBindingStride must be a less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingStride-02468", + "text": " callableShaderBindingStride must be a less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-width-02469", + "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, { - "vuid": "VUID-vkCmdTraceRaysNVX-commandBuffer-parameter", + "vuid": "VUID-vkCmdTraceRaysNV-height-02470", + "text": " height must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-depth-02471", + "text": " depth must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02472", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02473", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02474", + "text": " A valid ray tracing pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_RAY_TRACING_NV" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02475", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, a push constant value must have been set for VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02476", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02477", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02478", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02479", + "text": " If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02480", + "text": " If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02481", + "text": " If a VkImageView is sampled with with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT." + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" }, { - "vuid": "VUID-vkCmdTraceRaysNVX-raygenShaderBindingTableBuffer-parameter", + "vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-parameter", "text": " raygenShaderBindingTableBuffer must be a valid VkBuffer handle" }, { - "vuid": "VUID-vkCmdTraceRaysNVX-missShaderBindingTableBuffer-parameter", - "text": " missShaderBindingTableBuffer must be a valid VkBuffer handle" + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingTableBuffer-parameter", + "text": " If missShaderBindingTableBuffer is not VK_NULL_HANDLE, missShaderBindingTableBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingTableBuffer-parameter", + "text": " If hitShaderBindingTableBuffer is not VK_NULL_HANDLE, hitShaderBindingTableBuffer must be a valid VkBuffer handle" }, { - "vuid": "VUID-vkCmdTraceRaysNVX-hitShaderBindingTableBuffer-parameter", - "text": " hitShaderBindingTableBuffer must be a valid VkBuffer handle" + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingTableBuffer-parameter", + "text": " If callableShaderBindingTableBuffer is not VK_NULL_HANDLE, callableShaderBindingTableBuffer must be a valid VkBuffer handle" }, { - "vuid": "VUID-vkCmdTraceRaysNVX-commandBuffer-recording", + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-recording", "text": " commandBuffer must be in the recording state" }, { - "vuid": "VUID-vkCmdTraceRaysNVX-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-commonparent", + "text": " Each of callableShaderBindingTableBuffer, commandBuffer, hitShaderBindingTableBuffer, missShaderBindingTableBuffer, and raygenShaderBindingTableBuffer that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_NV_ray_tracing)+(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02482", + "text": " If a VkImageView is sampled with with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG." }, { - "vuid": "VUID-vkCmdTraceRaysNVX-commonparent", - "text": " Each of commandBuffer, hitShaderBindingTableBuffer, missShaderBindingTableBuffer, and raygenShaderBindingTableBuffer must have been created, allocated, or retrieved from the same VkDevice" + "vuid": "VUID-vkCmdTraceRaysNV-None-02483", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_ray_tracing)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02484", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02485", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02486", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the ray tracing pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_RAY_TRACING_NV reads from any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_NV_ray_tracing)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-flags-02487", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE." } ] }, - "vkCmdBuildAccelerationStructureNVX": { - "(VK_NVX_raytracing)": [ + "vkCmdBuildAccelerationStructureNV": { + "(VK_NV_ray_tracing)": [ { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-geometryCount-02241", - "text": " geometryCount must be less than or equal to VkPhysicalDeviceRaytracingPropertiesNVX::maxGeometryCount" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-geometryCount-02241", + "text": " geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-dst-02488", + "text": " dst must have been created with compatible VkAccelerationStructureInfoNV where VkAccelerationStructureInfoNV:::type and VkAccelerationStructureInfoNV::flags are identical, VkAccelerationStructureInfoNV::instanceCount and VkAccelerationStructureInfoNV::geometryCount for dst are greater than or equal to the build size and each geometry in VkAccelerationStructureInfoNV::pGeometries for dst has greater than or equal to the number of vertices, indices, and AABBs." }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-type-parameter", - "text": " type must be a valid VkAccelerationStructureTypeNVX value" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02489", + "text": " If update is true, src must not be VK_NULL_HANDLE" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-instanceData-parameter", - "text": " If instanceData is not VK_NULL_HANDLE, instanceData must be a valid VkBuffer handle" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02490", + "text": " If update is true, src must have been built last with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV set in VkAccelerationStructureInfoNV::flags" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02491", + "text": " If update is false, The size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with VkAccelerationStructureMemoryRequirementsInfoNV::accelerationStructure set to dst and VkAccelerationStructureMemoryRequirementsInfoNV::type set to VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV must be less than or equal to the size of scratch minus scratchOffset" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-pGeometries-parameter", - "text": " If geometryCount is not 0, pGeometries must be a valid pointer to an array of geometryCount valid VkGeometryNVX structures" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02492", + "text": " If update is true, The size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with VkAccelerationStructureMemoryRequirementsInfoNV::accelerationStructure set to dst and VkAccelerationStructureMemoryRequirementsInfoNV::type set to VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV must be less than or equal to the size of scratch minus scratchOffset" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-flags-parameter", - "text": " flags must be a valid combination of VkBuildAccelerationStructureFlagBitsNVX values" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-dst-parameter", - "text": " dst must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkAccelerationStructureInfoNV structure" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-src-parameter", - "text": " If src is not VK_NULL_HANDLE, src must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-instanceData-parameter", + "text": " If instanceData is not VK_NULL_HANDLE, instanceData must be a valid VkBuffer handle" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-scratch-parameter", + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-dst-parameter", + "text": " dst must be a valid VkAccelerationStructureNV handle" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-src-parameter", + "text": " If src is not VK_NULL_HANDLE, src must be a valid VkAccelerationStructureNV handle" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-scratch-parameter", "text": " scratch must be a valid VkBuffer handle" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-commandBuffer-recording", + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-recording", "text": " commandBuffer must be in the recording state" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" }, { - "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-commonparent", + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-commonparent", "text": " Each of commandBuffer, dst, instanceData, scratch, and src that are valid handles must have been created, allocated, or retrieved from the same VkDevice" } ] }, - "vkCmdWriteAccelerationStructurePropertiesNVX": { - "(VK_NVX_raytracing)": [ + "vkCmdWriteAccelerationStructuresPropertiesNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-02242", + "text": " queryType must be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV" + }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-queryType-02242", - "text": " queryType must be VK_QUERY_TYPE_COMPACTED_SIZE_NVX" + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-02493", + "text": " queryPool must have been created with a queryType matching queryType" }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-commandBuffer-parameter", + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-02494", + "text": " The queries identified by queryPool and firstQuery must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructures-02495", + "text": " All acceleration structures in accelerationStructures must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV if queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-accelerationStructure-parameter", - "text": " accelerationStructure must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-pAccelerationStructures-parameter", + "text": " pAccelerationStructures must be a valid pointer to an array of accelerationStructureCount valid VkAccelerationStructureNV handles" }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-queryType-parameter", + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-parameter", "text": " queryType must be a valid VkQueryType value" }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-queryPool-parameter", + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-parameter", "text": " queryPool must be a valid VkQueryPool handle" }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-commandBuffer-recording", + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commandBuffer-recording", "text": " commandBuffer must be in the recording state" }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructureCount-arraylength", + "text": " accelerationStructureCount must be greater than 0" }, { - "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-commonparent", - "text": " Each of accelerationStructure, commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commonparent", + "text": " Each of commandBuffer, queryPool, and the elements of pAccelerationStructures must have been created, allocated, or retrieved from the same VkDevice" } ] }, - "vkCmdCopyAccelerationStructureNVX": { - "(VK_NVX_raytracing)": [ + "vkCmdCopyAccelerationStructureNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-mode-02496", + "text": " mode must be VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV or VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV" + }, { - "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-commandBuffer-parameter", + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-src-02497", + "text": " src must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV if mode is VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" }, { - "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-dst-parameter", - "text": " dst must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-dst-parameter", + "text": " dst must be a valid VkAccelerationStructureNV handle" }, { - "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-src-parameter", - "text": " src must be a valid VkAccelerationStructureNVX handle" + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-src-parameter", + "text": " src must be a valid VkAccelerationStructureNV handle" }, { - "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-mode-parameter", - "text": " mode must be a valid VkCopyAccelerationStructureModeNVX value" + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-mode-parameter", + "text": " mode must be a valid VkCopyAccelerationStructureModeNV value" }, { - "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-commandBuffer-recording", + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-recording", "text": " commandBuffer must be in the recording state" }, { - "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" }, { - "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-commonparent", + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-commonparent", "text": " Each of commandBuffer, dst, and src must have been created, allocated, or retrieved from the same VkDevice" } ] @@ -21264,6 +21688,14 @@ } ] }, + "VkPhysicalDeviceRayTracingPropertiesNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkPhysicalDeviceRayTracingPropertiesNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV" + } + ] + }, "vkGetPhysicalDeviceMultisamplePropertiesEXT": { "(VK_EXT_sample_locations)": [ { diff --git a/registry/vk.xml b/registry/vk.xml index 863c33f..24cc3ce 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -49,7 +49,6 @@ server. - @@ -96,7 +95,6 @@ server. - @@ -122,8 +120,6 @@ server. - - @@ -150,7 +146,7 @@ server. // Vulkan 1.1 version number #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 90 +#define VK_HEADER_VERSION 91 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -162,12 +158,10 @@ server. #else #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; #endif -#endif - +#endif -#define VK_NULL_HANDLE 0 - +#define VK_NULL_HANDLE 0 struct ANativeWindow; struct AHardwareBuffer; @@ -251,9 +245,9 @@ server. typedef VkFlags VkSubgroupFeatureFlags; typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; typedef VkFlags VkObjectEntryUsageFlagsNVX; - typedef VkFlags VkGeometryFlagsNVX; - typedef VkFlags VkGeometryInstanceFlagsNVX; - typedef VkFlags VkBuildAccelerationStructureFlagsNVX; + typedef VkFlags VkGeometryFlagsNV; + typedef VkFlags VkGeometryInstanceFlagsNV; + typedef VkFlags VkBuildAccelerationStructureFlagsNV; typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; @@ -266,7 +260,6 @@ server. typedef VkFlags VkDisplayModeCreateFlagsKHR; typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; - typedef VkFlags VkMirSurfaceCreateFlagsKHR; typedef VkFlags VkViSurfaceCreateFlagsNN; typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; typedef VkFlags VkWin32SurfaceCreateFlagsKHR; @@ -351,7 +344,7 @@ server. VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) WSI extensions VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) @@ -470,12 +463,15 @@ server. - - - - - - + + + + + + + + + WSI extensions @@ -1644,13 +1640,6 @@ server. VkAndroidSurfaceCreateFlagsKHR flags struct ANativeWindow* window - - VkStructureType sType - const void* pNext - VkMirSurfaceCreateFlagsKHR flags - MirConnection* connection - MirSurface* mirSurface - VkStructureType sType const void* pNext @@ -3455,88 +3444,109 @@ server. uint32_t taskCount uint32_t firstTask - - VkStructureType sType + + VkStructureType sType + const void* pNext + VkRayTracingShaderGroupTypeNV type + uint32_t generalShader + uint32_t closestHitShader + uint32_t anyHitShader + uint32_t intersectionShader + + + VkStructureType sType const void* pNext VkPipelineCreateFlags flagsPipeline creation flags uint32_t stageCount const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage - const uint32_t* pGroupNumbersOne entry for each stage used as the query index and for grouping + uint32_t groupCount + const VkRayTracingShaderGroupCreateInfoNV* pGroups uint32_t maxRecursionDepth VkPipelineLayout layoutInterface layout of the pipeline VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of - - VkStructureType sType + + VkStructureType sType const void* pNext VkBuffer vertexData VkDeviceSize vertexOffset uint32_t vertexCount VkDeviceSize vertexStride - VkFormat vertexFormatVK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R16G16B16_SFLOAT, or VK_FORMAT_R16G16B16A16_SFLOAT + VkFormat vertexFormat VkBuffer indexData VkDeviceSize indexOffset uint32_t indexCount - VkIndexType indexType + VkIndexType indexType VkBuffer transformDataOptional reference to array of floats representing a 3x4 row major affine transformation matrix. VkDeviceSize transformOffset - - VkStructureType sType + + VkStructureType sType const void* pNext VkBuffer aabbData uint32_t numAABBs uint32_t strideStride in bytes between AABBs VkDeviceSize offsetOffset in bytes of the first AABB in aabbData - - VkGeometryTrianglesNVX triangles - VkGeometryAABBNVX aabbs + + VkGeometryTrianglesNV triangles + VkGeometryAABBNV aabbs - - VkStructureType sType + + VkStructureType sType const void* pNext - VkGeometryTypeNVX geometryType - VkGeometryDataNVX geometry - VkGeometryFlagsNVX flags + VkGeometryTypeNV geometryType + VkGeometryDataNV geometry + VkGeometryFlagsNV flags - - VkStructureType sType + + VkStructureType sType const void* pNext - VkAccelerationStructureTypeNVX type - VkBuildAccelerationStructureFlagsNVXflags - VkDeviceSize compactedSize + VkAccelerationStructureTypeNV type + VkBuildAccelerationStructureFlagsNVflags uint32_t instanceCount uint32_t geometryCount - const VkGeometryNVX* pGeometries + const VkGeometryNV* pGeometries + + + VkStructureType sType + const void* pNext + VkDeviceSize compactedSize + VkAccelerationStructureInfoNV info - - VkStructureType sType + + VkStructureType sType const void* pNext - VkAccelerationStructureNVX accelerationStructure + VkAccelerationStructureNV accelerationStructure VkDeviceMemory memory VkDeviceSize memoryOffset uint32_t deviceIndexCount const uint32_t* pDeviceIndices - - VkStructureType sType + + VkStructureType sType const void* pNext uint32_t accelerationStructureCount - const VkAccelerationStructureNVX* pAccelerationStructures + const VkAccelerationStructureNV* pAccelerationStructures - - VkStructureType sType + + VkStructureType sType const void* pNext - VkAccelerationStructureNVX accelerationStructure + VkAccelerationStructureMemoryRequirementsTypeNV type + VkAccelerationStructureNV accelerationStructure - - VkStructureType sType + + VkStructureType sType void* pNext - uint32_t shaderHeaderSize + uint32_t shaderGroupHandleSize uint32_t maxRecursionDepth - uint32_t maxGeometryCount + uint32_t maxShaderGroupStride + uint32_t shaderGroupBaseAlignment + uint64_t maxGeometryCount + uint64_t maxInstanceCount + uint64_t maxTriangleCount + uint32_t maxDescriptorSetAccelerationStructures VkStructureType sType @@ -3575,6 +3585,11 @@ server. void* pNext uint64_t drmFormatModifier + + VkStructureType sType + const void* pNext + VkMemoryOverallocationBehaviorAMD overallocationBehavior + Vulkan enumerant (token) definitions @@ -3604,6 +3619,7 @@ server. + @@ -4706,36 +4722,50 @@ server. - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - VkResult vkCreateInstance @@ -5759,19 +5789,6 @@ server. const VkAllocationCallbacks* pAllocator VkSwapchainKHR* pSwapchains - - VkResult vkCreateMirSurfaceKHR - VkInstance instance - const VkMirSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - MirConnection* connection - void vkDestroySurfaceKHR VkInstance instance @@ -6825,89 +6842,84 @@ server. uint32_t stride - VkResult vkCompileDeferredNVX + VkResult vkCompileDeferredNV VkDevice device VkPipeline pipeline uint32_t shader - VkResult vkCreateAccelerationStructureNVX + VkResult vkCreateAccelerationStructureNV VkDevice device - const VkAccelerationStructureCreateInfoNVX* pCreateInfo + const VkAccelerationStructureCreateInfoNV* pCreateInfo const VkAllocationCallbacks* pAllocator - VkAccelerationStructureNVX* pAccelerationStructure + VkAccelerationStructureNV* pAccelerationStructure - void vkDestroyAccelerationStructureNVX + void vkDestroyAccelerationStructureNV VkDevice device - VkAccelerationStructureNVX accelerationStructure + VkAccelerationStructureNV accelerationStructure const VkAllocationCallbacks* pAllocator - void vkGetAccelerationStructureMemoryRequirementsNVX - VkDevice device - const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo - VkMemoryRequirements2KHR* pMemoryRequirements - - - void vkGetAccelerationStructureScratchMemoryRequirementsNVX + void vkGetAccelerationStructureMemoryRequirementsNV VkDevice device - const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo VkMemoryRequirements2KHR* pMemoryRequirements - VkResult vkBindAccelerationStructureMemoryNVX + VkResult vkBindAccelerationStructureMemoryNV VkDevice device uint32_t bindInfoCount - const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos - - void vkCmdCopyAccelerationStructureNVX + + void vkCmdCopyAccelerationStructureNV VkCommandBuffer commandBuffer - VkAccelerationStructureNVX dst - VkAccelerationStructureNVX src - VkCopyAccelerationStructureModeNVX mode + VkAccelerationStructureNV dst + VkAccelerationStructureNV src + VkCopyAccelerationStructureModeNV mode - - void vkCmdWriteAccelerationStructurePropertiesNVX + + void vkCmdWriteAccelerationStructuresPropertiesNV VkCommandBuffer commandBuffer - VkAccelerationStructureNVX accelerationStructure + uint32_t accelerationStructureCount + const VkAccelerationStructureNV* pAccelerationStructures VkQueryType queryType VkQueryPool queryPool - uint32_t query + uint32_t firstQuery - - void vkCmdBuildAccelerationStructureNVX + + void vkCmdBuildAccelerationStructureNV VkCommandBuffer commandBuffer - VkAccelerationStructureTypeNVX type - uint32_t instanceCount + const VkAccelerationStructureInfoNV* pInfo VkBuffer instanceData VkDeviceSize instanceOffset - uint32_t geometryCount - const VkGeometryNVX* pGeometries - VkBuildAccelerationStructureFlagsNVX flags VkBool32 update - VkAccelerationStructureNVX dst - VkAccelerationStructureNVX src + VkAccelerationStructureNV dst + VkAccelerationStructureNV src VkBuffer scratch VkDeviceSize scratchOffset - - void vkCmdTraceRaysNVX + + void vkCmdTraceRaysNV VkCommandBuffer commandBuffer VkBuffer raygenShaderBindingTableBuffer VkDeviceSize raygenShaderBindingOffset - VkBuffer missShaderBindingTableBuffer + VkBuffer missShaderBindingTableBuffer VkDeviceSize missShaderBindingOffset VkDeviceSize missShaderBindingStride - VkBuffer hitShaderBindingTableBuffer + VkBuffer hitShaderBindingTableBuffer VkDeviceSize hitShaderBindingOffset VkDeviceSize hitShaderBindingStride + VkBuffer callableShaderBindingTableBuffer + VkDeviceSize callableShaderBindingOffset + VkDeviceSize callableShaderBindingStride uint32_t width uint32_t height + uint32_t depth - VkResult vkGetRaytracingShaderHandlesNVX + VkResult vkGetRayTracingShaderGroupHandlesNV VkDevice device VkPipeline pipeline uint32_t firstGroup @@ -6916,18 +6928,18 @@ server. void* pData - VkResult vkGetAccelerationStructureHandleNVX + VkResult vkGetAccelerationStructureHandleNV VkDevice device - VkAccelerationStructureNVX accelerationStructure + VkAccelerationStructureNV accelerationStructure size_t dataSize void* pData - VkResult vkCreateRaytracingPipelinesNVX + VkResult vkCreateRayTracingPipelinesNV VkDevice device VkPipelineCache pipelineCache uint32_t createInfoCount - const VkRaytracingPipelineCreateInfoNVX* pCreateInfos + const VkRayTracingPipelineCreateInfoNV* pCreateInfos const VkAllocationCallbacks* pAllocator VkPipeline* pPipelines @@ -7619,15 +7631,11 @@ server. - + + - - - - - @@ -9470,70 +9478,76 @@ server. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + @@ -9712,10 +9726,13 @@ server. - + - - + + + + + @@ -10100,5 +10117,11 @@ server. + + + + + + -- 2.7.4