From: Mike Schuchardt <mikes@lunarg.com>
Date: Thu, 20 Sep 2018 17:20:51 +0000 (-0700)
Subject: headers: Update to version 1.1.85
X-Git-Tag: upstream/1.1.92~8
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2fd5a24ec4a6df303b2155b3f85b6b8c1d56f6c0;p=platform%2Fupstream%2FVulkan-Headers.git

headers: Update to version 1.1.85

Updated:
- include/vulkan/vulkan.hpp
- include/vulkan/vulkan_core.h
- registry/validusage.json
- registry/vk.xml

Note: vulkan.hpp required some hand editing in
Device::getAccelerationStructureHandleNVX and
Device::getRaytracingShaderHandlesNVX in order to compile.
---

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index ad18221..a7a1003 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -70,7 +70,7 @@
   #undef MemoryBarrier
 #endif
 
-static_assert( VK_HEADER_VERSION ==  84 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION ==  85 , "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
@@ -479,8 +479,34 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 
+
   template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; };
 
+  template <typename P, typename T>
+  struct TypeList
+  {
+    using list = P;
+    using last = T;
+  };
+
+  template <typename List, typename X>
+  struct extendCheck
+  {
+    static const bool valid = isStructureChainValid<typename List::last, X>::value || extendCheck<typename List::list,X>::valid;
+  };
+
+  template <typename T, typename X>
+  struct extendCheck<TypeList<void,T>,X>
+  {
+    static const bool valid = isStructureChainValid<T, X>::value;
+  };
+
+  template <typename X>
+  struct extendCheck<void,X>
+  {
+    static const bool valid = true;
+  };
+
   template <class Element>
   class StructureChainElement
   {
@@ -497,75 +523,78 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     StructureChain()
     {
-      link<StructureElements...>();  
+      link<void, StructureElements...>();  
     }
 
     StructureChain(StructureChain const &rhs)
     {
-      linkAndCopy<StructureElements...>(rhs);
+      linkAndCopy<void, StructureElements...>(rhs);
     }
 
     StructureChain(StructureElements const &... elems)
     {
-      linkAndCopyElements<StructureElements...>(elems...);
+      linkAndCopyElements<void, StructureElements...>(elems...);
     }
 
     StructureChain& operator=(StructureChain const &rhs)
     {
-      linkAndCopy<StructureElements...>(rhs);
+      linkAndCopy<void, StructureElements...>(rhs);
       return *this;
     }
 
     template<typename ClassType> ClassType& get() { return static_cast<ClassType&>(*this);}
 
   private:
-    template<typename X>
+    template<typename List, typename X>
     void link()
     {
+      static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
     }
 
-    template<typename X, typename Y, typename ...Z>
+    template<typename List, typename X, typename Y, typename ...Z>
     void link()
     {
-      static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
+      static_assert(extendCheck<List,X>::valid, "The structure chain is not valid!");
       X& x = static_cast<X&>(*this);
       Y& y = static_cast<Y&>(*this);
       x.pNext = &y;
-      link<Y, Z...>();
+      link<TypeList<List, X>, Y, Z...>();
     }
 
-    template<typename X>
+    template<typename List, typename X>
     void linkAndCopy(StructureChain const &rhs)
     {
+      static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
       static_cast<X&>(*this) = static_cast<X const &>(rhs);
     }
 
-    template<typename X, typename Y, typename ...Z>
+    template<typename List, typename X, typename Y, typename ...Z>
     void linkAndCopy(StructureChain const &rhs)
     {
-      static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
+      static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
       X& x = static_cast<X&>(*this);
       Y& y = static_cast<Y&>(*this);
       x = static_cast<X const &>(rhs);
       x.pNext = &y;
-      linkAndCopy<Y, Z...>(rhs);
+      linkAndCopy<TypeList<List, X>, Y, Z...>(rhs);
     }
 
-    template<typename X>
+    template<typename List, typename X>
     void linkAndCopyElements(X const &xelem)
     {
+      static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
       static_cast<X&>(*this) = xelem;
     }
 
-    template<typename X, typename Y, typename ...Z>
+    template<typename List, typename X, typename Y, typename ...Z>
     void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem)
     {
-      static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
+      static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
       X& x = static_cast<X&>(*this);
       Y& y = static_cast<Y&>(*this);
       x = xelem;
       x.pNext = &y;
-      linkAndCopyElements<Y, Z...>(yelem, zelem...);
+      linkAndCopyElements<TypeList<List, X>, Y, Z...>(yelem, zelem...);
     }
   };
 
@@ -1084,6 +1113,10 @@ public:
   {
     return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo);
   }
+  VkResult vkBindAccelerationStructureMemoryNVX( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos  ) const
+  {
+    return ::vkBindAccelerationStructureMemoryNVX( device, bindInfoCount, pBindInfos);
+  }
   VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset  ) const
   {
     return ::vkBindBufferMemory( device, buffer, memory, memoryOffset);
@@ -1140,6 +1173,10 @@ public:
   {
     return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline);
   }
+  void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout  ) const
+  {
+    return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout);
+  }
   void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets  ) const
   {
     return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
@@ -1148,6 +1185,10 @@ public:
   {
     return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
   }
+  void vkCmdBuildAccelerationStructureNVX( VkCommandBuffer cmdBuf, 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
+  {
+    return ::vkCmdBuildAccelerationStructureNVX( cmdBuf, type, instanceCount, instanceData, instanceOffset, geometryCount, pGeometries, flags, update, dst, src, scratch, scratchOffset);
+  }
   void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects  ) const
   {
     return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
@@ -1160,6 +1201,10 @@ public:
   {
     return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
   }
+  void vkCmdCopyAccelerationStructureNVX( VkCommandBuffer cmdBuf, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkCopyAccelerationStructureModeNVX mode  ) const
+  {
+    return ::vkCmdCopyAccelerationStructureNVX( cmdBuf, dst, src, mode);
+  }
   void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions  ) const
   {
     return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
@@ -1240,6 +1285,18 @@ public:
   {
     return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
   }
+  void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
+  {
+    return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+  }
+  void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride  ) const
+  {
+    return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride);
+  }
+  void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask  ) const
+  {
+    return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask);
+  }
   void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer  ) const
   {
     return ::vkCmdEndConditionalRenderingEXT( commandBuffer);
@@ -1324,6 +1381,10 @@ public:
   {
     return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker);
   }
+  void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders  ) const
+  {
+    return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
+  }
   void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor  ) const
   {
     return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
@@ -1348,6 +1409,10 @@ public:
   {
     return ::vkCmdSetEvent( commandBuffer, event, stageMask);
   }
+  void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors  ) const
+  {
+    return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
+  }
   void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth  ) const
   {
     return ::vkCmdSetLineWidth( commandBuffer, lineWidth);
@@ -1376,10 +1441,18 @@ public:
   {
     return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports);
   }
+  void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes  ) const
+  {
+    return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
+  }
   void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings  ) const
   {
     return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings);
   }
+  void vkCmdTraceRaysNVX( VkCommandBuffer cmdBuf, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, uint32_t width, uint32_t height  ) const
+  {
+    return ::vkCmdTraceRaysNVX( cmdBuf, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, width, height);
+  }
   void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData  ) const
   {
     return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData);
@@ -1388,6 +1461,10 @@ public:
   {
     return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
   }
+  void vkCmdWriteAccelerationStructurePropertiesNVX( VkCommandBuffer cmdBuf, VkAccelerationStructureNVX accelerationStructure, VkQueryType queryType, VkQueryPool queryPool, uint32_t query  ) const
+  {
+    return ::vkCmdWriteAccelerationStructurePropertiesNVX( cmdBuf, accelerationStructure, queryType, queryPool, query);
+  }
   void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker  ) const
   {
     return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
@@ -1396,6 +1473,14 @@ public:
   {
     return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query);
   }
+  VkResult vkCompileDeferredNVX( VkDevice device, VkPipeline pipeline, uint32_t shader  ) const
+  {
+    return ::vkCompileDeferredNVX( device, pipeline, shader);
+  }
+  VkResult vkCreateAccelerationStructureNVX( VkDevice device, const VkAccelerationStructureCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNVX* pAccelerationStructure  ) const
+  {
+    return ::vkCreateAccelerationStructureNVX( device, pCreateInfo, pAllocator, pAccelerationStructure);
+  }
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
   {
@@ -1520,6 +1605,10 @@ 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
+  {
+    return ::vkCreateRaytracingPipelinesNVX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+  }
   VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass  ) const
   {
     return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass);
@@ -1602,6 +1691,10 @@ public:
   {
     return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
   }
+  void vkDestroyAccelerationStructureNVX( VkDevice device, VkAccelerationStructureNVX accelerationStructure, const VkAllocationCallbacks* pAllocator  ) const
+  {
+    return ::vkDestroyAccelerationStructureNVX( device, accelerationStructure, pAllocator);
+  }
   void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator  ) const
   {
     return ::vkDestroyBuffer( device, buffer, pAllocator);
@@ -1786,6 +1879,18 @@ public:
   {
     return ::vkFreeMemory( device, memory, pAllocator);
   }
+  VkResult vkGetAccelerationStructureHandleNVX( VkDevice device, VkAccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData  ) const
+  {
+    return ::vkGetAccelerationStructureHandleNVX( device, accelerationStructure, dataSize, pData);
+  }
+  void vkGetAccelerationStructureMemoryRequirementsNVX( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements  ) const
+  {
+    return ::vkGetAccelerationStructureMemoryRequirementsNVX( device, pInfo, pMemoryRequirements);
+  }
+  void vkGetAccelerationStructureScratchMemoryRequirementsNVX( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements  ) const
+  {
+    return ::vkGetAccelerationStructureScratchMemoryRequirementsNVX( device, pInfo, pMemoryRequirements);
+  }
 #ifdef VK_USE_PLATFORM_ANDROID_ANDROID
   VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties  ) const
   {
@@ -2170,6 +2275,10 @@ 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
+  {
+    return ::vkGetRaytracingShaderHandlesNVX( device, pipeline, firstGroup, groupCount, dataSize, pData);
+  }
   VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties  ) const
   {
     return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties);
@@ -4468,6 +4577,73 @@ public:
 
   static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
 
+  class AccelerationStructureNVX
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR AccelerationStructureNVX()
+      : m_accelerationStructureNVX(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR AccelerationStructureNVX( std::nullptr_t )
+      : m_accelerationStructureNVX(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNVX( VkAccelerationStructureNVX accelerationStructureNVX )
+      : m_accelerationStructureNVX( accelerationStructureNVX )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    AccelerationStructureNVX & operator=(VkAccelerationStructureNVX accelerationStructureNVX)
+    {
+      m_accelerationStructureNVX = accelerationStructureNVX;
+      return *this; 
+    }
+#endif
+
+    AccelerationStructureNVX & operator=( std::nullptr_t )
+    {
+      m_accelerationStructureNVX = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( AccelerationStructureNVX const & rhs ) const
+    {
+      return m_accelerationStructureNVX == rhs.m_accelerationStructureNVX;
+    }
+
+    bool operator!=(AccelerationStructureNVX const & rhs ) const
+    {
+      return m_accelerationStructureNVX != rhs.m_accelerationStructureNVX;
+    }
+
+    bool operator<(AccelerationStructureNVX const & rhs ) const
+    {
+      return m_accelerationStructureNVX < rhs.m_accelerationStructureNVX;
+    }
+
+
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNVX() const
+    {
+      return m_accelerationStructureNVX;
+    }
+
+    explicit operator bool() const
+    {
+      return m_accelerationStructureNVX != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_accelerationStructureNVX == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkAccelerationStructureNVX m_accelerationStructureNVX;
+  };
+
+  static_assert( sizeof( AccelerationStructureNVX ) == sizeof( VkAccelerationStructureNVX ), "handle and wrapper have different size!" );
+
   class DisplayKHR
   {
   public:
@@ -4901,11 +5077,16 @@ public:
       return *this;
     }
 
-    operator const VkOffset2D&() const
+    operator VkOffset2D const&() const
     {
       return *reinterpret_cast<const VkOffset2D*>(this);
     }
 
+    operator VkOffset2D &()
+    {
+      return *reinterpret_cast<VkOffset2D*>(this);
+    }
+
     bool operator==( Offset2D const& rhs ) const
     {
       return ( x == rhs.x )
@@ -4968,11 +5149,16 @@ public:
       return *this;
     }
 
-    operator const VkOffset3D&() const
+    operator VkOffset3D const&() const
     {
       return *reinterpret_cast<const VkOffset3D*>(this);
     }
 
+    operator VkOffset3D &()
+    {
+      return *reinterpret_cast<VkOffset3D*>(this);
+    }
+
     bool operator==( Offset3D const& rhs ) const
     {
       return ( x == rhs.x )
@@ -5022,11 +5208,16 @@ public:
       return *this;
     }
 
-    operator const VkExtent2D&() const
+    operator VkExtent2D const&() const
     {
       return *reinterpret_cast<const VkExtent2D*>(this);
     }
 
+    operator VkExtent2D &()
+    {
+      return *reinterpret_cast<VkExtent2D*>(this);
+    }
+
     bool operator==( Extent2D const& rhs ) const
     {
       return ( width == rhs.width )
@@ -5089,11 +5280,16 @@ public:
       return *this;
     }
 
-    operator const VkExtent3D&() const
+    operator VkExtent3D const&() const
     {
       return *reinterpret_cast<const VkExtent3D*>(this);
     }
 
+    operator VkExtent3D &()
+    {
+      return *reinterpret_cast<VkExtent3D*>(this);
+    }
+
     bool operator==( Extent3D const& rhs ) const
     {
       return ( width == rhs.width )
@@ -5175,11 +5371,16 @@ public:
       return *this;
     }
 
-    operator const VkViewport&() const
+    operator VkViewport const&() const
     {
       return *reinterpret_cast<const VkViewport*>(this);
     }
 
+    operator VkViewport &()
+    {
+      return *reinterpret_cast<VkViewport*>(this);
+    }
+
     bool operator==( Viewport const& rhs ) const
     {
       return ( x == rhs.x )
@@ -5235,11 +5436,16 @@ public:
       return *this;
     }
 
-    operator const VkRect2D&() const
+    operator VkRect2D const&() const
     {
       return *reinterpret_cast<const VkRect2D*>(this);
     }
 
+    operator VkRect2D &()
+    {
+      return *reinterpret_cast<VkRect2D*>(this);
+    }
+
     bool operator==( Rect2D const& rhs ) const
     {
       return ( offset == rhs.offset )
@@ -5295,11 +5501,16 @@ public:
       return *this;
     }
 
-    operator const VkClearRect&() const
+    operator VkClearRect const&() const
     {
       return *reinterpret_cast<const VkClearRect*>(this);
     }
 
+    operator VkClearRect &()
+    {
+      return *reinterpret_cast<VkClearRect*>(this);
+    }
+
     bool operator==( ClearRect const& rhs ) const
     {
       return ( rect == rhs.rect )
@@ -5320,11 +5531,16 @@ public:
 
   struct ExtensionProperties
   {
-    operator const VkExtensionProperties&() const
+    operator VkExtensionProperties const&() const
     {
       return *reinterpret_cast<const VkExtensionProperties*>(this);
     }
 
+    operator VkExtensionProperties &()
+    {
+      return *reinterpret_cast<VkExtensionProperties*>(this);
+    }
+
     bool operator==( ExtensionProperties const& rhs ) const
     {
       return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
@@ -5343,11 +5559,16 @@ public:
 
   struct LayerProperties
   {
-    operator const VkLayerProperties&() const
+    operator VkLayerProperties const&() const
     {
       return *reinterpret_cast<const VkLayerProperties*>(this);
     }
 
+    operator VkLayerProperties &()
+    {
+      return *reinterpret_cast<VkLayerProperties*>(this);
+    }
+
     bool operator==( LayerProperties const& rhs ) const
     {
       return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
@@ -5431,11 +5652,16 @@ public:
       return *this;
     }
 
-    operator const VkAllocationCallbacks&() const
+    operator VkAllocationCallbacks const&() const
     {
       return *reinterpret_cast<const VkAllocationCallbacks*>(this);
     }
 
+    operator VkAllocationCallbacks &()
+    {
+      return *reinterpret_cast<VkAllocationCallbacks*>(this);
+    }
+
     bool operator==( AllocationCallbacks const& rhs ) const
     {
       return ( pUserData == rhs.pUserData )
@@ -5462,11 +5688,16 @@ public:
 
   struct MemoryRequirements
   {
-    operator const VkMemoryRequirements&() const
+    operator VkMemoryRequirements const&() const
     {
       return *reinterpret_cast<const VkMemoryRequirements*>(this);
     }
 
+    operator VkMemoryRequirements &()
+    {
+      return *reinterpret_cast<VkMemoryRequirements*>(this);
+    }
+
     bool operator==( MemoryRequirements const& rhs ) const
     {
       return ( size == rhs.size )
@@ -5524,11 +5755,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorBufferInfo&() const
+    operator VkDescriptorBufferInfo const&() const
     {
       return *reinterpret_cast<const VkDescriptorBufferInfo*>(this);
     }
 
+    operator VkDescriptorBufferInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorBufferInfo*>(this);
+    }
+
     bool operator==( DescriptorBufferInfo const& rhs ) const
     {
       return ( buffer == rhs.buffer )
@@ -5549,11 +5785,16 @@ public:
 
   struct SubresourceLayout
   {
-    operator const VkSubresourceLayout&() const
+    operator VkSubresourceLayout const&() const
     {
       return *reinterpret_cast<const VkSubresourceLayout*>(this);
     }
 
+    operator VkSubresourceLayout &()
+    {
+      return *reinterpret_cast<VkSubresourceLayout*>(this);
+    }
+
     bool operator==( SubresourceLayout const& rhs ) const
     {
       return ( offset == rhs.offset )
@@ -5615,11 +5856,16 @@ public:
       return *this;
     }
 
-    operator const VkBufferCopy&() const
+    operator VkBufferCopy const&() const
     {
       return *reinterpret_cast<const VkBufferCopy*>(this);
     }
 
+    operator VkBufferCopy &()
+    {
+      return *reinterpret_cast<VkBufferCopy*>(this);
+    }
+
     bool operator==( BufferCopy const& rhs ) const
     {
       return ( srcOffset == rhs.srcOffset )
@@ -5677,11 +5923,16 @@ public:
       return *this;
     }
 
-    operator const VkSpecializationMapEntry&() const
+    operator VkSpecializationMapEntry const&() const
     {
       return *reinterpret_cast<const VkSpecializationMapEntry*>(this);
     }
 
+    operator VkSpecializationMapEntry &()
+    {
+      return *reinterpret_cast<VkSpecializationMapEntry*>(this);
+    }
+
     bool operator==( SpecializationMapEntry const& rhs ) const
     {
       return ( constantID == rhs.constantID )
@@ -5747,11 +5998,16 @@ public:
       return *this;
     }
 
-    operator const VkSpecializationInfo&() const
+    operator VkSpecializationInfo const&() const
     {
       return *reinterpret_cast<const VkSpecializationInfo*>(this);
     }
 
+    operator VkSpecializationInfo &()
+    {
+      return *reinterpret_cast<VkSpecializationInfo*>(this);
+    }
+
     bool operator==( SpecializationInfo const& rhs ) const
     {
       return ( mapEntryCount == rhs.mapEntryCount )
@@ -5807,11 +6063,16 @@ public:
       return *this;
     }
 
-    operator VkClearColorValue const& () const
+    operator VkClearColorValue const&() const
     {
       return *reinterpret_cast<const VkClearColorValue*>(this);
     }
 
+    operator VkClearColorValue &()
+    {
+      return *reinterpret_cast<VkClearColorValue*>(this);
+    }
+
     float float32[4];
     int32_t int32[4];
     uint32_t uint32[4];
@@ -5848,11 +6109,16 @@ public:
       return *this;
     }
 
-    operator const VkClearDepthStencilValue&() const
+    operator VkClearDepthStencilValue const&() const
     {
       return *reinterpret_cast<const VkClearDepthStencilValue*>(this);
     }
 
+    operator VkClearDepthStencilValue &()
+    {
+      return *reinterpret_cast<VkClearDepthStencilValue*>(this);
+    }
+
     bool operator==( ClearDepthStencilValue const& rhs ) const
     {
       return ( depth == rhs.depth )
@@ -5893,11 +6159,16 @@ public:
       return *this;
     }
 
-    operator VkClearValue const& () const
+    operator VkClearValue const&() const
     {
       return *reinterpret_cast<const VkClearValue*>(this);
     }
 
+    operator VkClearValue &()
+    {
+      return *reinterpret_cast<VkClearValue*>(this);
+    }
+
 #ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
     ClearColorValue color;
     ClearDepthStencilValue depthStencil;
@@ -6362,11 +6633,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceFeatures&() const
+    operator VkPhysicalDeviceFeatures const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this);
     }
 
+    operator VkPhysicalDeviceFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceFeatures*>(this);
+    }
+
     bool operator==( PhysicalDeviceFeatures const& rhs ) const
     {
       return ( robustBufferAccess == rhs.robustBufferAccess )
@@ -6491,11 +6767,16 @@ public:
 
   struct PhysicalDeviceSparseProperties
   {
-    operator const VkPhysicalDeviceSparseProperties&() const
+    operator VkPhysicalDeviceSparseProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
     }
 
+    operator VkPhysicalDeviceSparseProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceSparseProperties const& rhs ) const
     {
       return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape )
@@ -6565,11 +6846,16 @@ public:
       return *this;
     }
 
-    operator const VkDrawIndirectCommand&() const
+    operator VkDrawIndirectCommand const&() const
     {
       return *reinterpret_cast<const VkDrawIndirectCommand*>(this);
     }
 
+    operator VkDrawIndirectCommand &()
+    {
+      return *reinterpret_cast<VkDrawIndirectCommand*>(this);
+    }
+
     bool operator==( DrawIndirectCommand const& rhs ) const
     {
       return ( vertexCount == rhs.vertexCount )
@@ -6645,11 +6931,16 @@ public:
       return *this;
     }
 
-    operator const VkDrawIndexedIndirectCommand&() const
+    operator VkDrawIndexedIndirectCommand const&() const
     {
       return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this);
     }
 
+    operator VkDrawIndexedIndirectCommand &()
+    {
+      return *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this);
+    }
+
     bool operator==( DrawIndexedIndirectCommand const& rhs ) const
     {
       return ( indexCount == rhs.indexCount )
@@ -6711,11 +7002,16 @@ public:
       return *this;
     }
 
-    operator const VkDispatchIndirectCommand&() const
+    operator VkDispatchIndirectCommand const&() const
     {
       return *reinterpret_cast<const VkDispatchIndirectCommand*>(this);
     }
 
+    operator VkDispatchIndirectCommand &()
+    {
+      return *reinterpret_cast<VkDispatchIndirectCommand*>(this);
+    }
+
     bool operator==( DispatchIndirectCommand const& rhs ) const
     {
       return ( x == rhs.x )
@@ -6736,11 +7032,16 @@ public:
 
   struct DisplayPlanePropertiesKHR
   {
-    operator const VkDisplayPlanePropertiesKHR&() const
+    operator VkDisplayPlanePropertiesKHR const&() const
     {
       return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
     }
 
+    operator VkDisplayPlanePropertiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this);
+    }
+
     bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
     {
       return ( currentDisplay == rhs.currentDisplay )
@@ -6788,11 +7089,16 @@ public:
       return *this;
     }
 
-    operator const VkDisplayModeParametersKHR&() const
+    operator VkDisplayModeParametersKHR const&() const
     {
       return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this);
     }
 
+    operator VkDisplayModeParametersKHR &()
+    {
+      return *reinterpret_cast<VkDisplayModeParametersKHR*>(this);
+    }
+
     bool operator==( DisplayModeParametersKHR const& rhs ) const
     {
       return ( visibleRegion == rhs.visibleRegion )
@@ -6811,11 +7117,16 @@ public:
 
   struct DisplayModePropertiesKHR
   {
-    operator const VkDisplayModePropertiesKHR&() const
+    operator VkDisplayModePropertiesKHR const&() const
     {
       return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
     }
 
+    operator VkDisplayModePropertiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayModePropertiesKHR*>(this);
+    }
+
     bool operator==( DisplayModePropertiesKHR const& rhs ) const
     {
       return ( displayMode == rhs.displayMode )
@@ -6878,11 +7189,16 @@ public:
       return *this;
     }
 
-    operator const VkRectLayerKHR&() const
+    operator VkRectLayerKHR const&() const
     {
       return *reinterpret_cast<const VkRectLayerKHR*>(this);
     }
 
+    operator VkRectLayerKHR &()
+    {
+      return *reinterpret_cast<VkRectLayerKHR*>(this);
+    }
+
     bool operator==( RectLayerKHR const& rhs ) const
     {
       return ( offset == rhs.offset )
@@ -6932,11 +7248,16 @@ public:
       return *this;
     }
 
-    operator const VkPresentRegionKHR&() const
+    operator VkPresentRegionKHR const&() const
     {
       return *reinterpret_cast<const VkPresentRegionKHR*>(this);
     }
 
+    operator VkPresentRegionKHR &()
+    {
+      return *reinterpret_cast<VkPresentRegionKHR*>(this);
+    }
+
     bool operator==( PresentRegionKHR const& rhs ) const
     {
       return ( rectangleCount == rhs.rectangleCount )
@@ -6984,11 +7305,16 @@ public:
       return *this;
     }
 
-    operator const VkXYColorEXT&() const
+    operator VkXYColorEXT const&() const
     {
       return *reinterpret_cast<const VkXYColorEXT*>(this);
     }
 
+    operator VkXYColorEXT &()
+    {
+      return *reinterpret_cast<VkXYColorEXT*>(this);
+    }
+
     bool operator==( XYColorEXT const& rhs ) const
     {
       return ( x == rhs.x )
@@ -7007,11 +7333,16 @@ public:
 
   struct RefreshCycleDurationGOOGLE
   {
-    operator const VkRefreshCycleDurationGOOGLE&() const
+    operator VkRefreshCycleDurationGOOGLE const&() const
     {
       return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>(this);
     }
 
+    operator VkRefreshCycleDurationGOOGLE &()
+    {
+      return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this);
+    }
+
     bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const
     {
       return ( refreshDuration == rhs.refreshDuration );
@@ -7028,11 +7359,16 @@ public:
 
   struct PastPresentationTimingGOOGLE
   {
-    operator const VkPastPresentationTimingGOOGLE&() const
+    operator VkPastPresentationTimingGOOGLE const&() const
     {
       return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>(this);
     }
 
+    operator VkPastPresentationTimingGOOGLE &()
+    {
+      return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this);
+    }
+
     bool operator==( PastPresentationTimingGOOGLE const& rhs ) const
     {
       return ( presentID == rhs.presentID )
@@ -7086,11 +7422,16 @@ public:
       return *this;
     }
 
-    operator const VkPresentTimeGOOGLE&() const
+    operator VkPresentTimeGOOGLE const&() const
     {
       return *reinterpret_cast<const VkPresentTimeGOOGLE*>(this);
     }
 
+    operator VkPresentTimeGOOGLE &()
+    {
+      return *reinterpret_cast<VkPresentTimeGOOGLE*>(this);
+    }
+
     bool operator==( PresentTimeGOOGLE const& rhs ) const
     {
       return ( presentID == rhs.presentID )
@@ -7138,11 +7479,16 @@ public:
       return *this;
     }
 
-    operator const VkViewportWScalingNV&() const
+    operator VkViewportWScalingNV const&() const
     {
       return *reinterpret_cast<const VkViewportWScalingNV*>(this);
     }
 
+    operator VkViewportWScalingNV &()
+    {
+      return *reinterpret_cast<VkViewportWScalingNV*>(this);
+    }
+
     bool operator==( ViewportWScalingNV const& rhs ) const
     {
       return ( xcoeff == rhs.xcoeff )
@@ -7190,11 +7536,16 @@ public:
       return *this;
     }
 
-    operator const VkSampleLocationEXT&() const
+    operator VkSampleLocationEXT const&() const
     {
       return *reinterpret_cast<const VkSampleLocationEXT*>(this);
     }
 
+    operator VkSampleLocationEXT &()
+    {
+      return *reinterpret_cast<VkSampleLocationEXT*>(this);
+    }
+
     bool operator==( SampleLocationEXT const& rhs ) const
     {
       return ( x == rhs.x )
@@ -7213,11 +7564,16 @@ public:
 
   struct ShaderResourceUsageAMD
   {
-    operator const VkShaderResourceUsageAMD&() const
+    operator VkShaderResourceUsageAMD const&() const
     {
       return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this);
     }
 
+    operator VkShaderResourceUsageAMD &()
+    {
+      return *reinterpret_cast<VkShaderResourceUsageAMD*>(this);
+    }
+
     bool operator==( ShaderResourceUsageAMD const& rhs ) const
     {
       return ( numUsedVgprs == rhs.numUsedVgprs )
@@ -7271,11 +7627,16 @@ public:
       return *this;
     }
 
-    operator const VkVertexInputBindingDivisorDescriptionEXT&() const
+    operator VkVertexInputBindingDivisorDescriptionEXT const&() const
     {
       return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>(this);
     }
 
+    operator VkVertexInputBindingDivisorDescriptionEXT &()
+    {
+      return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this);
+    }
+
     bool operator==( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
     {
       return ( binding == rhs.binding )
@@ -7292,6 +7653,130 @@ public:
   };
   static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
 
+  struct CoarseSampleLocationNV
+  {
+    CoarseSampleLocationNV( uint32_t pixelX_ = 0,
+                            uint32_t pixelY_ = 0,
+                            uint32_t sample_ = 0 )
+      : pixelX( pixelX_ )
+      , pixelY( pixelY_ )
+      , sample( sample_ )
+    {
+    }
+
+    CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+    }
+
+    CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+      return *this;
+    }
+    CoarseSampleLocationNV& setPixelX( uint32_t pixelX_ )
+    {
+      pixelX = pixelX_;
+      return *this;
+    }
+
+    CoarseSampleLocationNV& setPixelY( uint32_t pixelY_ )
+    {
+      pixelY = pixelY_;
+      return *this;
+    }
+
+    CoarseSampleLocationNV& setSample( uint32_t sample_ )
+    {
+      sample = sample_;
+      return *this;
+    }
+
+    operator VkCoarseSampleLocationNV const&() const
+    {
+      return *reinterpret_cast<const VkCoarseSampleLocationNV*>(this);
+    }
+
+    operator VkCoarseSampleLocationNV &()
+    {
+      return *reinterpret_cast<VkCoarseSampleLocationNV*>(this);
+    }
+
+    bool operator==( CoarseSampleLocationNV const& rhs ) const
+    {
+      return ( pixelX == rhs.pixelX )
+          && ( pixelY == rhs.pixelY )
+          && ( sample == rhs.sample );
+    }
+
+    bool operator!=( CoarseSampleLocationNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t pixelX;
+    uint32_t pixelY;
+    uint32_t sample;
+  };
+  static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
+
+  struct DrawMeshTasksIndirectCommandNV
+  {
+    DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
+                                    uint32_t firstTask_ = 0 )
+      : taskCount( taskCount_ )
+      , firstTask( firstTask_ )
+    {
+    }
+
+    DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+    }
+
+    DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+      return *this;
+    }
+    DrawMeshTasksIndirectCommandNV& setTaskCount( uint32_t taskCount_ )
+    {
+      taskCount = taskCount_;
+      return *this;
+    }
+
+    DrawMeshTasksIndirectCommandNV& setFirstTask( uint32_t firstTask_ )
+    {
+      firstTask = firstTask_;
+      return *this;
+    }
+
+    operator VkDrawMeshTasksIndirectCommandNV const&() const
+    {
+      return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>(this);
+    }
+
+    operator VkDrawMeshTasksIndirectCommandNV &()
+    {
+      return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this);
+    }
+
+    bool operator==( DrawMeshTasksIndirectCommandNV const& rhs ) const
+    {
+      return ( taskCount == rhs.taskCount )
+          && ( firstTask == rhs.firstTask );
+    }
+
+    bool operator!=( DrawMeshTasksIndirectCommandNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t taskCount;
+    uint32_t firstTask;
+  };
+  static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
+
   enum class ImageLayout
   {
     eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
@@ -7308,7 +7793,8 @@ public:
     eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
     eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
     ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-    eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
+    eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
+    eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV
   };
 
   struct DescriptorImageInfo
@@ -7350,11 +7836,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorImageInfo&() const
+    operator VkDescriptorImageInfo const&() const
     {
       return *reinterpret_cast<const VkDescriptorImageInfo*>(this);
     }
 
+    operator VkDescriptorImageInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorImageInfo*>(this);
+    }
+
     bool operator==( DescriptorImageInfo const& rhs ) const
     {
       return ( sampler == rhs.sampler )
@@ -7404,11 +7895,16 @@ public:
       return *this;
     }
 
-    operator const VkAttachmentReference&() const
+    operator VkAttachmentReference const&() const
     {
       return *reinterpret_cast<const VkAttachmentReference*>(this);
     }
 
+    operator VkAttachmentReference &()
+    {
+      return *reinterpret_cast<VkAttachmentReference*>(this);
+    }
+
     bool operator==( AttachmentReference const& rhs ) const
     {
       return ( attachment == rhs.attachment )
@@ -7526,11 +8022,16 @@ public:
       return *this;
     }
 
-    operator const VkComponentMapping&() const
+    operator VkComponentMapping const&() const
     {
       return *reinterpret_cast<const VkComponentMapping*>(this);
     }
 
+    operator VkComponentMapping &()
+    {
+      return *reinterpret_cast<VkComponentMapping*>(this);
+    }
+
     bool operator==( ComponentMapping const& rhs ) const
     {
       return ( r == rhs.r )
@@ -7564,7 +8065,8 @@ public:
     eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
     eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
     eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-    eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT
+    eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
+    eAccelerationStructureNVX = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX
   };
 
   struct DescriptorPoolSize
@@ -7598,11 +8100,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorPoolSize&() const
+    operator VkDescriptorPoolSize const&() const
     {
       return *reinterpret_cast<const VkDescriptorPoolSize*>(this);
     }
 
+    operator VkDescriptorPoolSize &()
+    {
+      return *reinterpret_cast<VkDescriptorPoolSize*>(this);
+    }
+
     bool operator==( DescriptorPoolSize const& rhs ) const
     {
       return ( type == rhs.type )
@@ -7682,11 +8189,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorUpdateTemplateEntry&() const
+    operator VkDescriptorUpdateTemplateEntry const&() const
     {
       return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>(this);
     }
 
+    operator VkDescriptorUpdateTemplateEntry &()
+    {
+      return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this);
+    }
+
     bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const
     {
       return ( dstBinding == rhs.dstBinding )
@@ -7717,7 +8229,8 @@ public:
   {
     eOcclusion = VK_QUERY_TYPE_OCCLUSION,
     ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
-    eTimestamp = VK_QUERY_TYPE_TIMESTAMP
+    eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
+    eCompactedSizeNVX = VK_QUERY_TYPE_COMPACTED_SIZE_NVX
   };
 
   enum class BorderColor
@@ -7733,7 +8246,8 @@ public:
   enum class PipelineBindPoint
   {
     eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
-    eCompute = VK_PIPELINE_BIND_POINT_COMPUTE
+    eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
+    eRaytracingNVX = VK_PIPELINE_BIND_POINT_RAYTRACING_NVX
   };
 
   enum class PipelineCacheHeaderVersion
@@ -8005,11 +8519,16 @@ public:
       return *this;
     }
 
-    operator const VkStencilOpState&() const
+    operator VkStencilOpState const&() const
     {
       return *reinterpret_cast<const VkStencilOpState*>(this);
     }
 
+    operator VkStencilOpState &()
+    {
+      return *reinterpret_cast<VkStencilOpState*>(this);
+    }
+
     bool operator==( StencilOpState const& rhs ) const
     {
       return ( failOp == rhs.failOp )
@@ -8124,11 +8643,16 @@ public:
       return *this;
     }
 
-    operator const VkVertexInputBindingDescription&() const
+    operator VkVertexInputBindingDescription const&() const
     {
       return *reinterpret_cast<const VkVertexInputBindingDescription*>(this);
     }
 
+    operator VkVertexInputBindingDescription &()
+    {
+      return *reinterpret_cast<VkVertexInputBindingDescription*>(this);
+    }
+
     bool operator==( VertexInputBindingDescription const& rhs ) const
     {
       return ( binding == rhs.binding )
@@ -8459,11 +8983,16 @@ public:
       return *this;
     }
 
-    operator const VkVertexInputAttributeDescription&() const
+    operator VkVertexInputAttributeDescription const&() const
     {
       return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this);
     }
 
+    operator VkVertexInputAttributeDescription &()
+    {
+      return *reinterpret_cast<VkVertexInputAttributeDescription*>(this);
+    }
+
     bool operator==( VertexInputAttributeDescription const& rhs ) const
     {
       return ( location == rhs.location )
@@ -8686,6 +9215,7 @@ public:
     eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
     eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
     eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
+    ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
     eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
     eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
     eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
@@ -8792,6 +9322,23 @@ public:
     ePhysicalDeviceDescriptorIndexingPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT,
     eDescriptorSetVariableDescriptorCountAllocateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT,
     eDescriptorSetVariableDescriptorCountLayoutSupportEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT,
+    ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
+    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,
+    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,
     ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR,
     eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
@@ -8801,6 +9348,13 @@ public:
     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,
+    ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
+    ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
+    ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
+    ePhysicalDeviceFragmentShaderBarycentricFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
+    ePhysicalDeviceShaderImageFootprintFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
+    ePipelineViewportExclusiveScissorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
+    ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
     eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV,
     eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
     ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR
@@ -8867,11 +9421,16 @@ public:
       return *this;
     }
 
-    operator const VkApplicationInfo&() const
+    operator VkApplicationInfo const&() const
     {
       return *reinterpret_cast<const VkApplicationInfo*>(this);
     }
 
+    operator VkApplicationInfo &()
+    {
+      return *reinterpret_cast<VkApplicationInfo*>(this);
+    }
+
     bool operator==( ApplicationInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -8970,11 +9529,16 @@ public:
       return *this;
     }
 
-    operator const VkInstanceCreateInfo&() const
+    operator VkInstanceCreateInfo const&() const
     {
       return *reinterpret_cast<const VkInstanceCreateInfo*>(this);
     }
 
+    operator VkInstanceCreateInfo &()
+    {
+      return *reinterpret_cast<VkInstanceCreateInfo*>(this);
+    }
+
     bool operator==( InstanceCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9043,11 +9607,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryAllocateInfo&() const
+    operator VkMemoryAllocateInfo const&() const
     {
       return *reinterpret_cast<const VkMemoryAllocateInfo*>(this);
     }
 
+    operator VkMemoryAllocateInfo &()
+    {
+      return *reinterpret_cast<VkMemoryAllocateInfo*>(this);
+    }
+
     bool operator==( MemoryAllocateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9116,11 +9685,16 @@ public:
       return *this;
     }
 
-    operator const VkMappedMemoryRange&() const
+    operator VkMappedMemoryRange const&() const
     {
       return *reinterpret_cast<const VkMappedMemoryRange*>(this);
     }
 
+    operator VkMappedMemoryRange &()
+    {
+      return *reinterpret_cast<VkMappedMemoryRange*>(this);
+    }
+
     bool operator==( MappedMemoryRange const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9231,11 +9805,16 @@ public:
       return *this;
     }
 
-    operator const VkWriteDescriptorSet&() const
+    operator VkWriteDescriptorSet const&() const
     {
       return *reinterpret_cast<const VkWriteDescriptorSet*>(this);
     }
 
+    operator VkWriteDescriptorSet &()
+    {
+      return *reinterpret_cast<VkWriteDescriptorSet*>(this);
+    }
+
     bool operator==( WriteDescriptorSet const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9348,11 +9927,16 @@ public:
       return *this;
     }
 
-    operator const VkCopyDescriptorSet&() const
+    operator VkCopyDescriptorSet const&() const
     {
       return *reinterpret_cast<const VkCopyDescriptorSet*>(this);
     }
 
+    operator VkCopyDescriptorSet &()
+    {
+      return *reinterpret_cast<VkCopyDescriptorSet*>(this);
+    }
+
     bool operator==( CopyDescriptorSet const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9447,11 +10031,16 @@ public:
       return *this;
     }
 
-    operator const VkBufferViewCreateInfo&() const
+    operator VkBufferViewCreateInfo const&() const
     {
       return *reinterpret_cast<const VkBufferViewCreateInfo*>(this);
     }
 
+    operator VkBufferViewCreateInfo &()
+    {
+      return *reinterpret_cast<VkBufferViewCreateInfo*>(this);
+    }
+
     bool operator==( BufferViewCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9526,11 +10115,16 @@ public:
       return *this;
     }
 
-    operator const VkShaderModuleCreateInfo&() const
+    operator VkShaderModuleCreateInfo const&() const
     {
       return *reinterpret_cast<const VkShaderModuleCreateInfo*>(this);
     }
 
+    operator VkShaderModuleCreateInfo &()
+    {
+      return *reinterpret_cast<VkShaderModuleCreateInfo*>(this);
+    }
+
     bool operator==( ShaderModuleCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9601,11 +10195,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorSetAllocateInfo&() const
+    operator VkDescriptorSetAllocateInfo const&() const
     {
       return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(this);
     }
 
+    operator VkDescriptorSetAllocateInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this);
+    }
+
     bool operator==( DescriptorSetAllocateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9692,11 +10291,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineVertexInputStateCreateInfo&() const
+    operator VkPipelineVertexInputStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(this);
     }
 
+    operator VkPipelineVertexInputStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9771,11 +10375,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineInputAssemblyStateCreateInfo&() const
+    operator VkPipelineInputAssemblyStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(this);
     }
 
+    operator VkPipelineInputAssemblyStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9838,11 +10447,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineTessellationStateCreateInfo&() const
+    operator VkPipelineTessellationStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(this);
     }
 
+    operator VkPipelineTessellationStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -9927,11 +10541,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineViewportStateCreateInfo&() const
+    operator VkPipelineViewportStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(this);
     }
 
+    operator VkPipelineViewportStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineViewportStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10070,11 +10689,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineRasterizationStateCreateInfo&() const
+    operator VkPipelineRasterizationStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(this);
     }
 
+    operator VkPipelineRasterizationStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10217,11 +10841,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineDepthStencilStateCreateInfo&() const
+    operator VkPipelineDepthStencilStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(this);
     }
 
+    operator VkPipelineDepthStencilStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10306,11 +10935,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineCacheCreateInfo&() const
+    operator VkPipelineCacheCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineCacheCreateInfo*>(this);
     }
 
+    operator VkPipelineCacheCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineCacheCreateInfo*>(this);
+    }
+
     bool operator==( PipelineCacheCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10485,11 +11119,16 @@ public:
       return *this;
     }
 
-    operator const VkSamplerCreateInfo&() const
+    operator VkSamplerCreateInfo const&() const
     {
       return *reinterpret_cast<const VkSamplerCreateInfo*>(this);
     }
 
+    operator VkSamplerCreateInfo &()
+    {
+      return *reinterpret_cast<VkSamplerCreateInfo*>(this);
+    }
+
     bool operator==( SamplerCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10586,11 +11225,16 @@ public:
       return *this;
     }
 
-    operator const VkCommandBufferAllocateInfo&() const
+    operator VkCommandBufferAllocateInfo const&() const
     {
       return *reinterpret_cast<const VkCommandBufferAllocateInfo*>(this);
     }
 
+    operator VkCommandBufferAllocateInfo &()
+    {
+      return *reinterpret_cast<VkCommandBufferAllocateInfo*>(this);
+    }
+
     bool operator==( CommandBufferAllocateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10677,11 +11321,16 @@ public:
       return *this;
     }
 
-    operator const VkRenderPassBeginInfo&() const
+    operator VkRenderPassBeginInfo const&() const
     {
       return *reinterpret_cast<const VkRenderPassBeginInfo*>(this);
     }
 
+    operator VkRenderPassBeginInfo &()
+    {
+      return *reinterpret_cast<VkRenderPassBeginInfo*>(this);
+    }
+
     bool operator==( RenderPassBeginInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10740,11 +11389,16 @@ public:
       return *this;
     }
 
-    operator const VkEventCreateInfo&() const
+    operator VkEventCreateInfo const&() const
     {
       return *reinterpret_cast<const VkEventCreateInfo*>(this);
     }
 
+    operator VkEventCreateInfo &()
+    {
+      return *reinterpret_cast<VkEventCreateInfo*>(this);
+    }
+
     bool operator==( EventCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10795,11 +11449,16 @@ public:
       return *this;
     }
 
-    operator const VkSemaphoreCreateInfo&() const
+    operator VkSemaphoreCreateInfo const&() const
     {
       return *reinterpret_cast<const VkSemaphoreCreateInfo*>(this);
     }
 
+    operator VkSemaphoreCreateInfo &()
+    {
+      return *reinterpret_cast<VkSemaphoreCreateInfo*>(this);
+    }
+
     bool operator==( SemaphoreCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10898,11 +11557,16 @@ public:
       return *this;
     }
 
-    operator const VkFramebufferCreateInfo&() const
+    operator VkFramebufferCreateInfo const&() const
     {
       return *reinterpret_cast<const VkFramebufferCreateInfo*>(this);
     }
 
+    operator VkFramebufferCreateInfo &()
+    {
+      return *reinterpret_cast<VkFramebufferCreateInfo*>(this);
+    }
+
     bool operator==( FramebufferCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -10973,11 +11637,16 @@ public:
       return *this;
     }
 
-    operator const VkDisplayModeCreateInfoKHR&() const
+    operator VkDisplayModeCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(this);
     }
 
+    operator VkDisplayModeCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this);
+    }
+
     bool operator==( DisplayModeCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11046,11 +11715,16 @@ public:
       return *this;
     }
 
-    operator const VkDisplayPresentInfoKHR&() const
+    operator VkDisplayPresentInfoKHR const&() const
     {
       return *reinterpret_cast<const VkDisplayPresentInfoKHR*>(this);
     }
 
+    operator VkDisplayPresentInfoKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPresentInfoKHR*>(this);
+    }
+
     bool operator==( DisplayPresentInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11114,11 +11788,16 @@ public:
       return *this;
     }
 
-    operator const VkAndroidSurfaceCreateInfoKHR&() const
+    operator VkAndroidSurfaceCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(this);
     }
 
+    operator VkAndroidSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this);
+    }
+
     bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11189,11 +11868,16 @@ public:
       return *this;
     }
 
-    operator const VkMirSurfaceCreateInfoKHR&() const
+    operator VkMirSurfaceCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>(this);
     }
 
+    operator VkMirSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkMirSurfaceCreateInfoKHR*>(this);
+    }
+
     bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11258,11 +11942,16 @@ public:
       return *this;
     }
 
-    operator const VkViSurfaceCreateInfoNN&() const
+    operator VkViSurfaceCreateInfoNN const&() const
     {
       return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>(this);
     }
 
+    operator VkViSurfaceCreateInfoNN &()
+    {
+      return *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this);
+    }
+
     bool operator==( ViSurfaceCreateInfoNN const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11333,11 +12022,16 @@ public:
       return *this;
     }
 
-    operator const VkWaylandSurfaceCreateInfoKHR&() const
+    operator VkWaylandSurfaceCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(this);
     }
 
+    operator VkWaylandSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this);
+    }
+
     bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11410,11 +12104,16 @@ public:
       return *this;
     }
 
-    operator const VkWin32SurfaceCreateInfoKHR&() const
+    operator VkWin32SurfaceCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(this);
     }
 
+    operator VkWin32SurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this);
+    }
+
     bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11487,11 +12186,16 @@ public:
       return *this;
     }
 
-    operator const VkXlibSurfaceCreateInfoKHR&() const
+    operator VkXlibSurfaceCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(this);
     }
 
+    operator VkXlibSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this);
+    }
+
     bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11564,11 +12268,16 @@ public:
       return *this;
     }
 
-    operator const VkXcbSurfaceCreateInfoKHR&() const
+    operator VkXcbSurfaceCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(this);
     }
 
+    operator VkXcbSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this);
+    }
+
     bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11632,11 +12341,16 @@ public:
       return *this;
     }
 
-    operator const VkDebugMarkerMarkerInfoEXT&() const
+    operator VkDebugMarkerMarkerInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(this);
     }
 
+    operator VkDebugMarkerMarkerInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this);
+    }
+
     bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11689,11 +12403,16 @@ public:
       return *this;
     }
 
-    operator const VkDedicatedAllocationImageCreateInfoNV&() const
+    operator VkDedicatedAllocationImageCreateInfoNV const&() const
     {
       return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(this);
     }
 
+    operator VkDedicatedAllocationImageCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this);
+    }
+
     bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11744,11 +12463,16 @@ public:
       return *this;
     }
 
-    operator const VkDedicatedAllocationBufferCreateInfoNV&() const
+    operator VkDedicatedAllocationBufferCreateInfoNV const&() const
     {
       return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(this);
     }
 
+    operator VkDedicatedAllocationBufferCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this);
+    }
+
     bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11807,11 +12531,16 @@ public:
       return *this;
     }
 
-    operator const VkDedicatedAllocationMemoryAllocateInfoNV&() const
+    operator VkDedicatedAllocationMemoryAllocateInfoNV const&() const
     {
       return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
     }
 
+    operator VkDedicatedAllocationMemoryAllocateInfoNV &()
+    {
+      return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
+    }
+
     bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11873,11 +12602,16 @@ public:
       return *this;
     }
 
-    operator const VkExportMemoryWin32HandleInfoNV&() const
+    operator VkExportMemoryWin32HandleInfoNV const&() const
     {
       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this);
     }
 
+    operator VkExportMemoryWin32HandleInfoNV &()
+    {
+      return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this);
+    }
+
     bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -11980,11 +12714,16 @@ public:
       return *this;
     }
 
-    operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const
+    operator VkWin32KeyedMutexAcquireReleaseInfoNV const&() const
     {
       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
     }
 
+    operator VkWin32KeyedMutexAcquireReleaseInfoNV &()
+    {
+      return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
+    }
+
     bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12048,11 +12787,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGeneratedCommandsFeaturesNVX&() const
+    operator VkDeviceGeneratedCommandsFeaturesNVX const&() const
     {
       return *reinterpret_cast<const VkDeviceGeneratedCommandsFeaturesNVX*>(this);
     }
 
+    operator VkDeviceGeneratedCommandsFeaturesNVX &()
+    {
+      return *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this);
+    }
+
     bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12135,11 +12879,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGeneratedCommandsLimitsNVX&() const
+    operator VkDeviceGeneratedCommandsLimitsNVX const&() const
     {
       return *reinterpret_cast<const VkDeviceGeneratedCommandsLimitsNVX*>(this);
     }
 
+    operator VkDeviceGeneratedCommandsLimitsNVX &()
+    {
+      return *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this);
+    }
+
     bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12214,11 +12963,16 @@ public:
       return *this;
     }
 
-    operator const VkCmdReserveSpaceForCommandsInfoNVX&() const
+    operator VkCmdReserveSpaceForCommandsInfoNVX const&() const
     {
       return *reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>(this);
     }
 
+    operator VkCmdReserveSpaceForCommandsInfoNVX &()
+    {
+      return *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this);
+    }
+
     bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12273,11 +13027,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceFeatures2&() const
+    operator VkPhysicalDeviceFeatures2 const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceFeatures2*>(this);
     }
 
+    operator VkPhysicalDeviceFeatures2 &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this);
+    }
+
     bool operator==( PhysicalDeviceFeatures2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12330,11 +13089,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDevicePushDescriptorPropertiesKHR&() const
+    operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const
     {
       return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
     }
 
+    operator VkPhysicalDevicePushDescriptorPropertiesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
+    }
+
     bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12393,11 +13157,16 @@ public:
       return *this;
     }
 
-    operator const VkPresentRegionsKHR&() const
+    operator VkPresentRegionsKHR const&() const
     {
       return *reinterpret_cast<const VkPresentRegionsKHR*>(this);
     }
 
+    operator VkPresentRegionsKHR &()
+    {
+      return *reinterpret_cast<VkPresentRegionsKHR*>(this);
+    }
+
     bool operator==( PresentRegionsKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12458,11 +13227,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceVariablePointerFeatures&() const
+    operator VkPhysicalDeviceVariablePointerFeatures const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(this);
     }
 
+    operator VkPhysicalDeviceVariablePointerFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(this);
+    }
+
     bool operator==( PhysicalDeviceVariablePointerFeatures const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12490,11 +13264,16 @@ public:
 
   struct PhysicalDeviceIDProperties
   {
-    operator const VkPhysicalDeviceIDProperties&() const
+    operator VkPhysicalDeviceIDProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>(this);
     }
 
+    operator VkPhysicalDeviceIDProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceIDProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12572,11 +13351,16 @@ public:
       return *this;
     }
 
-    operator const VkExportMemoryWin32HandleInfoKHR&() const
+    operator VkExportMemoryWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(this);
     }
 
+    operator VkExportMemoryWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12606,11 +13390,16 @@ public:
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct MemoryWin32HandlePropertiesKHR
   {
-    operator const VkMemoryWin32HandlePropertiesKHR&() const
+    operator VkMemoryWin32HandlePropertiesKHR const&() const
     {
       return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(this);
     }
 
+    operator VkMemoryWin32HandlePropertiesKHR &()
+    {
+      return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this);
+    }
+
     bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12635,11 +13424,16 @@ public:
 
   struct MemoryFdPropertiesKHR
   {
-    operator const VkMemoryFdPropertiesKHR&() const
+    operator VkMemoryFdPropertiesKHR const&() const
     {
       return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(this);
     }
 
+    operator VkMemoryFdPropertiesKHR &()
+    {
+      return *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this);
+    }
+
     bool operator==( MemoryFdPropertiesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12739,11 +13533,16 @@ public:
       return *this;
     }
 
-    operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const
+    operator VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const
     {
       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
     }
 
+    operator VkWin32KeyedMutexAcquireReleaseInfoKHR &()
+    {
+      return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
+    }
+
     bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12824,11 +13623,16 @@ public:
       return *this;
     }
 
-    operator const VkExportSemaphoreWin32HandleInfoKHR&() const
+    operator VkExportSemaphoreWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(this);
     }
 
+    operator VkExportSemaphoreWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12909,11 +13713,16 @@ public:
       return *this;
     }
 
-    operator const VkD3D12FenceSubmitInfoKHR&() const
+    operator VkD3D12FenceSubmitInfoKHR const&() const
     {
       return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(this);
     }
 
+    operator VkD3D12FenceSubmitInfoKHR &()
+    {
+      return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this);
+    }
+
     bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -12988,11 +13797,16 @@ public:
       return *this;
     }
 
-    operator const VkExportFenceWin32HandleInfoKHR&() const
+    operator VkExportFenceWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(this);
     }
 
+    operator VkExportFenceWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13064,11 +13878,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceMultiviewFeatures&() const
+    operator VkPhysicalDeviceMultiviewFeatures const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(this);
     }
 
+    operator VkPhysicalDeviceMultiviewFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this);
+    }
+
     bool operator==( PhysicalDeviceMultiviewFeatures const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13098,11 +13917,16 @@ public:
 
   struct PhysicalDeviceMultiviewProperties
   {
-    operator const VkPhysicalDeviceMultiviewProperties&() const
+    operator VkPhysicalDeviceMultiviewProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(this);
     }
 
+    operator VkPhysicalDeviceMultiviewProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceMultiviewProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13197,11 +14021,16 @@ public:
       return *this;
     }
 
-    operator const VkRenderPassMultiviewCreateInfo&() const
+    operator VkRenderPassMultiviewCreateInfo const&() const
     {
       return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(this);
     }
 
+    operator VkRenderPassMultiviewCreateInfo &()
+    {
+      return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this);
+    }
+
     bool operator==( RenderPassMultiviewCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13280,11 +14109,16 @@ public:
       return *this;
     }
 
-    operator const VkBindBufferMemoryInfo&() const
+    operator VkBindBufferMemoryInfo const&() const
     {
       return *reinterpret_cast<const VkBindBufferMemoryInfo*>(this);
     }
 
+    operator VkBindBufferMemoryInfo &()
+    {
+      return *reinterpret_cast<VkBindBufferMemoryInfo*>(this);
+    }
+
     bool operator==( BindBufferMemoryInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13349,11 +14183,16 @@ public:
       return *this;
     }
 
-    operator const VkBindBufferMemoryDeviceGroupInfo&() const
+    operator VkBindBufferMemoryDeviceGroupInfo const&() const
     {
       return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(this);
     }
 
+    operator VkBindBufferMemoryDeviceGroupInfo &()
+    {
+      return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this);
+    }
+
     bool operator==( BindBufferMemoryDeviceGroupInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13424,11 +14263,16 @@ public:
       return *this;
     }
 
-    operator const VkBindImageMemoryInfo&() const
+    operator VkBindImageMemoryInfo const&() const
     {
       return *reinterpret_cast<const VkBindImageMemoryInfo*>(this);
     }
 
+    operator VkBindImageMemoryInfo &()
+    {
+      return *reinterpret_cast<VkBindImageMemoryInfo*>(this);
+    }
+
     bool operator==( BindImageMemoryInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13509,11 +14353,16 @@ public:
       return *this;
     }
 
-    operator const VkBindImageMemoryDeviceGroupInfo&() const
+    operator VkBindImageMemoryDeviceGroupInfo const&() const
     {
       return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(this);
     }
 
+    operator VkBindImageMemoryDeviceGroupInfo &()
+    {
+      return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this);
+    }
+
     bool operator==( BindImageMemoryDeviceGroupInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13588,11 +14437,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGroupRenderPassBeginInfo&() const
+    operator VkDeviceGroupRenderPassBeginInfo const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(this);
     }
 
+    operator VkDeviceGroupRenderPassBeginInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this);
+    }
+
     bool operator==( DeviceGroupRenderPassBeginInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13649,11 +14503,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGroupCommandBufferBeginInfo&() const
+    operator VkDeviceGroupCommandBufferBeginInfo const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(this);
     }
 
+    operator VkDeviceGroupCommandBufferBeginInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this);
+    }
+
     bool operator==( DeviceGroupCommandBufferBeginInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13746,11 +14605,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGroupSubmitInfo&() const
+    operator VkDeviceGroupSubmitInfo const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupSubmitInfo*>(this);
     }
 
+    operator VkDeviceGroupSubmitInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this);
+    }
+
     bool operator==( DeviceGroupSubmitInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13821,11 +14685,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGroupBindSparseInfo&() const
+    operator VkDeviceGroupBindSparseInfo const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(this);
     }
 
+    operator VkDeviceGroupBindSparseInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this);
+    }
+
     bool operator==( DeviceGroupBindSparseInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13880,11 +14749,16 @@ public:
       return *this;
     }
 
-    operator const VkImageSwapchainCreateInfoKHR&() const
+    operator VkImageSwapchainCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(this);
     }
 
+    operator VkImageSwapchainCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this);
+    }
+
     bool operator==( ImageSwapchainCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -13943,11 +14817,16 @@ public:
       return *this;
     }
 
-    operator const VkBindImageMemorySwapchainInfoKHR&() const
+    operator VkBindImageMemorySwapchainInfoKHR const&() const
     {
       return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(this);
     }
 
+    operator VkBindImageMemorySwapchainInfoKHR &()
+    {
+      return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this);
+    }
+
     bool operator==( BindImageMemorySwapchainInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14032,11 +14911,16 @@ public:
       return *this;
     }
 
-    operator const VkAcquireNextImageInfoKHR&() const
+    operator VkAcquireNextImageInfoKHR const&() const
     {
       return *reinterpret_cast<const VkAcquireNextImageInfoKHR*>(this);
     }
 
+    operator VkAcquireNextImageInfoKHR &()
+    {
+      return *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this);
+    }
+
     bool operator==( AcquireNextImageInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14151,11 +15035,16 @@ public:
       return *this;
     }
 
-    operator const VkHdrMetadataEXT&() const
+    operator VkHdrMetadataEXT const&() const
     {
       return *reinterpret_cast<const VkHdrMetadataEXT*>(this);
     }
 
+    operator VkHdrMetadataEXT &()
+    {
+      return *reinterpret_cast<VkHdrMetadataEXT*>(this);
+    }
+
     bool operator==( HdrMetadataEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14228,11 +15117,16 @@ public:
       return *this;
     }
 
-    operator const VkPresentTimesInfoGOOGLE&() const
+    operator VkPresentTimesInfoGOOGLE const&() const
     {
       return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(this);
     }
 
+    operator VkPresentTimesInfoGOOGLE &()
+    {
+      return *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this);
+    }
+
     bool operator==( PresentTimesInfoGOOGLE const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14294,11 +15188,16 @@ public:
       return *this;
     }
 
-    operator const VkIOSSurfaceCreateInfoMVK&() const
+    operator VkIOSSurfaceCreateInfoMVK const&() const
     {
       return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(this);
     }
 
+    operator VkIOSSurfaceCreateInfoMVK &()
+    {
+      return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this);
+    }
+
     bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14361,11 +15260,16 @@ public:
       return *this;
     }
 
-    operator const VkMacOSSurfaceCreateInfoMVK&() const
+    operator VkMacOSSurfaceCreateInfoMVK const&() const
     {
       return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(this);
     }
 
+    operator VkMacOSSurfaceCreateInfoMVK &()
+    {
+      return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this);
+    }
+
     bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14435,11 +15339,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineViewportWScalingStateCreateInfoNV&() const
+    operator VkPipelineViewportWScalingStateCreateInfoNV const&() const
     {
       return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(this);
     }
 
+    operator VkPipelineViewportWScalingStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this);
+    }
+
     bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14494,11 +15403,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceDiscardRectanglePropertiesEXT&() const
+    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14522,11 +15436,16 @@ public:
 
   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
   {
-    operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const
+    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
     }
 
+    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
+    }
+
     bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14577,11 +15496,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceSurfaceInfo2KHR&() const
+    operator VkPhysicalDeviceSurfaceInfo2KHR const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(this);
     }
 
+    operator VkPhysicalDeviceSurfaceInfo2KHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this);
+    }
+
     bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14605,11 +15529,16 @@ public:
 
   struct DisplayPlaneProperties2KHR
   {
-    operator const VkDisplayPlaneProperties2KHR&() const
+    operator VkDisplayPlaneProperties2KHR const&() const
     {
       return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(this);
     }
 
+    operator VkDisplayPlaneProperties2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this);
+    }
+
     bool operator==( DisplayPlaneProperties2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14633,11 +15562,16 @@ public:
 
   struct DisplayModeProperties2KHR
   {
-    operator const VkDisplayModeProperties2KHR&() const
+    operator VkDisplayModeProperties2KHR const&() const
     {
       return *reinterpret_cast<const VkDisplayModeProperties2KHR*>(this);
     }
 
+    operator VkDisplayModeProperties2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayModeProperties2KHR*>(this);
+    }
+
     bool operator==( DisplayModeProperties2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14696,11 +15630,16 @@ public:
       return *this;
     }
 
-    operator const VkDisplayPlaneInfo2KHR&() const
+    operator VkDisplayPlaneInfo2KHR const&() const
     {
       return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(this);
     }
 
+    operator VkDisplayPlaneInfo2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this);
+    }
+
     bool operator==( DisplayPlaneInfo2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14777,11 +15716,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDevice16BitStorageFeatures&() const
+    operator VkPhysicalDevice16BitStorageFeatures const&() const
     {
       return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(this);
     }
 
+    operator VkPhysicalDevice16BitStorageFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this);
+    }
+
     bool operator==( PhysicalDevice16BitStorageFeatures const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14840,11 +15784,16 @@ public:
       return *this;
     }
 
-    operator const VkBufferMemoryRequirementsInfo2&() const
+    operator VkBufferMemoryRequirementsInfo2 const&() const
     {
       return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(this);
     }
 
+    operator VkBufferMemoryRequirementsInfo2 &()
+    {
+      return *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this);
+    }
+
     bool operator==( BufferMemoryRequirementsInfo2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14897,11 +15846,16 @@ public:
       return *this;
     }
 
-    operator const VkImageMemoryRequirementsInfo2&() const
+    operator VkImageMemoryRequirementsInfo2 const&() const
     {
       return *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(this);
     }
 
+    operator VkImageMemoryRequirementsInfo2 &()
+    {
+      return *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this);
+    }
+
     bool operator==( ImageMemoryRequirementsInfo2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14954,11 +15908,16 @@ public:
       return *this;
     }
 
-    operator const VkImageSparseMemoryRequirementsInfo2&() const
+    operator VkImageSparseMemoryRequirementsInfo2 const&() const
     {
       return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(this);
     }
 
+    operator VkImageSparseMemoryRequirementsInfo2 &()
+    {
+      return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this);
+    }
+
     bool operator==( ImageSparseMemoryRequirementsInfo2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -14984,11 +15943,16 @@ public:
 
   struct MemoryRequirements2
   {
-    operator const VkMemoryRequirements2&() const
+    operator VkMemoryRequirements2 const&() const
     {
       return *reinterpret_cast<const VkMemoryRequirements2*>(this);
     }
 
+    operator VkMemoryRequirements2 &()
+    {
+      return *reinterpret_cast<VkMemoryRequirements2*>(this);
+    }
+
     bool operator==( MemoryRequirements2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15014,11 +15978,16 @@ public:
 
   struct MemoryDedicatedRequirements
   {
-    operator const VkMemoryDedicatedRequirements&() const
+    operator VkMemoryDedicatedRequirements const&() const
     {
       return *reinterpret_cast<const VkMemoryDedicatedRequirements*>(this);
     }
 
+    operator VkMemoryDedicatedRequirements &()
+    {
+      return *reinterpret_cast<VkMemoryDedicatedRequirements*>(this);
+    }
+
     bool operator==( MemoryDedicatedRequirements const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15081,11 +16050,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryDedicatedAllocateInfo&() const
+    operator VkMemoryDedicatedAllocateInfo const&() const
     {
       return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(this);
     }
 
+    operator VkMemoryDedicatedAllocateInfo &()
+    {
+      return *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this);
+    }
+
     bool operator==( MemoryDedicatedAllocateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15140,11 +16114,16 @@ public:
       return *this;
     }
 
-    operator const VkSamplerYcbcrConversionInfo&() const
+    operator VkSamplerYcbcrConversionInfo const&() const
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(this);
     }
 
+    operator VkSamplerYcbcrConversionInfo &()
+    {
+      return *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this);
+    }
+
     bool operator==( SamplerYcbcrConversionInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15197,11 +16176,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceSamplerYcbcrConversionFeatures&() const
+    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
     }
 
+    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
+    }
+
     bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15227,11 +16211,16 @@ public:
 
   struct SamplerYcbcrConversionImageFormatProperties
   {
-    operator const VkSamplerYcbcrConversionImageFormatProperties&() const
+    operator VkSamplerYcbcrConversionImageFormatProperties const&() const
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(this);
     }
 
+    operator VkSamplerYcbcrConversionImageFormatProperties &()
+    {
+      return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this);
+    }
+
     bool operator==( SamplerYcbcrConversionImageFormatProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15257,11 +16246,16 @@ public:
 
   struct TextureLODGatherFormatPropertiesAMD
   {
-    operator const VkTextureLODGatherFormatPropertiesAMD&() const
+    operator VkTextureLODGatherFormatPropertiesAMD const&() const
     {
       return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this);
     }
 
+    operator VkTextureLODGatherFormatPropertiesAMD &()
+    {
+      return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this);
+    }
+
     bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15312,11 +16306,16 @@ public:
       return *this;
     }
 
-    operator const VkProtectedSubmitInfo&() const
+    operator VkProtectedSubmitInfo const&() const
     {
       return *reinterpret_cast<const VkProtectedSubmitInfo*>(this);
     }
 
+    operator VkProtectedSubmitInfo &()
+    {
+      return *reinterpret_cast<VkProtectedSubmitInfo*>(this);
+    }
+
     bool operator==( ProtectedSubmitInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15367,11 +16366,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceProtectedMemoryFeatures&() const
+    operator VkPhysicalDeviceProtectedMemoryFeatures const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(this);
     }
 
+    operator VkPhysicalDeviceProtectedMemoryFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this);
+    }
+
     bool operator==( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15422,11 +16426,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceProtectedMemoryProperties&() const
+    operator VkPhysicalDeviceProtectedMemoryProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(this);
     }
 
+    operator VkPhysicalDeviceProtectedMemoryProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceProtectedMemoryProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15493,11 +16502,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineCoverageToColorStateCreateInfoNV&() const
+    operator VkPipelineCoverageToColorStateCreateInfoNV const&() const
     {
       return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(this);
     }
 
+    operator VkPipelineCoverageToColorStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this);
+    }
+
     bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15525,11 +16539,16 @@ public:
 
   struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
   {
-    operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const
+    operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15555,11 +16574,16 @@ public:
 
   struct MultisamplePropertiesEXT
   {
-    operator const VkMultisamplePropertiesEXT&() const
+    operator VkMultisamplePropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkMultisamplePropertiesEXT*>(this);
     }
 
+    operator VkMultisamplePropertiesEXT &()
+    {
+      return *reinterpret_cast<VkMultisamplePropertiesEXT*>(this);
+    }
+
     bool operator==( MultisamplePropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15610,11 +16634,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const
+    operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15638,11 +16667,16 @@ public:
 
   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
   {
-    operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const
+    operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15676,11 +16710,16 @@ public:
 
   struct PhysicalDeviceInlineUniformBlockFeaturesEXT
   {
-    operator const VkPhysicalDeviceInlineUniformBlockFeaturesEXT&() const
+    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15706,11 +16745,16 @@ public:
 
   struct PhysicalDeviceInlineUniformBlockPropertiesEXT
   {
-    operator const VkPhysicalDeviceInlineUniformBlockPropertiesEXT&() const
+    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15777,11 +16821,16 @@ public:
       return *this;
     }
 
-    operator const VkWriteDescriptorSetInlineUniformBlockEXT&() const
+    operator VkWriteDescriptorSetInlineUniformBlockEXT const&() const
     {
       return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
     }
 
+    operator VkWriteDescriptorSetInlineUniformBlockEXT &()
+    {
+      return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
+    }
+
     bool operator==( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15834,11 +16883,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorPoolInlineUniformBlockCreateInfoEXT&() const
+    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
     }
 
+    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
+    }
+
     bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15897,11 +16951,16 @@ public:
       return *this;
     }
 
-    operator const VkImageFormatListCreateInfoKHR&() const
+    operator VkImageFormatListCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(this);
     }
 
+    operator VkImageFormatListCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this);
+    }
+
     bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -15970,11 +17029,16 @@ public:
       return *this;
     }
 
-    operator const VkValidationCacheCreateInfoEXT&() const
+    operator VkValidationCacheCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(this);
     }
 
+    operator VkValidationCacheCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this);
+    }
+
     bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16029,11 +17093,16 @@ public:
       return *this;
     }
 
-    operator const VkShaderModuleValidationCacheCreateInfoEXT&() const
+    operator VkShaderModuleValidationCacheCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(this);
     }
 
+    operator VkShaderModuleValidationCacheCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this);
+    }
+
     bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16057,11 +17126,16 @@ public:
 
   struct PhysicalDeviceMaintenance3Properties
   {
-    operator const VkPhysicalDeviceMaintenance3Properties&() const
+    operator VkPhysicalDeviceMaintenance3Properties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(this);
     }
 
+    operator VkPhysicalDeviceMaintenance3Properties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this);
+    }
+
     bool operator==( PhysicalDeviceMaintenance3Properties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16089,11 +17163,16 @@ public:
 
   struct DescriptorSetLayoutSupport
   {
-    operator const VkDescriptorSetLayoutSupport&() const
+    operator VkDescriptorSetLayoutSupport const&() const
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>(this);
     }
 
+    operator VkDescriptorSetLayoutSupport &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this);
+    }
+
     bool operator==( DescriptorSetLayoutSupport const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16146,11 +17225,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceShaderDrawParameterFeatures&() const
+    operator VkPhysicalDeviceShaderDrawParameterFeatures const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
     }
 
+    operator VkPhysicalDeviceShaderDrawParameterFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
+    }
+
     bool operator==( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16209,11 +17293,16 @@ public:
       return *this;
     }
 
-    operator const VkDebugUtilsLabelEXT&() const
+    operator VkDebugUtilsLabelEXT const&() const
     {
       return *reinterpret_cast<const VkDebugUtilsLabelEXT*>(this);
     }
 
+    operator VkDebugUtilsLabelEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsLabelEXT*>(this);
+    }
+
     bool operator==( DebugUtilsLabelEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16266,11 +17355,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryHostPointerPropertiesEXT&() const
+    operator VkMemoryHostPointerPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(this);
     }
 
+    operator VkMemoryHostPointerPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this);
+    }
+
     bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16321,11 +17415,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&() const
+    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16440,11 +17539,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&() const
+    operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16484,11 +17588,16 @@ public:
 
   struct PhysicalDeviceShaderCorePropertiesAMD
   {
-    operator const VkPhysicalDeviceShaderCorePropertiesAMD&() const
+    operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
     }
 
+    operator VkPhysicalDeviceShaderCorePropertiesAMD &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
+    }
+
     bool operator==( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16717,11 +17826,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceDescriptorIndexingFeaturesEXT&() const
+    operator VkPhysicalDeviceDescriptorIndexingFeaturesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceDescriptorIndexingFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceDescriptorIndexingFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16783,11 +17897,16 @@ public:
 
   struct PhysicalDeviceDescriptorIndexingPropertiesEXT
   {
-    operator const VkPhysicalDeviceDescriptorIndexingPropertiesEXT&() const
+    operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceDescriptorIndexingPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16890,11 +18009,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT&() const
+    operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
     }
 
+    operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
+    }
+
     bool operator==( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16920,11 +18044,16 @@ public:
 
   struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
   {
-    operator const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT&() const
+    operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const
     {
       return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
     }
 
+    operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
+    }
+
     bool operator==( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -16968,11 +18097,16 @@ public:
       return *this;
     }
 
-    operator const VkSubpassEndInfoKHR&() const
+    operator VkSubpassEndInfoKHR const&() const
     {
       return *reinterpret_cast<const VkSubpassEndInfoKHR*>(this);
     }
 
+    operator VkSubpassEndInfoKHR &()
+    {
+      return *reinterpret_cast<VkSubpassEndInfoKHR*>(this);
+    }
+
     bool operator==( SubpassEndInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17029,11 +18163,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineVertexInputDivisorStateCreateInfoEXT&() const
+    operator VkPipelineVertexInputDivisorStateCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
     }
 
+    operator VkPipelineVertexInputDivisorStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
+    }
+
     bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17086,11 +18225,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT&() const
+    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17142,11 +18286,16 @@ public:
       return *this;
     }
 
-    operator const VkImportAndroidHardwareBufferInfoANDROID&() const
+    operator VkImportAndroidHardwareBufferInfoANDROID const&() const
     {
       return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(this);
     }
 
+    operator VkImportAndroidHardwareBufferInfoANDROID &()
+    {
+      return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this);
+    }
+
     bool operator==( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17172,11 +18321,16 @@ public:
 #ifdef VK_USE_PLATFORM_ANDROID_ANDROID
   struct AndroidHardwareBufferUsageANDROID
   {
-    operator const VkAndroidHardwareBufferUsageANDROID&() const
+    operator VkAndroidHardwareBufferUsageANDROID const&() const
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(this);
     }
 
+    operator VkAndroidHardwareBufferUsageANDROID &()
+    {
+      return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this);
+    }
+
     bool operator==( AndroidHardwareBufferUsageANDROID const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17202,11 +18356,16 @@ public:
 #ifdef VK_USE_PLATFORM_ANDROID_ANDROID
   struct AndroidHardwareBufferPropertiesANDROID
   {
-    operator const VkAndroidHardwareBufferPropertiesANDROID&() const
+    operator VkAndroidHardwareBufferPropertiesANDROID const&() const
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(this);
     }
 
+    operator VkAndroidHardwareBufferPropertiesANDROID &()
+    {
+      return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this);
+    }
+
     bool operator==( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17261,11 +18420,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryGetAndroidHardwareBufferInfoANDROID&() const
+    operator VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const
     {
       return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
     }
 
+    operator VkMemoryGetAndroidHardwareBufferInfoANDROID &()
+    {
+      return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
+    }
+
     bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17317,11 +18481,16 @@ public:
       return *this;
     }
 
-    operator const VkCommandBufferInheritanceConditionalRenderingInfoEXT&() const
+    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const&() const
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
     }
 
+    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &()
+    {
+      return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
+    }
+
     bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17373,11 +18542,16 @@ public:
       return *this;
     }
 
-    operator const VkExternalFormatANDROID&() const
+    operator VkExternalFormatANDROID const&() const
     {
       return *reinterpret_cast<const VkExternalFormatANDROID*>(this);
     }
 
+    operator VkExternalFormatANDROID &()
+    {
+      return *reinterpret_cast<VkExternalFormatANDROID*>(this);
+    }
+
     bool operator==( ExternalFormatANDROID const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17445,11 +18619,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDevice8BitStorageFeaturesKHR&() const
+    operator VkPhysicalDevice8BitStorageFeaturesKHR const&() const
     {
       return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
     }
 
+    operator VkPhysicalDevice8BitStorageFeaturesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
+    }
+
     bool operator==( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17512,11 +18691,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceConditionalRenderingFeaturesEXT&() const
+    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17542,11 +18726,16 @@ public:
 
   struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
   {
-    operator const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR&() const
+    operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
     }
 
+    operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
+    }
+
     bool operator==( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17607,11 +18796,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT&() const
+    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17664,11 +18858,16 @@ public:
       return *this;
     }
 
-    operator const VkImageViewASTCDecodeModeEXT&() const
+    operator VkImageViewASTCDecodeModeEXT const&() const
     {
       return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(this);
     }
 
+    operator VkImageViewASTCDecodeModeEXT &()
+    {
+      return *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this);
+    }
+
     bool operator==( ImageViewASTCDecodeModeEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17719,11 +18918,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceASTCDecodeFeaturesEXT&() const
+    operator VkPhysicalDeviceASTCDecodeFeaturesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceASTCDecodeFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -17745,581 +18949,2089 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
 
-  enum class SubpassContents
-  {
-    eInline = VK_SUBPASS_CONTENTS_INLINE,
-    eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
-  };
-
-  struct SubpassBeginInfoKHR
+  struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
   {
-    SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
-      : contents( contents_ )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = 0 )
+      : representativeFragmentTest( representativeFragmentTest_ )
     {
     }
 
-    SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
     }
 
-    SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
       return *this;
     }
-    SubpassBeginInfoKHR& setPNext( const void* pNext_ )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    SubpassBeginInfoKHR& setContents( SubpassContents contents_ )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ )
     {
-      contents = contents_;
+      representativeFragmentTest = representativeFragmentTest_;
       return *this;
     }
 
-    operator const VkSubpassBeginInfoKHR&() const
+    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const&() const
     {
-      return *reinterpret_cast<const VkSubpassBeginInfoKHR*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
     }
 
-    bool operator==( SubpassBeginInfoKHR const& rhs ) const
+    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
+    }
+
+    bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( contents == rhs.contents );
+          && ( representativeFragmentTest == rhs.representativeFragmentTest );
     }
 
-    bool operator!=( SubpassBeginInfoKHR const& rhs ) const
+    bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eSubpassBeginInfoKHR;
+    StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
 
   public:
-    const void* pNext = nullptr;
-    SubpassContents contents;
+    void* pNext = nullptr;
+    Bool32 representativeFragmentTest;
   };
-  static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
 
-  struct PresentInfoKHR
+  struct PipelineRepresentativeFragmentTestStateCreateInfoNV
   {
-    PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
-                    const Semaphore* pWaitSemaphores_ = nullptr,
-                    uint32_t swapchainCount_ = 0,
-                    const SwapchainKHR* pSwapchains_ = nullptr,
-                    const uint32_t* pImageIndices_ = nullptr,
-                    Result* pResults_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , swapchainCount( swapchainCount_ )
-      , pSwapchains( pSwapchains_ )
-      , pImageIndices( pImageIndices_ )
-      , pResults( pResults_ )
+    PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 )
+      : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
     {
     }
 
-    PresentInfoKHR( VkPresentInfoKHR const & rhs )
+    PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+      memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
     }
 
-    PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+    PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+      memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
       return *this;
     }
-    PresentInfoKHR& setPNext( const void* pNext_ )
+    PipelineRepresentativeFragmentTestStateCreateInfoNV& setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+    PipelineRepresentativeFragmentTestStateCreateInfoNV& setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ )
     {
-      waitSemaphoreCount = waitSemaphoreCount_;
+      representativeFragmentTestEnable = representativeFragmentTestEnable_;
       return *this;
     }
 
-    PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const&() const
     {
-      pWaitSemaphores = pWaitSemaphores_;
-      return *this;
+      return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
     }
 
-    PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
+    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &()
     {
-      swapchainCount = swapchainCount_;
-      return *this;
+      return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
     }
 
-    PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
+    bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
     {
-      pSwapchains = pSwapchains_;
-      return *this;
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
     }
 
-    PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
+    bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
     {
-      pImageIndices = pImageIndices_;
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 representativeFragmentTestEnable;
+  };
+  static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceExclusiveScissorFeaturesNV
+  {
+    PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = 0 )
+      : exclusiveScissor( exclusiveScissor_ )
+    {
+    }
+
+    PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
+    }
+
+    PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
+      return *this;
+    }
+    PhysicalDeviceExclusiveScissorFeaturesNV& setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
       return *this;
     }
 
-    PresentInfoKHR& setPResults( Result* pResults_ )
+    PhysicalDeviceExclusiveScissorFeaturesNV& setExclusiveScissor( Bool32 exclusiveScissor_ )
     {
-      pResults = pResults_;
+      exclusiveScissor = exclusiveScissor_;
       return *this;
     }
 
-    operator const VkPresentInfoKHR&() const
+    operator VkPhysicalDeviceExclusiveScissorFeaturesNV const&() const
     {
-      return *reinterpret_cast<const VkPresentInfoKHR*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
     }
 
-    bool operator==( PresentInfoKHR const& rhs ) const
+    operator VkPhysicalDeviceExclusiveScissorFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
+    }
+
+    bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphores == rhs.pWaitSemaphores )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pSwapchains == rhs.pSwapchains )
-          && ( pImageIndices == rhs.pImageIndices )
-          && ( pResults == rhs.pResults );
+          && ( exclusiveScissor == rhs.exclusiveScissor );
     }
 
-    bool operator!=( PresentInfoKHR const& rhs ) const
+    bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePresentInfoKHR;
+    StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
 
   public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    uint32_t swapchainCount;
-    const SwapchainKHR* pSwapchains;
-    const uint32_t* pImageIndices;
-    Result* pResults;
-  };
-  static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class DynamicState
-  {
-    eViewport = VK_DYNAMIC_STATE_VIEWPORT,
-    eScissor = VK_DYNAMIC_STATE_SCISSOR,
-    eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
-    eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
-    eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-    eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
-    eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-    eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
-    eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-    eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
-    eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
-    eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT
+    void* pNext = nullptr;
+    Bool32 exclusiveScissor;
   };
+  static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" );
 
-  struct PipelineDynamicStateCreateInfo
+  struct PipelineViewportExclusiveScissorStateCreateInfoNV
   {
-    PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
-                                    uint32_t dynamicStateCount_ = 0,
-                                    const DynamicState* pDynamicStates_ = nullptr )
-      : flags( flags_ )
-      , dynamicStateCount( dynamicStateCount_ )
-      , pDynamicStates( pDynamicStates_ )
+    PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
+                                                       const Rect2D* pExclusiveScissors_ = nullptr )
+      : exclusiveScissorCount( exclusiveScissorCount_ )
+      , pExclusiveScissors( pExclusiveScissors_ )
     {
     }
 
-    PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
+    PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
+      memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
     }
 
-    PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
+    PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
+      memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
       return *this;
     }
-    PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
+    PipelineViewportExclusiveScissorStateCreateInfoNV& setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
+    PipelineViewportExclusiveScissorStateCreateInfoNV& setExclusiveScissorCount( uint32_t exclusiveScissorCount_ )
     {
-      flags = flags_;
+      exclusiveScissorCount = exclusiveScissorCount_;
       return *this;
     }
 
-    PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
+    PipelineViewportExclusiveScissorStateCreateInfoNV& setPExclusiveScissors( const Rect2D* pExclusiveScissors_ )
     {
-      dynamicStateCount = dynamicStateCount_;
+      pExclusiveScissors = pExclusiveScissors_;
       return *this;
     }
 
-    PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
+    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const&() const
     {
-      pDynamicStates = pDynamicStates_;
-      return *this;
+      return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
     }
 
-    operator const VkPipelineDynamicStateCreateInfo&() const
+    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &()
     {
-      return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
+      return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
     }
 
-    bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
+    bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( dynamicStateCount == rhs.dynamicStateCount )
-          && ( pDynamicStates == rhs.pDynamicStates );
+          && ( exclusiveScissorCount == rhs.exclusiveScissorCount )
+          && ( pExclusiveScissors == rhs.pExclusiveScissors );
     }
 
-    bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
+    bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
+    StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
 
   public:
     const void* pNext = nullptr;
-    PipelineDynamicStateCreateFlags flags;
-    uint32_t dynamicStateCount;
-    const DynamicState* pDynamicStates;
-  };
-  static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class DescriptorUpdateTemplateType
-  {
-    eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
-    eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
-    ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
+    uint32_t exclusiveScissorCount;
+    const Rect2D* pExclusiveScissors;
   };
+  static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
 
-  struct DescriptorUpdateTemplateCreateInfo
+  struct PhysicalDeviceCornerSampledImageFeaturesNV
   {
-    DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
-                                        uint32_t descriptorUpdateEntryCount_ = 0,
-                                        const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
-                                        DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
-                                        DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
-                                        PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
-                                        PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                        uint32_t set_ = 0 )
-      : flags( flags_ )
-      , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
-      , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
-      , templateType( templateType_ )
-      , descriptorSetLayout( descriptorSetLayout_ )
-      , pipelineBindPoint( pipelineBindPoint_ )
-      , pipelineLayout( pipelineLayout_ )
-      , set( set_ )
+    PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = 0 )
+      : cornerSampledImage( cornerSampledImage_ )
     {
     }
 
-    DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+    PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
     }
 
-    DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+    PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
       return *this;
     }
-    DescriptorUpdateTemplateCreateInfo& setPNext( void* pNext_ )
+    PhysicalDeviceCornerSampledImageFeaturesNV& setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo& setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
+    PhysicalDeviceCornerSampledImageFeaturesNV& setCornerSampledImage( Bool32 cornerSampledImage_ )
     {
-      flags = flags_;
+      cornerSampledImage = cornerSampledImage_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
+    operator VkPhysicalDeviceCornerSampledImageFeaturesNV const&() const
     {
-      descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
     }
 
-    DescriptorUpdateTemplateCreateInfo& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
+    operator VkPhysicalDeviceCornerSampledImageFeaturesNV &()
     {
-      pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
     }
 
-    DescriptorUpdateTemplateCreateInfo& setTemplateType( DescriptorUpdateTemplateType templateType_ )
+    bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
     {
-      templateType = templateType_;
-      return *this;
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( cornerSampledImage == rhs.cornerSampledImage );
     }
 
-    DescriptorUpdateTemplateCreateInfo& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
+    bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
     {
-      descriptorSetLayout = descriptorSetLayout_;
-      return *this;
+      return !operator==( rhs );
     }
 
-    DescriptorUpdateTemplateCreateInfo& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 cornerSampledImage;
+  };
+  static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
+  {
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV( Bool32 computeDerivativeGroupQuads_ = 0,
+                                                      Bool32 computeDerivativeGroupLinear_ = 0 )
+      : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
+      , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
     {
-      pipelineBindPoint = pipelineBindPoint_;
+    }
+
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
+    }
+
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
+      return *this;
+    }
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV& setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo& setPipelineLayout( PipelineLayout pipelineLayout_ )
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV& setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ )
     {
-      pipelineLayout = pipelineLayout_;
+      computeDerivativeGroupQuads = computeDerivativeGroupQuads_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo& setSet( uint32_t set_ )
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV& setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ )
     {
-      set = set_;
+      computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
       return *this;
     }
 
-    operator const VkDescriptorUpdateTemplateCreateInfo&() const
+    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const&() const
     {
-      return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
     }
 
-    bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
+    }
+
+    bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
-          && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
-          && ( templateType == rhs.templateType )
-          && ( descriptorSetLayout == rhs.descriptorSetLayout )
-          && ( pipelineBindPoint == rhs.pipelineBindPoint )
-          && ( pipelineLayout == rhs.pipelineLayout )
-          && ( set == rhs.set );
+          && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads )
+          && ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear );
     }
 
-    bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+    bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
+    StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
 
   public:
     void* pNext = nullptr;
-    DescriptorUpdateTemplateCreateFlags flags;
-    uint32_t descriptorUpdateEntryCount;
-    const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
-    DescriptorUpdateTemplateType templateType;
-    DescriptorSetLayout descriptorSetLayout;
-    PipelineBindPoint pipelineBindPoint;
-    PipelineLayout pipelineLayout;
-    uint32_t set;
-  };
-  static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
-
-  using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
-
-  enum class ObjectType
-  {
-    eUnknown = VK_OBJECT_TYPE_UNKNOWN,
-    eInstance = VK_OBJECT_TYPE_INSTANCE,
-    ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
-    eDevice = VK_OBJECT_TYPE_DEVICE,
-    eQueue = VK_OBJECT_TYPE_QUEUE,
-    eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
-    eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
-    eFence = VK_OBJECT_TYPE_FENCE,
-    eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
-    eBuffer = VK_OBJECT_TYPE_BUFFER,
-    eImage = VK_OBJECT_TYPE_IMAGE,
-    eEvent = VK_OBJECT_TYPE_EVENT,
-    eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
-    eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
-    eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
-    eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
-    ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
-    ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
-    eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
-    ePipeline = VK_OBJECT_TYPE_PIPELINE,
-    eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
-    eSampler = VK_OBJECT_TYPE_SAMPLER,
-    eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
-    eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
-    eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
-    eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
-    eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
-    eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
-    eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
-    eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
-    eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
-    eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-    eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
-    eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
-    eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
-    eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
-    eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX,
-    eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,
-    eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT
+    Bool32 computeDerivativeGroupQuads;
+    Bool32 computeDerivativeGroupLinear;
   };
+  static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
 
-  struct DebugUtilsObjectNameInfoEXT
+  struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
   {
-    DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
-                                 uint64_t objectHandle_ = 0,
-                                 const char* pObjectName_ = nullptr )
-      : objectType( objectType_ )
-      , objectHandle( objectHandle_ )
-      , pObjectName( pObjectName_ )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( Bool32 fragmentShaderBarycentric_ = 0 )
+      : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
     {
     }
 
-    DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
     }
 
-    DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
       return *this;
     }
-    DebugUtilsObjectNameInfoEXT& setPNext( const void* pNext_ )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV& setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DebugUtilsObjectNameInfoEXT& setObjectType( ObjectType objectType_ )
-    {
-      objectType = objectType_;
-      return *this;
-    }
-
-    DebugUtilsObjectNameInfoEXT& setObjectHandle( uint64_t objectHandle_ )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV& setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ )
     {
-      objectHandle = objectHandle_;
+      fragmentShaderBarycentric = fragmentShaderBarycentric_;
       return *this;
     }
 
-    DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
+    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const&() const
     {
-      pObjectName = pObjectName_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
     }
 
-    operator const VkDebugUtilsObjectNameInfoEXT&() const
+    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &()
     {
-      return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
     }
 
-    bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const
+    bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( objectType == rhs.objectType )
-          && ( objectHandle == rhs.objectHandle )
-          && ( pObjectName == rhs.pObjectName );
+          && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
     }
 
-    bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
+    StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
 
   public:
-    const void* pNext = nullptr;
-    ObjectType objectType;
-    uint64_t objectHandle;
-    const char* pObjectName;
+    void* pNext = nullptr;
+    Bool32 fragmentShaderBarycentric;
   };
-  static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
 
-  struct DebugUtilsObjectTagInfoEXT
+  struct PhysicalDeviceShaderImageFootprintFeaturesNV
   {
-    DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
-                                uint64_t objectHandle_ = 0,
-                                uint64_t tagName_ = 0,
-                                size_t tagSize_ = 0,
-                                const void* pTag_ = nullptr )
-      : objectType( objectType_ )
-      , objectHandle( objectHandle_ )
-      , tagName( tagName_ )
-      , tagSize( tagSize_ )
-      , pTag( pTag_ )
+    PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 )
+      : imageFootprint( imageFootprint_ )
     {
     }
 
-    DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
+    PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
     }
 
-    DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
+    PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
       return *this;
     }
-    DebugUtilsObjectTagInfoEXT& setPNext( const void* pNext_ )
+    PhysicalDeviceShaderImageFootprintFeaturesNV& setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DebugUtilsObjectTagInfoEXT& setObjectType( ObjectType objectType_ )
+    PhysicalDeviceShaderImageFootprintFeaturesNV& setImageFootprint( Bool32 imageFootprint_ )
     {
-      objectType = objectType_;
+      imageFootprint = imageFootprint_;
       return *this;
     }
 
-    DebugUtilsObjectTagInfoEXT& setObjectHandle( uint64_t objectHandle_ )
+    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const&() const
     {
-      objectHandle = objectHandle_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
     }
 
-    DebugUtilsObjectTagInfoEXT& setTagName( uint64_t tagName_ )
+    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &()
     {
-      tagName = tagName_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
     }
 
-    DebugUtilsObjectTagInfoEXT& setTagSize( size_t tagSize_ )
+    bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
     {
-      tagSize = tagSize_;
-      return *this;
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( imageFootprint == rhs.imageFootprint );
     }
 
-    DebugUtilsObjectTagInfoEXT& setPTag( const void* pTag_ )
+    bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
     {
-      pTag = pTag_;
-      return *this;
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 imageFootprint;
+  };
+  static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShadingRateImageFeaturesNV
+  {
+    PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0,
+                                              Bool32 shadingRateCoarseSampleOrder_ = 0 )
+      : shadingRateImage( shadingRateImage_ )
+      , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
+    {
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
+      return *this;
+    }
+    PhysicalDeviceShadingRateImageFeaturesNV& setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV& setShadingRateImage( Bool32 shadingRateImage_ )
+    {
+      shadingRateImage = shadingRateImage_;
+      return *this;
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV& setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ )
+    {
+      shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceShadingRateImageFeaturesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
+    }
+
+    operator VkPhysicalDeviceShadingRateImageFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
+    }
+
+    bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shadingRateImage == rhs.shadingRateImage )
+          && ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder );
+    }
+
+    bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 shadingRateImage;
+    Bool32 shadingRateCoarseSampleOrder;
+  };
+  static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShadingRateImagePropertiesNV
+  {
+    operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
+    }
+
+    operator VkPhysicalDeviceShadingRateImagePropertiesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
+    }
+
+    bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shadingRateTexelSize == rhs.shadingRateTexelSize )
+          && ( shadingRatePaletteSize == rhs.shadingRatePaletteSize )
+          && ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples );
+    }
+
+    bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
+
+  public:
+    void* pNext = nullptr;
+    Extent2D shadingRateTexelSize;
+    uint32_t shadingRatePaletteSize;
+    uint32_t shadingRateMaxCoarseSamples;
+  };
+  static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMeshShaderFeaturesNV
+  {
+    PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = 0,
+                                        Bool32 meshShader_ = 0 )
+      : taskShader( taskShader_ )
+      , meshShader( meshShader_ )
+    {
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
+      return *this;
+    }
+    PhysicalDeviceMeshShaderFeaturesNV& setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV& setTaskShader( Bool32 taskShader_ )
+    {
+      taskShader = taskShader_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV& setMeshShader( Bool32 meshShader_ )
+    {
+      meshShader = meshShader_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceMeshShaderFeaturesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
+    }
+
+    operator VkPhysicalDeviceMeshShaderFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
+    }
+
+    bool operator==( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( taskShader == rhs.taskShader )
+          && ( meshShader == rhs.meshShader );
+    }
+
+    bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 taskShader;
+    Bool32 meshShader;
+  };
+  static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMeshShaderPropertiesNV
+  {
+    PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0,
+                                          uint32_t maxTaskWorkGroupInvocations_ = 0,
+                                          std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = { { 0, 0, 0 } },
+                                          uint32_t maxTaskTotalMemorySize_ = 0,
+                                          uint32_t maxTaskOutputCount_ = 0,
+                                          uint32_t maxMeshWorkGroupInvocations_ = 0,
+                                          std::array<uint32_t,3> const& maxMeshWorkGroupSize_ = { { 0, 0, 0 } },
+                                          uint32_t maxMeshTotalMemorySize_ = 0,
+                                          uint32_t maxMeshOutputVertices_ = 0,
+                                          uint32_t maxMeshOutputPrimitives_ = 0,
+                                          uint32_t maxMeshMultiviewViewCount_ = 0,
+                                          uint32_t meshOutputPerVertexGranularity_ = 0,
+                                          uint32_t meshOutputPerPrimitiveGranularity_ = 0 )
+      : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
+      , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
+      , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
+      , maxTaskOutputCount( maxTaskOutputCount_ )
+      , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
+      , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
+      , maxMeshOutputVertices( maxMeshOutputVertices_ )
+      , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
+      , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
+      , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
+      , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
+    {
+      memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+      memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
+      return *this;
+    }
+    PhysicalDeviceMeshShaderPropertiesNV& setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxDrawMeshTasksCount( uint32_t maxDrawMeshTasksCount_ )
+    {
+      maxDrawMeshTasksCount = maxDrawMeshTasksCount_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskWorkGroupInvocations( uint32_t maxTaskWorkGroupInvocations_ )
+    {
+      maxTaskWorkGroupInvocations = maxTaskWorkGroupInvocations_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskWorkGroupSize( std::array<uint32_t,3> maxTaskWorkGroupSize_ )
+    {
+      memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskTotalMemorySize( uint32_t maxTaskTotalMemorySize_ )
+    {
+      maxTaskTotalMemorySize = maxTaskTotalMemorySize_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskOutputCount( uint32_t maxTaskOutputCount_ )
+    {
+      maxTaskOutputCount = maxTaskOutputCount_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshWorkGroupInvocations( uint32_t maxMeshWorkGroupInvocations_ )
+    {
+      maxMeshWorkGroupInvocations = maxMeshWorkGroupInvocations_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshWorkGroupSize( std::array<uint32_t,3> maxMeshWorkGroupSize_ )
+    {
+      memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshTotalMemorySize( uint32_t maxMeshTotalMemorySize_ )
+    {
+      maxMeshTotalMemorySize = maxMeshTotalMemorySize_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshOutputVertices( uint32_t maxMeshOutputVertices_ )
+    {
+      maxMeshOutputVertices = maxMeshOutputVertices_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshOutputPrimitives( uint32_t maxMeshOutputPrimitives_ )
+    {
+      maxMeshOutputPrimitives = maxMeshOutputPrimitives_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshMultiviewViewCount( uint32_t maxMeshMultiviewViewCount_ )
+    {
+      maxMeshMultiviewViewCount = maxMeshMultiviewViewCount_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMeshOutputPerVertexGranularity( uint32_t meshOutputPerVertexGranularity_ )
+    {
+      meshOutputPerVertexGranularity = meshOutputPerVertexGranularity_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& setMeshOutputPerPrimitiveGranularity( uint32_t meshOutputPerPrimitiveGranularity_ )
+    {
+      meshOutputPerPrimitiveGranularity = meshOutputPerPrimitiveGranularity_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
+    }
+
+    operator VkPhysicalDeviceMeshShaderPropertiesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
+    }
+
+    bool operator==( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount )
+          && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations )
+          && ( memcmp( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+          && ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize )
+          && ( maxTaskOutputCount == rhs.maxTaskOutputCount )
+          && ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations )
+          && ( memcmp( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+          && ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize )
+          && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices )
+          && ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives )
+          && ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount )
+          && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity )
+          && ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity );
+    }
+
+    bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t maxDrawMeshTasksCount;
+    uint32_t maxTaskWorkGroupInvocations;
+    uint32_t maxTaskWorkGroupSize[3];
+    uint32_t maxTaskTotalMemorySize;
+    uint32_t maxTaskOutputCount;
+    uint32_t maxMeshWorkGroupInvocations;
+    uint32_t maxMeshWorkGroupSize[3];
+    uint32_t maxMeshTotalMemorySize;
+    uint32_t maxMeshOutputVertices;
+    uint32_t maxMeshOutputPrimitives;
+    uint32_t maxMeshMultiviewViewCount;
+    uint32_t meshOutputPerVertexGranularity;
+    uint32_t meshOutputPerPrimitiveGranularity;
+  };
+  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 )
+      : vertexData( vertexData_ )
+      , vertexOffset( vertexOffset_ )
+      , vertexCount( vertexCount_ )
+      , vertexStride( vertexStride_ )
+      , vertexFormat( vertexFormat_ )
+      , indexData( indexData_ )
+      , indexOffset( indexOffset_ )
+      , indexCount( indexCount_ )
+      , indexType( indexType_ )
+      , transformData( transformData_ )
+      , transformOffset( transformOffset_ )
+    {
+    }
+
+    GeometryTrianglesNVX( VkGeometryTrianglesNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryTrianglesNVX ) );
+    }
+
+    GeometryTrianglesNVX& operator=( VkGeometryTrianglesNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryTrianglesNVX ) );
+      return *this;
+    }
+    GeometryTrianglesNVX& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setVertexData( Buffer vertexData_ )
+    {
+      vertexData = vertexData_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setVertexOffset( DeviceSize vertexOffset_ )
+    {
+      vertexOffset = vertexOffset_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setVertexCount( uint32_t vertexCount_ )
+    {
+      vertexCount = vertexCount_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setVertexStride( DeviceSize vertexStride_ )
+    {
+      vertexStride = vertexStride_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setVertexFormat( Format vertexFormat_ )
+    {
+      vertexFormat = vertexFormat_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setIndexData( Buffer indexData_ )
+    {
+      indexData = indexData_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setIndexOffset( DeviceSize indexOffset_ )
+    {
+      indexOffset = indexOffset_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setIndexCount( uint32_t indexCount_ )
+    {
+      indexCount = indexCount_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setIndexType( IndexType indexType_ )
+    {
+      indexType = indexType_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setTransformData( Buffer transformData_ )
+    {
+      transformData = transformData_;
+      return *this;
+    }
+
+    GeometryTrianglesNVX& setTransformOffset( DeviceSize transformOffset_ )
+    {
+      transformOffset = transformOffset_;
+      return *this;
+    }
+
+    operator VkGeometryTrianglesNVX const&() const
+    {
+      return *reinterpret_cast<const VkGeometryTrianglesNVX*>(this);
+    }
+
+    operator VkGeometryTrianglesNVX &()
+    {
+      return *reinterpret_cast<VkGeometryTrianglesNVX*>(this);
+    }
+
+    bool operator==( GeometryTrianglesNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( vertexData == rhs.vertexData )
+          && ( vertexOffset == rhs.vertexOffset )
+          && ( vertexCount == rhs.vertexCount )
+          && ( vertexStride == rhs.vertexStride )
+          && ( vertexFormat == rhs.vertexFormat )
+          && ( indexData == rhs.indexData )
+          && ( indexOffset == rhs.indexOffset )
+          && ( indexCount == rhs.indexCount )
+          && ( indexType == rhs.indexType )
+          && ( transformData == rhs.transformData )
+          && ( transformOffset == rhs.transformOffset );
+    }
+
+    bool operator!=( GeometryTrianglesNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eGeometryTrianglesNVX;
+
+  public:
+    const void* pNext = nullptr;
+    Buffer vertexData;
+    DeviceSize vertexOffset;
+    uint32_t vertexCount;
+    DeviceSize vertexStride;
+    Format vertexFormat;
+    Buffer indexData;
+    DeviceSize indexOffset;
+    uint32_t indexCount;
+    IndexType indexType;
+    Buffer transformData;
+    DeviceSize transformOffset;
+  };
+  static_assert( sizeof( GeometryTrianglesNVX ) == sizeof( VkGeometryTrianglesNVX ), "struct and wrapper have different size!" );
+
+  struct GeometryAABBNVX
+  {
+    GeometryAABBNVX( Buffer aabbData_ = Buffer(),
+                     uint32_t numAABBs_ = 0,
+                     uint32_t stride_ = 0,
+                     DeviceSize offset_ = 0 )
+      : aabbData( aabbData_ )
+      , numAABBs( numAABBs_ )
+      , stride( stride_ )
+      , offset( offset_ )
+    {
+    }
+
+    GeometryAABBNVX( VkGeometryAABBNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryAABBNVX ) );
+    }
+
+    GeometryAABBNVX& operator=( VkGeometryAABBNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryAABBNVX ) );
+      return *this;
+    }
+    GeometryAABBNVX& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    GeometryAABBNVX& setAabbData( Buffer aabbData_ )
+    {
+      aabbData = aabbData_;
+      return *this;
+    }
+
+    GeometryAABBNVX& setNumAABBs( uint32_t numAABBs_ )
+    {
+      numAABBs = numAABBs_;
+      return *this;
+    }
+
+    GeometryAABBNVX& setStride( uint32_t stride_ )
+    {
+      stride = stride_;
+      return *this;
+    }
+
+    GeometryAABBNVX& setOffset( DeviceSize offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    operator VkGeometryAABBNVX const&() const
+    {
+      return *reinterpret_cast<const VkGeometryAABBNVX*>(this);
+    }
+
+    operator VkGeometryAABBNVX &()
+    {
+      return *reinterpret_cast<VkGeometryAABBNVX*>(this);
+    }
+
+    bool operator==( GeometryAABBNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( aabbData == rhs.aabbData )
+          && ( numAABBs == rhs.numAABBs )
+          && ( stride == rhs.stride )
+          && ( offset == rhs.offset );
+    }
+
+    bool operator!=( GeometryAABBNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eGeometryAabbNVX;
+
+  public:
+    const void* pNext = nullptr;
+    Buffer aabbData;
+    uint32_t numAABBs;
+    uint32_t stride;
+    DeviceSize offset;
+  };
+  static_assert( sizeof( GeometryAABBNVX ) == sizeof( VkGeometryAABBNVX ), "struct and wrapper have different size!" );
+
+  struct GeometryDataNVX
+  {
+    GeometryDataNVX( GeometryTrianglesNVX triangles_ = GeometryTrianglesNVX(),
+                     GeometryAABBNVX aabbs_ = GeometryAABBNVX() )
+      : triangles( triangles_ )
+      , aabbs( aabbs_ )
+    {
+    }
+
+    GeometryDataNVX( VkGeometryDataNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryDataNVX ) );
+    }
+
+    GeometryDataNVX& operator=( VkGeometryDataNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryDataNVX ) );
+      return *this;
+    }
+    GeometryDataNVX& setTriangles( GeometryTrianglesNVX triangles_ )
+    {
+      triangles = triangles_;
+      return *this;
+    }
+
+    GeometryDataNVX& setAabbs( GeometryAABBNVX aabbs_ )
+    {
+      aabbs = aabbs_;
+      return *this;
+    }
+
+    operator VkGeometryDataNVX const&() const
+    {
+      return *reinterpret_cast<const VkGeometryDataNVX*>(this);
+    }
+
+    operator VkGeometryDataNVX &()
+    {
+      return *reinterpret_cast<VkGeometryDataNVX*>(this);
+    }
+
+    bool operator==( GeometryDataNVX const& rhs ) const
+    {
+      return ( triangles == rhs.triangles )
+          && ( aabbs == rhs.aabbs );
+    }
+
+    bool operator!=( GeometryDataNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    GeometryTrianglesNVX triangles;
+    GeometryAABBNVX aabbs;
+  };
+  static_assert( sizeof( GeometryDataNVX ) == sizeof( VkGeometryDataNVX ), "struct and wrapper have different size!" );
+
+  struct BindAccelerationStructureMemoryInfoNVX
+  {
+    BindAccelerationStructureMemoryInfoNVX( AccelerationStructureNVX accelerationStructure_ = AccelerationStructureNVX(),
+                                            DeviceMemory memory_ = DeviceMemory(),
+                                            DeviceSize memoryOffset_ = 0,
+                                            uint32_t deviceIndexCount_ = 0,
+                                            const uint32_t* pDeviceIndices_ = nullptr )
+      : accelerationStructure( accelerationStructure_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
+      , deviceIndexCount( deviceIndexCount_ )
+      , pDeviceIndices( pDeviceIndices_ )
+    {
+    }
+
+    BindAccelerationStructureMemoryInfoNVX( VkBindAccelerationStructureMemoryInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNVX ) );
+    }
+
+    BindAccelerationStructureMemoryInfoNVX& operator=( VkBindAccelerationStructureMemoryInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNVX ) );
+      return *this;
+    }
+    BindAccelerationStructureMemoryInfoNVX& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNVX& setAccelerationStructure( AccelerationStructureNVX accelerationStructure_ )
+    {
+      accelerationStructure = accelerationStructure_;
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNVX& setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNVX& setMemoryOffset( DeviceSize memoryOffset_ )
+    {
+      memoryOffset = memoryOffset_;
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNVX& setDeviceIndexCount( uint32_t deviceIndexCount_ )
+    {
+      deviceIndexCount = deviceIndexCount_;
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNVX& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
+    {
+      pDeviceIndices = pDeviceIndices_;
+      return *this;
+    }
+
+    operator VkBindAccelerationStructureMemoryInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNVX*>(this);
+    }
+
+    operator VkBindAccelerationStructureMemoryInfoNVX &()
+    {
+      return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNVX*>(this);
+    }
+
+    bool operator==( BindAccelerationStructureMemoryInfoNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( accelerationStructure == rhs.accelerationStructure )
+          && ( memory == rhs.memory )
+          && ( memoryOffset == rhs.memoryOffset )
+          && ( deviceIndexCount == rhs.deviceIndexCount )
+          && ( pDeviceIndices == rhs.pDeviceIndices );
+    }
+
+    bool operator!=( BindAccelerationStructureMemoryInfoNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNVX;
+
+  public:
+    const void* pNext = nullptr;
+    AccelerationStructureNVX accelerationStructure;
+    DeviceMemory memory;
+    DeviceSize memoryOffset;
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices;
+  };
+  static_assert( sizeof( BindAccelerationStructureMemoryInfoNVX ) == sizeof( VkBindAccelerationStructureMemoryInfoNVX ), "struct and wrapper have different size!" );
+
+  struct DescriptorAccelerationStructureInfoNVX
+  {
+    DescriptorAccelerationStructureInfoNVX( uint32_t accelerationStructureCount_ = 0,
+                                            const AccelerationStructureNVX* pAccelerationStructures_ = nullptr )
+      : accelerationStructureCount( accelerationStructureCount_ )
+      , pAccelerationStructures( pAccelerationStructures_ )
+    {
+    }
+
+    DescriptorAccelerationStructureInfoNVX( VkDescriptorAccelerationStructureInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorAccelerationStructureInfoNVX ) );
+    }
+
+    DescriptorAccelerationStructureInfoNVX& operator=( VkDescriptorAccelerationStructureInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorAccelerationStructureInfoNVX ) );
+      return *this;
+    }
+    DescriptorAccelerationStructureInfoNVX& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DescriptorAccelerationStructureInfoNVX& setAccelerationStructureCount( uint32_t accelerationStructureCount_ )
+    {
+      accelerationStructureCount = accelerationStructureCount_;
+      return *this;
+    }
+
+    DescriptorAccelerationStructureInfoNVX& setPAccelerationStructures( const AccelerationStructureNVX* pAccelerationStructures_ )
+    {
+      pAccelerationStructures = pAccelerationStructures_;
+      return *this;
+    }
+
+    operator VkDescriptorAccelerationStructureInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorAccelerationStructureInfoNVX*>(this);
+    }
+
+    operator VkDescriptorAccelerationStructureInfoNVX &()
+    {
+      return *reinterpret_cast<VkDescriptorAccelerationStructureInfoNVX*>(this);
+    }
+
+    bool operator==( DescriptorAccelerationStructureInfoNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( accelerationStructureCount == rhs.accelerationStructureCount )
+          && ( pAccelerationStructures == rhs.pAccelerationStructures );
+    }
+
+    bool operator!=( DescriptorAccelerationStructureInfoNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorAccelerationStructureInfoNVX;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t accelerationStructureCount;
+    const AccelerationStructureNVX* pAccelerationStructures;
+  };
+  static_assert( sizeof( DescriptorAccelerationStructureInfoNVX ) == sizeof( VkDescriptorAccelerationStructureInfoNVX ), "struct and wrapper have different size!" );
+
+  struct AccelerationStructureMemoryRequirementsInfoNVX
+  {
+    AccelerationStructureMemoryRequirementsInfoNVX( AccelerationStructureNVX accelerationStructure_ = AccelerationStructureNVX() )
+      : accelerationStructure( accelerationStructure_ )
+    {
+    }
+
+    AccelerationStructureMemoryRequirementsInfoNVX( VkAccelerationStructureMemoryRequirementsInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNVX ) );
+    }
+
+    AccelerationStructureMemoryRequirementsInfoNVX& operator=( VkAccelerationStructureMemoryRequirementsInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNVX ) );
+      return *this;
+    }
+    AccelerationStructureMemoryRequirementsInfoNVX& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AccelerationStructureMemoryRequirementsInfoNVX& setAccelerationStructure( AccelerationStructureNVX accelerationStructure_ )
+    {
+      accelerationStructure = accelerationStructure_;
+      return *this;
+    }
+
+    operator VkAccelerationStructureMemoryRequirementsInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNVX*>(this);
+    }
+
+    operator VkAccelerationStructureMemoryRequirementsInfoNVX &()
+    {
+      return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNVX*>(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_ )
+    {
+    }
+
+    PhysicalDeviceRaytracingPropertiesNVX( VkPhysicalDeviceRaytracingPropertiesNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRaytracingPropertiesNVX ) );
+    }
+
+    PhysicalDeviceRaytracingPropertiesNVX& operator=( VkPhysicalDeviceRaytracingPropertiesNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRaytracingPropertiesNVX ) );
+      return *this;
+    }
+    PhysicalDeviceRaytracingPropertiesNVX& setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceRaytracingPropertiesNVX& setShaderHeaderSize( uint32_t shaderHeaderSize_ )
+    {
+      shaderHeaderSize = shaderHeaderSize_;
+      return *this;
+    }
+
+    PhysicalDeviceRaytracingPropertiesNVX& setMaxRecursionDepth( uint32_t maxRecursionDepth_ )
+    {
+      maxRecursionDepth = maxRecursionDepth_;
+      return *this;
+    }
+
+    PhysicalDeviceRaytracingPropertiesNVX& setMaxGeometryCount( uint32_t maxGeometryCount_ )
+    {
+      maxGeometryCount = maxGeometryCount_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceRaytracingPropertiesNVX const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRaytracingPropertiesNVX*>(this);
+    }
+
+    operator VkPhysicalDeviceRaytracingPropertiesNVX &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRaytracingPropertiesNVX*>(this);
+    }
+
+    bool operator==( PhysicalDeviceRaytracingPropertiesNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shaderHeaderSize == rhs.shaderHeaderSize )
+          && ( maxRecursionDepth == rhs.maxRecursionDepth )
+          && ( maxGeometryCount == rhs.maxGeometryCount );
+    }
+
+    bool operator!=( PhysicalDeviceRaytracingPropertiesNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceRaytracingPropertiesNVX;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t shaderHeaderSize;
+    uint32_t maxRecursionDepth;
+    uint32_t maxGeometryCount;
+  };
+  static_assert( sizeof( PhysicalDeviceRaytracingPropertiesNVX ) == sizeof( VkPhysicalDeviceRaytracingPropertiesNVX ), "struct and wrapper have different size!" );
+
+  enum class SubpassContents
+  {
+    eInline = VK_SUBPASS_CONTENTS_INLINE,
+    eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+  };
+
+  struct SubpassBeginInfoKHR
+  {
+    SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
+      : contents( contents_ )
+    {
+    }
+
+    SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+    }
+
+    SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+      return *this;
+    }
+    SubpassBeginInfoKHR& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SubpassBeginInfoKHR& setContents( SubpassContents contents_ )
+    {
+      contents = contents_;
+      return *this;
+    }
+
+    operator VkSubpassBeginInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkSubpassBeginInfoKHR*>(this);
+    }
+
+    operator VkSubpassBeginInfoKHR &()
+    {
+      return *reinterpret_cast<VkSubpassBeginInfoKHR*>(this);
+    }
+
+    bool operator==( SubpassBeginInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( contents == rhs.contents );
+    }
+
+    bool operator!=( SubpassBeginInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSubpassBeginInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    SubpassContents contents;
+  };
+  static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
+
+  struct PresentInfoKHR
+  {
+    PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
+                    const Semaphore* pWaitSemaphores_ = nullptr,
+                    uint32_t swapchainCount_ = 0,
+                    const SwapchainKHR* pSwapchains_ = nullptr,
+                    const uint32_t* pImageIndices_ = nullptr,
+                    Result* pResults_ = nullptr )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphores( pWaitSemaphores_ )
+      , swapchainCount( swapchainCount_ )
+      , pSwapchains( pSwapchains_ )
+      , pImageIndices( pImageIndices_ )
+      , pResults( pResults_ )
+    {
+    }
+
+    PresentInfoKHR( VkPresentInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+    }
+
+    PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+      return *this;
+    }
+    PresentInfoKHR& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+    {
+      waitSemaphoreCount = waitSemaphoreCount_;
+      return *this;
+    }
+
+    PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    {
+      pWaitSemaphores = pWaitSemaphores_;
+      return *this;
+    }
+
+    PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
+    {
+      swapchainCount = swapchainCount_;
+      return *this;
+    }
+
+    PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
+    {
+      pSwapchains = pSwapchains_;
+      return *this;
+    }
+
+    PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
+    {
+      pImageIndices = pImageIndices_;
+      return *this;
+    }
+
+    PresentInfoKHR& setPResults( Result* pResults_ )
+    {
+      pResults = pResults_;
+      return *this;
+    }
+
+    operator VkPresentInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkPresentInfoKHR*>(this);
+    }
+
+    operator VkPresentInfoKHR &()
+    {
+      return *reinterpret_cast<VkPresentInfoKHR*>(this);
+    }
+
+    bool operator==( PresentInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+          && ( pWaitSemaphores == rhs.pWaitSemaphores )
+          && ( swapchainCount == rhs.swapchainCount )
+          && ( pSwapchains == rhs.pSwapchains )
+          && ( pImageIndices == rhs.pImageIndices )
+          && ( pResults == rhs.pResults );
+    }
+
+    bool operator!=( PresentInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePresentInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t waitSemaphoreCount;
+    const Semaphore* pWaitSemaphores;
+    uint32_t swapchainCount;
+    const SwapchainKHR* pSwapchains;
+    const uint32_t* pImageIndices;
+    Result* pResults;
+  };
+  static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
+
+  enum class DynamicState
+  {
+    eViewport = VK_DYNAMIC_STATE_VIEWPORT,
+    eScissor = VK_DYNAMIC_STATE_SCISSOR,
+    eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
+    eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
+    eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+    eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
+    eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+    eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
+    eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+    eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
+    eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
+    eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
+    eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
+    eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
+    eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
+  };
+
+  struct PipelineDynamicStateCreateInfo
+  {
+    PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
+                                    uint32_t dynamicStateCount_ = 0,
+                                    const DynamicState* pDynamicStates_ = nullptr )
+      : flags( flags_ )
+      , dynamicStateCount( dynamicStateCount_ )
+      , pDynamicStates( pDynamicStates_ )
+    {
+    }
+
+    PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
+    }
+
+    PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
+      return *this;
+    }
+    PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
+    {
+      dynamicStateCount = dynamicStateCount_;
+      return *this;
+    }
+
+    PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
+    {
+      pDynamicStates = pDynamicStates_;
+      return *this;
+    }
+
+    operator VkPipelineDynamicStateCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
+    }
+
+    operator VkPipelineDynamicStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this);
+    }
+
+    bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( dynamicStateCount == rhs.dynamicStateCount )
+          && ( pDynamicStates == rhs.pDynamicStates );
+    }
+
+    bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineDynamicStateCreateFlags flags;
+    uint32_t dynamicStateCount;
+    const DynamicState* pDynamicStates;
+  };
+  static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
+
+  enum class DescriptorUpdateTemplateType
+  {
+    eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
+  };
+
+  struct DescriptorUpdateTemplateCreateInfo
+  {
+    DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
+                                        uint32_t descriptorUpdateEntryCount_ = 0,
+                                        const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
+                                        DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
+                                        DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
+                                        PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+                                        PipelineLayout pipelineLayout_ = PipelineLayout(),
+                                        uint32_t set_ = 0 )
+      : flags( flags_ )
+      , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
+      , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
+      , templateType( templateType_ )
+      , descriptorSetLayout( descriptorSetLayout_ )
+      , pipelineBindPoint( pipelineBindPoint_ )
+      , pipelineLayout( pipelineLayout_ )
+      , set( set_ )
+    {
+    }
+
+    DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+    }
+
+    DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+      return *this;
+    }
+    DescriptorUpdateTemplateCreateInfo& setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
+    {
+      descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
+    {
+      pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setTemplateType( DescriptorUpdateTemplateType templateType_ )
+    {
+      templateType = templateType_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
+    {
+      descriptorSetLayout = descriptorSetLayout_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    {
+      pipelineBindPoint = pipelineBindPoint_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setPipelineLayout( PipelineLayout pipelineLayout_ )
+    {
+      pipelineLayout = pipelineLayout_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo& setSet( uint32_t set_ )
+    {
+      set = set_;
+      return *this;
+    }
+
+    operator VkDescriptorUpdateTemplateCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(this);
+    }
+
+    operator VkDescriptorUpdateTemplateCreateInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this);
+    }
+
+    bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
+          && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
+          && ( templateType == rhs.templateType )
+          && ( descriptorSetLayout == rhs.descriptorSetLayout )
+          && ( pipelineBindPoint == rhs.pipelineBindPoint )
+          && ( pipelineLayout == rhs.pipelineLayout )
+          && ( set == rhs.set );
+    }
+
+    bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
+
+  public:
+    void* pNext = nullptr;
+    DescriptorUpdateTemplateCreateFlags flags;
+    uint32_t descriptorUpdateEntryCount;
+    const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
+    DescriptorUpdateTemplateType templateType;
+    DescriptorSetLayout descriptorSetLayout;
+    PipelineBindPoint pipelineBindPoint;
+    PipelineLayout pipelineLayout;
+    uint32_t set;
+  };
+  static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
+
+  using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
+
+  enum class ObjectType
+  {
+    eUnknown = VK_OBJECT_TYPE_UNKNOWN,
+    eInstance = VK_OBJECT_TYPE_INSTANCE,
+    ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
+    eDevice = VK_OBJECT_TYPE_DEVICE,
+    eQueue = VK_OBJECT_TYPE_QUEUE,
+    eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
+    eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
+    eFence = VK_OBJECT_TYPE_FENCE,
+    eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
+    eBuffer = VK_OBJECT_TYPE_BUFFER,
+    eImage = VK_OBJECT_TYPE_IMAGE,
+    eEvent = VK_OBJECT_TYPE_EVENT,
+    eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
+    eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
+    eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
+    eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
+    ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
+    ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
+    eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
+    ePipeline = VK_OBJECT_TYPE_PIPELINE,
+    eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+    eSampler = VK_OBJECT_TYPE_SAMPLER,
+    eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+    eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
+    eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
+    eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
+    eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+    eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+    eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+    eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+    eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
+    eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
+    eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
+    eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
+    eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
+    eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
+    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
+  };
+
+  struct DebugUtilsObjectNameInfoEXT
+  {
+    DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+                                 uint64_t objectHandle_ = 0,
+                                 const char* pObjectName_ = nullptr )
+      : objectType( objectType_ )
+      , objectHandle( objectHandle_ )
+      , pObjectName( pObjectName_ )
+    {
+    }
+
+    DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+    }
+
+    DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+      return *this;
+    }
+    DebugUtilsObjectNameInfoEXT& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugUtilsObjectNameInfoEXT& setObjectType( ObjectType objectType_ )
+    {
+      objectType = objectType_;
+      return *this;
+    }
+
+    DebugUtilsObjectNameInfoEXT& setObjectHandle( uint64_t objectHandle_ )
+    {
+      objectHandle = objectHandle_;
+      return *this;
+    }
+
+    DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
+    {
+      pObjectName = pObjectName_;
+      return *this;
+    }
+
+    operator VkDebugUtilsObjectNameInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(this);
+    }
+
+    operator VkDebugUtilsObjectNameInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this);
+    }
+
+    bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectType == rhs.objectType )
+          && ( objectHandle == rhs.objectHandle )
+          && ( pObjectName == rhs.pObjectName );
+    }
+
+    bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    ObjectType objectType;
+    uint64_t objectHandle;
+    const char* pObjectName;
+  };
+  static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DebugUtilsObjectTagInfoEXT
+  {
+    DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+                                uint64_t objectHandle_ = 0,
+                                uint64_t tagName_ = 0,
+                                size_t tagSize_ = 0,
+                                const void* pTag_ = nullptr )
+      : objectType( objectType_ )
+      , objectHandle( objectHandle_ )
+      , tagName( tagName_ )
+      , tagSize( tagSize_ )
+      , pTag( pTag_ )
+    {
+    }
+
+    DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+    }
+
+    DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+      return *this;
+    }
+    DebugUtilsObjectTagInfoEXT& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT& setObjectType( ObjectType objectType_ )
+    {
+      objectType = objectType_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT& setObjectHandle( uint64_t objectHandle_ )
+    {
+      objectHandle = objectHandle_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT& setTagName( uint64_t tagName_ )
+    {
+      tagName = tagName_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT& setTagSize( size_t tagSize_ )
+    {
+      tagSize = tagSize_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT& setPTag( const void* pTag_ )
+    {
+      pTag = pTag_;
+      return *this;
     }
 
-    operator const VkDebugUtilsObjectTagInfoEXT&() const
+    operator VkDebugUtilsObjectTagInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(this);
     }
 
+    operator VkDebugUtilsObjectTagInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this);
+    }
+
     bool operator==( DebugUtilsObjectTagInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -18450,11 +21162,16 @@ public:
       return *this;
     }
 
-    operator const VkDebugUtilsMessengerCallbackDataEXT&() const
+    operator VkDebugUtilsMessengerCallbackDataEXT const&() const
     {
       return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(this);
     }
 
+    operator VkDebugUtilsMessengerCallbackDataEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this);
+    }
+
     bool operator==( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -18525,11 +21242,16 @@ public:
 
   struct QueueFamilyProperties
   {
-    operator const VkQueueFamilyProperties&() const
+    operator VkQueueFamilyProperties const&() const
     {
       return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
     }
 
+    operator VkQueueFamilyProperties &()
+    {
+      return *reinterpret_cast<VkQueueFamilyProperties*>(this);
+    }
+
     bool operator==( QueueFamilyProperties const& rhs ) const
     {
       return ( queueFlags == rhs.queueFlags )
@@ -18552,11 +21274,16 @@ public:
 
   struct QueueFamilyProperties2
   {
-    operator const VkQueueFamilyProperties2&() const
+    operator VkQueueFamilyProperties2 const&() const
     {
       return *reinterpret_cast<const VkQueueFamilyProperties2*>(this);
     }
 
+    operator VkQueueFamilyProperties2 &()
+    {
+      return *reinterpret_cast<VkQueueFamilyProperties2*>(this);
+    }
+
     bool operator==( QueueFamilyProperties2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -18658,11 +21385,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceQueueCreateInfo&() const
+    operator VkDeviceQueueCreateInfo const&() const
     {
       return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this);
     }
 
+    operator VkDeviceQueueCreateInfo &()
+    {
+      return *reinterpret_cast<VkDeviceQueueCreateInfo*>(this);
+    }
+
     bool operator==( DeviceQueueCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -18775,11 +21507,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceCreateInfo&() const
+    operator VkDeviceCreateInfo const&() const
     {
       return *reinterpret_cast<const VkDeviceCreateInfo*>(this);
     }
 
+    operator VkDeviceCreateInfo &()
+    {
+      return *reinterpret_cast<VkDeviceCreateInfo*>(this);
+    }
+
     bool operator==( DeviceCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -18860,11 +21597,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceQueueInfo2&() const
+    operator VkDeviceQueueInfo2 const&() const
     {
       return *reinterpret_cast<const VkDeviceQueueInfo2*>(this);
     }
 
+    operator VkDeviceQueueInfo2 &()
+    {
+      return *reinterpret_cast<VkDeviceQueueInfo2*>(this);
+    }
+
     bool operator==( DeviceQueueInfo2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -18922,11 +21664,16 @@ public:
 
   struct MemoryType
   {
-    operator const VkMemoryType&() const
+    operator VkMemoryType const&() const
     {
       return *reinterpret_cast<const VkMemoryType*>(this);
     }
 
+    operator VkMemoryType &()
+    {
+      return *reinterpret_cast<VkMemoryType*>(this);
+    }
+
     bool operator==( MemoryType const& rhs ) const
     {
       return ( propertyFlags == rhs.propertyFlags )
@@ -18972,11 +21719,16 @@ public:
 
   struct MemoryHeap
   {
-    operator const VkMemoryHeap&() const
+    operator VkMemoryHeap const&() const
     {
       return *reinterpret_cast<const VkMemoryHeap*>(this);
     }
 
+    operator VkMemoryHeap &()
+    {
+      return *reinterpret_cast<VkMemoryHeap*>(this);
+    }
+
     bool operator==( MemoryHeap const& rhs ) const
     {
       return ( size == rhs.size )
@@ -18995,11 +21747,16 @@ public:
 
   struct PhysicalDeviceMemoryProperties
   {
-    operator const VkPhysicalDeviceMemoryProperties&() const
+    operator VkPhysicalDeviceMemoryProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
     }
 
+    operator VkPhysicalDeviceMemoryProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
     {
       return ( memoryTypeCount == rhs.memoryTypeCount )
@@ -19022,11 +21779,16 @@ public:
 
   struct PhysicalDeviceMemoryProperties2
   {
-    operator const VkPhysicalDeviceMemoryProperties2&() const
+    operator VkPhysicalDeviceMemoryProperties2 const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(this);
     }
 
+    operator VkPhysicalDeviceMemoryProperties2 &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this);
+    }
+
     bool operator==( PhysicalDeviceMemoryProperties2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19072,7 +21834,10 @@ public:
     eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
     eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
     eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX,
-    eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT
+    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
   };
 
   using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
@@ -19091,7 +21856,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::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT)
+      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::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNVX) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNVX)
     };
   };
 
@@ -19132,11 +21897,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryBarrier&() const
+    operator VkMemoryBarrier const&() const
     {
       return *reinterpret_cast<const VkMemoryBarrier*>(this);
     }
 
+    operator VkMemoryBarrier &()
+    {
+      return *reinterpret_cast<VkMemoryBarrier*>(this);
+    }
+
     bool operator==( MemoryBarrier const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19237,11 +22007,16 @@ public:
       return *this;
     }
 
-    operator const VkBufferMemoryBarrier&() const
+    operator VkBufferMemoryBarrier const&() const
     {
       return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
     }
 
+    operator VkBufferMemoryBarrier &()
+    {
+      return *reinterpret_cast<VkBufferMemoryBarrier*>(this);
+    }
+
     bool operator==( BufferMemoryBarrier const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19286,7 +22061,8 @@ public:
     eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
     eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
     eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
-    eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT
+    eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
+    eRaytracingNVX = VK_BUFFER_USAGE_RAYTRACING_BIT_NVX
   };
 
   using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
@@ -19305,7 +22081,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::eConditionalRenderingEXT)
+      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::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRaytracingNVX)
     };
   };
 
@@ -19406,11 +22182,16 @@ public:
       return *this;
     }
 
-    operator const VkBufferCreateInfo&() const
+    operator VkBufferCreateInfo const&() const
     {
       return *reinterpret_cast<const VkBufferCreateInfo*>(this);
     }
 
+    operator VkBufferCreateInfo &()
+    {
+      return *reinterpret_cast<VkBufferCreateInfo*>(this);
+    }
+
     bool operator==( BufferCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19451,7 +22232,15 @@ public:
     eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
     eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
     eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
-    eAll = VK_SHADER_STAGE_ALL
+    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,
+    eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV,
+    eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV
   };
 
   using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
@@ -19470,7 +22259,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)
+      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)
     };
   };
 
@@ -19529,11 +22318,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorSetLayoutBinding&() const
+    operator VkDescriptorSetLayoutBinding const&() const
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
     }
 
+    operator VkDescriptorSetLayoutBinding &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this);
+    }
+
     bool operator==( DescriptorSetLayoutBinding const& rhs ) const
     {
       return ( binding == rhs.binding )
@@ -19617,11 +22411,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineShaderStageCreateInfo&() const
+    operator VkPipelineShaderStageCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
     }
 
+    operator VkPipelineShaderStageCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this);
+    }
+
     bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19690,11 +22489,16 @@ public:
       return *this;
     }
 
-    operator const VkPushConstantRange&() const
+    operator VkPushConstantRange const&() const
     {
       return *reinterpret_cast<const VkPushConstantRange*>(this);
     }
 
+    operator VkPushConstantRange &()
+    {
+      return *reinterpret_cast<VkPushConstantRange*>(this);
+    }
+
     bool operator==( PushConstantRange const& rhs ) const
     {
       return ( stageFlags == rhs.stageFlags )
@@ -19774,11 +22578,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineLayoutCreateInfo&() const
+    operator VkPipelineLayoutCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
     }
 
+    operator VkPipelineLayoutCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this);
+    }
+
     bool operator==( PipelineLayoutCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19810,11 +22619,16 @@ public:
 
   struct ShaderStatisticsInfoAMD
   {
-    operator const VkShaderStatisticsInfoAMD&() const
+    operator VkShaderStatisticsInfoAMD const&() const
     {
       return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this);
     }
 
+    operator VkShaderStatisticsInfoAMD &()
+    {
+      return *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this);
+    }
+
     bool operator==( ShaderStatisticsInfoAMD const& rhs ) const
     {
       return ( shaderStageMask == rhs.shaderStageMask )
@@ -19850,7 +22664,8 @@ public:
     eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
     eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
     eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
-    eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
+    eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+    eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV
   };
 
   using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
@@ -19869,17 +22684,22 @@ public:
   {
     enum
     {
-      allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment)
+      allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) | VkFlags(ImageUsageFlagBits::eShadingRateImageNV)
     };
   };
 
   struct SharedPresentSurfaceCapabilitiesKHR
   {
-    operator const VkSharedPresentSurfaceCapabilitiesKHR&() const
+    operator VkSharedPresentSurfaceCapabilitiesKHR const&() const
     {
       return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this);
     }
 
+    operator VkSharedPresentSurfaceCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this);
+    }
+
     bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19930,11 +22750,16 @@ public:
       return *this;
     }
 
-    operator const VkImageViewUsageCreateInfo&() const
+    operator VkImageViewUsageCreateInfo const&() const
     {
       return *reinterpret_cast<const VkImageViewUsageCreateInfo*>(this);
     }
 
+    operator VkImageViewUsageCreateInfo &()
+    {
+      return *reinterpret_cast<VkImageViewUsageCreateInfo*>(this);
+    }
+
     bool operator==( ImageViewUsageCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -19978,6 +22803,7 @@ public:
     eProtected = VK_IMAGE_CREATE_PROTECTED_BIT,
     eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT,
     eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT,
+    eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
     eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT
   };
 
@@ -19997,7 +22823,7 @@ public:
   {
     enum
     {
-      allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT)
+      allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eCornerSampledNV) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT)
     };
   };
 
@@ -20062,11 +22888,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceImageFormatInfo2&() const
+    operator VkPhysicalDeviceImageFormatInfo2 const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(this);
     }
 
+    operator VkPhysicalDeviceImageFormatInfo2 &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this);
+    }
+
     bool operator==( PhysicalDeviceImageFormatInfo2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -20106,7 +22937,8 @@ public:
     eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
     eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
     eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
-    eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE
+    eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
+    eDeferCompileNVX = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX
   };
 
   using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
@@ -20125,7 +22957,7 @@ public:
   {
     enum
     {
-      allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase)
+      allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNVX)
     };
   };
 
@@ -20190,11 +23022,16 @@ public:
       return *this;
     }
 
-    operator const VkComputePipelineCreateInfo&() const
+    operator VkComputePipelineCreateInfo const&() const
     {
       return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
     }
 
+    operator VkComputePipelineCreateInfo &()
+    {
+      return *reinterpret_cast<VkComputePipelineCreateInfo*>(this);
+    }
+
     bool operator==( ComputePipelineCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -20224,6 +23061,136 @@ 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<const VkRaytracingPipelineCreateInfoNVX*>(this);
+    }
+
+    operator VkRaytracingPipelineCreateInfoNVX &()
+    {
+      return *reinterpret_cast<VkRaytracingPipelineCreateInfoNVX*>(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,
@@ -20331,11 +23298,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineColorBlendAttachmentState&() const
+    operator VkPipelineColorBlendAttachmentState const&() const
     {
       return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
     }
 
+    operator VkPipelineColorBlendAttachmentState &()
+    {
+      return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this);
+    }
+
     bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
     {
       return ( blendEnable == rhs.blendEnable )
@@ -20433,11 +23405,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineColorBlendStateCreateInfo&() const
+    operator VkPipelineColorBlendStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
     }
 
+    operator VkPipelineColorBlendStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -20523,11 +23500,16 @@ public:
       return *this;
     }
 
-    operator const VkFenceCreateInfo&() const
+    operator VkFenceCreateInfo const&() const
     {
       return *reinterpret_cast<const VkFenceCreateInfo*>(this);
     }
 
+    operator VkFenceCreateInfo &()
+    {
+      return *reinterpret_cast<VkFenceCreateInfo*>(this);
+    }
+
     bool operator==( FenceCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -20608,11 +23590,16 @@ public:
 
   struct FormatProperties
   {
-    operator const VkFormatProperties&() const
+    operator VkFormatProperties const&() const
     {
       return *reinterpret_cast<const VkFormatProperties*>(this);
     }
 
+    operator VkFormatProperties &()
+    {
+      return *reinterpret_cast<VkFormatProperties*>(this);
+    }
+
     bool operator==( FormatProperties const& rhs ) const
     {
       return ( linearTilingFeatures == rhs.linearTilingFeatures )
@@ -20633,11 +23620,16 @@ public:
 
   struct FormatProperties2
   {
-    operator const VkFormatProperties2&() const
+    operator VkFormatProperties2 const&() const
     {
       return *reinterpret_cast<const VkFormatProperties2*>(this);
     }
 
+    operator VkFormatProperties2 &()
+    {
+      return *reinterpret_cast<VkFormatProperties2*>(this);
+    }
+
     bool operator==( FormatProperties2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -20845,11 +23837,16 @@ public:
       return *this;
     }
 
-    operator const VkCommandBufferInheritanceInfo&() const
+    operator VkCommandBufferInheritanceInfo const&() const
     {
       return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
     }
 
+    operator VkCommandBufferInheritanceInfo &()
+    {
+      return *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this);
+    }
+
     bool operator==( CommandBufferInheritanceInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -20918,11 +23915,16 @@ public:
       return *this;
     }
 
-    operator const VkCommandBufferBeginInfo&() const
+    operator VkCommandBufferBeginInfo const&() const
     {
       return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
     }
 
+    operator VkCommandBufferBeginInfo &()
+    {
+      return *reinterpret_cast<VkCommandBufferBeginInfo*>(this);
+    }
+
     bool operator==( CommandBufferBeginInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -20999,11 +24001,16 @@ public:
       return *this;
     }
 
-    operator const VkQueryPoolCreateInfo&() const
+    operator VkQueryPoolCreateInfo const&() const
     {
       return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
     }
 
+    operator VkQueryPoolCreateInfo &()
+    {
+      return *reinterpret_cast<VkQueryPoolCreateInfo*>(this);
+    }
+
     bool operator==( QueryPoolCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -21104,11 +24111,16 @@ public:
       return *this;
     }
 
-    operator const VkImageSubresource&() const
+    operator VkImageSubresource const&() const
     {
       return *reinterpret_cast<const VkImageSubresource*>(this);
     }
 
+    operator VkImageSubresource &()
+    {
+      return *reinterpret_cast<VkImageSubresource*>(this);
+    }
+
     bool operator==( ImageSubresource const& rhs ) const
     {
       return ( aspectMask == rhs.aspectMask )
@@ -21174,11 +24186,16 @@ public:
       return *this;
     }
 
-    operator const VkImageSubresourceLayers&() const
+    operator VkImageSubresourceLayers const&() const
     {
       return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
     }
 
+    operator VkImageSubresourceLayers &()
+    {
+      return *reinterpret_cast<VkImageSubresourceLayers*>(this);
+    }
+
     bool operator==( ImageSubresourceLayers const& rhs ) const
     {
       return ( aspectMask == rhs.aspectMask )
@@ -21254,11 +24271,16 @@ public:
       return *this;
     }
 
-    operator const VkImageSubresourceRange&() const
+    operator VkImageSubresourceRange const&() const
     {
       return *reinterpret_cast<const VkImageSubresourceRange*>(this);
     }
 
+    operator VkImageSubresourceRange &()
+    {
+      return *reinterpret_cast<VkImageSubresourceRange*>(this);
+    }
+
     bool operator==( ImageSubresourceRange const& rhs ) const
     {
       return ( aspectMask == rhs.aspectMask )
@@ -21366,11 +24388,16 @@ public:
       return *this;
     }
 
-    operator const VkImageMemoryBarrier&() const
+    operator VkImageMemoryBarrier const&() const
     {
       return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
     }
 
+    operator VkImageMemoryBarrier &()
+    {
+      return *reinterpret_cast<VkImageMemoryBarrier*>(this);
+    }
+
     bool operator==( ImageMemoryBarrier const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -21475,11 +24502,16 @@ public:
       return *this;
     }
 
-    operator const VkImageViewCreateInfo&() const
+    operator VkImageViewCreateInfo const&() const
     {
       return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
     }
 
+    operator VkImageViewCreateInfo &()
+    {
+      return *reinterpret_cast<VkImageViewCreateInfo*>(this);
+    }
+
     bool operator==( ImageViewCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -21566,11 +24598,16 @@ public:
       return *this;
     }
 
-    operator const VkImageCopy&() const
+    operator VkImageCopy const&() const
     {
       return *reinterpret_cast<const VkImageCopy*>(this);
     }
 
+    operator VkImageCopy &()
+    {
+      return *reinterpret_cast<VkImageCopy*>(this);
+    }
+
     bool operator==( ImageCopy const& rhs ) const
     {
       return ( srcSubresource == rhs.srcSubresource )
@@ -21640,11 +24677,16 @@ public:
       return *this;
     }
 
-    operator const VkImageBlit&() const
+    operator VkImageBlit const&() const
     {
       return *reinterpret_cast<const VkImageBlit*>(this);
     }
 
+    operator VkImageBlit &()
+    {
+      return *reinterpret_cast<VkImageBlit*>(this);
+    }
+
     bool operator==( ImageBlit const& rhs ) const
     {
       return ( srcSubresource == rhs.srcSubresource )
@@ -21728,11 +24770,16 @@ public:
       return *this;
     }
 
-    operator const VkBufferImageCopy&() const
+    operator VkBufferImageCopy const&() const
     {
       return *reinterpret_cast<const VkBufferImageCopy*>(this);
     }
 
+    operator VkBufferImageCopy &()
+    {
+      return *reinterpret_cast<VkBufferImageCopy*>(this);
+    }
+
     bool operator==( BufferImageCopy const& rhs ) const
     {
       return ( bufferOffset == rhs.bufferOffset )
@@ -21812,11 +24859,16 @@ public:
       return *this;
     }
 
-    operator const VkImageResolve&() const
+    operator VkImageResolve const&() const
     {
       return *reinterpret_cast<const VkImageResolve*>(this);
     }
 
+    operator VkImageResolve &()
+    {
+      return *reinterpret_cast<VkImageResolve*>(this);
+    }
+
     bool operator==( ImageResolve const& rhs ) const
     {
       return ( srcSubresource == rhs.srcSubresource )
@@ -21878,11 +24930,16 @@ public:
       return *this;
     }
 
-    operator const VkClearAttachment&() const
+    operator VkClearAttachment const&() const
     {
       return *reinterpret_cast<const VkClearAttachment*>(this);
     }
 
+    operator VkClearAttachment &()
+    {
+      return *reinterpret_cast<VkClearAttachment*>(this);
+    }
+
     ImageAspectFlags aspectMask;
     uint32_t colorAttachment;
     ClearValue clearValue;
@@ -21928,11 +24985,16 @@ public:
       return *this;
     }
 
-    operator const VkInputAttachmentAspectReference&() const
+    operator VkInputAttachmentAspectReference const&() const
     {
       return *reinterpret_cast<const VkInputAttachmentAspectReference*>(this);
     }
 
+    operator VkInputAttachmentAspectReference &()
+    {
+      return *reinterpret_cast<VkInputAttachmentAspectReference*>(this);
+    }
+
     bool operator==( InputAttachmentAspectReference const& rhs ) const
     {
       return ( subpass == rhs.subpass )
@@ -21990,11 +25052,16 @@ public:
       return *this;
     }
 
-    operator const VkRenderPassInputAttachmentAspectCreateInfo&() const
+    operator VkRenderPassInputAttachmentAspectCreateInfo const&() const
     {
       return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(this);
     }
 
+    operator VkRenderPassInputAttachmentAspectCreateInfo &()
+    {
+      return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this);
+    }
+
     bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22049,11 +25116,16 @@ public:
       return *this;
     }
 
-    operator const VkBindImagePlaneMemoryInfo&() const
+    operator VkBindImagePlaneMemoryInfo const&() const
     {
       return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(this);
     }
 
+    operator VkBindImagePlaneMemoryInfo &()
+    {
+      return *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this);
+    }
+
     bool operator==( BindImagePlaneMemoryInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22106,11 +25178,16 @@ public:
       return *this;
     }
 
-    operator const VkImagePlaneMemoryRequirementsInfo&() const
+    operator VkImagePlaneMemoryRequirementsInfo const&() const
     {
       return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(this);
     }
 
+    operator VkImagePlaneMemoryRequirementsInfo &()
+    {
+      return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this);
+    }
+
     bool operator==( ImagePlaneMemoryRequirementsInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22179,11 +25256,16 @@ public:
       return *this;
     }
 
-    operator const VkAttachmentReference2KHR&() const
+    operator VkAttachmentReference2KHR const&() const
     {
       return *reinterpret_cast<const VkAttachmentReference2KHR*>(this);
     }
 
+    operator VkAttachmentReference2KHR &()
+    {
+      return *reinterpret_cast<VkAttachmentReference2KHR*>(this);
+    }
+
     bool operator==( AttachmentReference2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22238,11 +25320,16 @@ public:
 
   struct SparseImageFormatProperties
   {
-    operator const VkSparseImageFormatProperties&() const
+    operator VkSparseImageFormatProperties const&() const
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
     }
 
+    operator VkSparseImageFormatProperties &()
+    {
+      return *reinterpret_cast<VkSparseImageFormatProperties*>(this);
+    }
+
     bool operator==( SparseImageFormatProperties const& rhs ) const
     {
       return ( aspectMask == rhs.aspectMask )
@@ -22263,11 +25350,16 @@ public:
 
   struct SparseImageMemoryRequirements
   {
-    operator const VkSparseImageMemoryRequirements&() const
+    operator VkSparseImageMemoryRequirements const&() const
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
     }
 
+    operator VkSparseImageMemoryRequirements &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryRequirements*>(this);
+    }
+
     bool operator==( SparseImageMemoryRequirements const& rhs ) const
     {
       return ( formatProperties == rhs.formatProperties )
@@ -22292,11 +25384,16 @@ public:
 
   struct SparseImageFormatProperties2
   {
-    operator const VkSparseImageFormatProperties2&() const
+    operator VkSparseImageFormatProperties2 const&() const
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties2*>(this);
     }
 
+    operator VkSparseImageFormatProperties2 &()
+    {
+      return *reinterpret_cast<VkSparseImageFormatProperties2*>(this);
+    }
+
     bool operator==( SparseImageFormatProperties2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22322,11 +25419,16 @@ public:
 
   struct SparseImageMemoryRequirements2
   {
-    operator const VkSparseImageMemoryRequirements2&() const
+    operator VkSparseImageMemoryRequirements2 const&() const
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>(this);
     }
 
+    operator VkSparseImageMemoryRequirements2 &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this);
+    }
+
     bool operator==( SparseImageMemoryRequirements2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22430,11 +25532,16 @@ public:
       return *this;
     }
 
-    operator const VkSparseMemoryBind&() const
+    operator VkSparseMemoryBind const&() const
     {
       return *reinterpret_cast<const VkSparseMemoryBind*>(this);
     }
 
+    operator VkSparseMemoryBind &()
+    {
+      return *reinterpret_cast<VkSparseMemoryBind*>(this);
+    }
+
     bool operator==( SparseMemoryBind const& rhs ) const
     {
       return ( resourceOffset == rhs.resourceOffset )
@@ -22520,11 +25627,16 @@ public:
       return *this;
     }
 
-    operator const VkSparseImageMemoryBind&() const
+    operator VkSparseImageMemoryBind const&() const
     {
       return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
     }
 
+    operator VkSparseImageMemoryBind &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryBind*>(this);
+    }
+
     bool operator==( SparseImageMemoryBind const& rhs ) const
     {
       return ( subresource == rhs.subresource )
@@ -22588,11 +25700,16 @@ public:
       return *this;
     }
 
-    operator const VkSparseBufferMemoryBindInfo&() const
+    operator VkSparseBufferMemoryBindInfo const&() const
     {
       return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
     }
 
+    operator VkSparseBufferMemoryBindInfo &()
+    {
+      return *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this);
+    }
+
     bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
     {
       return ( buffer == rhs.buffer )
@@ -22650,11 +25767,16 @@ public:
       return *this;
     }
 
-    operator const VkSparseImageOpaqueMemoryBindInfo&() const
+    operator VkSparseImageOpaqueMemoryBindInfo const&() const
     {
       return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
     }
 
+    operator VkSparseImageOpaqueMemoryBindInfo &()
+    {
+      return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this);
+    }
+
     bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
     {
       return ( image == rhs.image )
@@ -22712,11 +25834,16 @@ public:
       return *this;
     }
 
-    operator const VkSparseImageMemoryBindInfo&() const
+    operator VkSparseImageMemoryBindInfo const&() const
     {
       return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
     }
 
+    operator VkSparseImageMemoryBindInfo &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this);
+    }
+
     bool operator==( SparseImageMemoryBindInfo const& rhs ) const
     {
       return ( image == rhs.image )
@@ -22836,11 +25963,16 @@ public:
       return *this;
     }
 
-    operator const VkBindSparseInfo&() const
+    operator VkBindSparseInfo const&() const
     {
       return *reinterpret_cast<const VkBindSparseInfo*>(this);
     }
 
+    operator VkBindSparseInfo &()
+    {
+      return *reinterpret_cast<VkBindSparseInfo*>(this);
+    }
+
     bool operator==( BindSparseInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22900,7 +26032,11 @@ public:
     eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
     eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
     eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
-    eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX
+    eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX,
+    eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
+    eRaytracingNVX = VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX,
+    eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
+    eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
   };
 
   using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
@@ -22919,17 +26055,22 @@ 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::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX)
+      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::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRaytracingNVX) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV)
     };
   };
 
   struct QueueFamilyCheckpointPropertiesNV
   {
-    operator const VkQueueFamilyCheckpointPropertiesNV&() const
+    operator VkQueueFamilyCheckpointPropertiesNV const&() const
     {
       return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(this);
     }
 
+    operator VkQueueFamilyCheckpointPropertiesNV &()
+    {
+      return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this);
+    }
+
     bool operator==( QueueFamilyCheckpointPropertiesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -22953,11 +26094,16 @@ public:
 
   struct CheckpointDataNV
   {
-    operator const VkCheckpointDataNV&() const
+    operator VkCheckpointDataNV const&() const
     {
       return *reinterpret_cast<const VkCheckpointDataNV*>(this);
     }
 
+    operator VkCheckpointDataNV &()
+    {
+      return *reinterpret_cast<VkCheckpointDataNV*>(this);
+    }
+
     bool operator==( CheckpointDataNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -23045,11 +26191,16 @@ public:
       return *this;
     }
 
-    operator const VkCommandPoolCreateInfo&() const
+    operator VkCommandPoolCreateInfo const&() const
     {
       return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
     }
 
+    operator VkCommandPoolCreateInfo &()
+    {
+      return *reinterpret_cast<VkCommandPoolCreateInfo*>(this);
+    }
+
     bool operator==( CommandPoolCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -23156,11 +26307,16 @@ public:
 
   struct ImageFormatProperties
   {
-    operator const VkImageFormatProperties&() const
+    operator VkImageFormatProperties const&() const
     {
       return *reinterpret_cast<const VkImageFormatProperties*>(this);
     }
 
+    operator VkImageFormatProperties &()
+    {
+      return *reinterpret_cast<VkImageFormatProperties*>(this);
+    }
+
     bool operator==( ImageFormatProperties const& rhs ) const
     {
       return ( maxExtent == rhs.maxExtent )
@@ -23308,11 +26464,16 @@ public:
       return *this;
     }
 
-    operator const VkImageCreateInfo&() const
+    operator VkImageCreateInfo const&() const
     {
       return *reinterpret_cast<const VkImageCreateInfo*>(this);
     }
 
+    operator VkImageCreateInfo &()
+    {
+      return *reinterpret_cast<VkImageCreateInfo*>(this);
+    }
+
     bool operator==( ImageCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -23435,11 +26596,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineMultisampleStateCreateInfo&() const
+    operator VkPipelineMultisampleStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
     }
 
+    operator VkPipelineMultisampleStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -23630,11 +26796,16 @@ public:
       return *this;
     }
 
-    operator const VkGraphicsPipelineCreateInfo&() const
+    operator VkGraphicsPipelineCreateInfo const&() const
     {
       return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
     }
 
+    operator VkGraphicsPipelineCreateInfo &()
+    {
+      return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this);
+    }
+
     bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -23690,11 +26861,16 @@ public:
 
   struct PhysicalDeviceLimits
   {
-    operator const VkPhysicalDeviceLimits&() const
+    operator VkPhysicalDeviceLimits const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
     }
 
+    operator VkPhysicalDeviceLimits &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceLimits*>(this);
+    }
+
     bool operator==( PhysicalDeviceLimits const& rhs ) const
     {
       return ( maxImageDimension1D == rhs.maxImageDimension1D )
@@ -23921,11 +27097,16 @@ public:
 
   struct PhysicalDeviceProperties
   {
-    operator const VkPhysicalDeviceProperties&() const
+    operator VkPhysicalDeviceProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
     }
 
+    operator VkPhysicalDeviceProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceProperties const& rhs ) const
     {
       return ( apiVersion == rhs.apiVersion )
@@ -23958,11 +27139,16 @@ public:
 
   struct PhysicalDeviceProperties2
   {
-    operator const VkPhysicalDeviceProperties2&() const
+    operator VkPhysicalDeviceProperties2 const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties2*>(this);
     }
 
+    operator VkPhysicalDeviceProperties2 &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceProperties2*>(this);
+    }
+
     bool operator==( PhysicalDeviceProperties2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -23988,11 +27174,16 @@ public:
 
   struct ImageFormatProperties2
   {
-    operator const VkImageFormatProperties2&() const
+    operator VkImageFormatProperties2 const&() const
     {
       return *reinterpret_cast<const VkImageFormatProperties2*>(this);
     }
 
+    operator VkImageFormatProperties2 &()
+    {
+      return *reinterpret_cast<VkImageFormatProperties2*>(this);
+    }
+
     bool operator==( ImageFormatProperties2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -24077,11 +27268,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceSparseImageFormatInfo2&() const
+    operator VkPhysicalDeviceSparseImageFormatInfo2 const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(this);
     }
 
+    operator VkPhysicalDeviceSparseImageFormatInfo2 &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this);
+    }
+
     bool operator==( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -24166,11 +27362,16 @@ public:
       return *this;
     }
 
-    operator const VkSampleLocationsInfoEXT&() const
+    operator VkSampleLocationsInfoEXT const&() const
     {
       return *reinterpret_cast<const VkSampleLocationsInfoEXT*>(this);
     }
 
+    operator VkSampleLocationsInfoEXT &()
+    {
+      return *reinterpret_cast<VkSampleLocationsInfoEXT*>(this);
+    }
+
     bool operator==( SampleLocationsInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -24229,11 +27430,16 @@ public:
       return *this;
     }
 
-    operator const VkAttachmentSampleLocationsEXT&() const
+    operator VkAttachmentSampleLocationsEXT const&() const
     {
       return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>(this);
     }
 
+    operator VkAttachmentSampleLocationsEXT &()
+    {
+      return *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this);
+    }
+
     bool operator==( AttachmentSampleLocationsEXT const& rhs ) const
     {
       return ( attachmentIndex == rhs.attachmentIndex )
@@ -24281,11 +27487,16 @@ public:
       return *this;
     }
 
-    operator const VkSubpassSampleLocationsEXT&() const
+    operator VkSubpassSampleLocationsEXT const&() const
     {
       return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>(this);
     }
 
+    operator VkSubpassSampleLocationsEXT &()
+    {
+      return *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this);
+    }
+
     bool operator==( SubpassSampleLocationsEXT const& rhs ) const
     {
       return ( subpassIndex == rhs.subpassIndex )
@@ -24355,11 +27566,16 @@ public:
       return *this;
     }
 
-    operator const VkRenderPassSampleLocationsBeginInfoEXT&() const
+    operator VkRenderPassSampleLocationsBeginInfoEXT const&() const
     {
       return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(this);
     }
 
+    operator VkRenderPassSampleLocationsBeginInfoEXT &()
+    {
+      return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this);
+    }
+
     bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -24424,11 +27640,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineSampleLocationsStateCreateInfoEXT&() const
+    operator VkPipelineSampleLocationsStateCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
     }
 
+    operator VkPipelineSampleLocationsStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
+    }
+
     bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -24454,11 +27675,16 @@ public:
 
   struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
-    operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const
+    operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
     }
 
+    operator VkPhysicalDeviceSampleLocationsPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+    }
+
     bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -24600,11 +27826,16 @@ public:
       return *this;
     }
 
-    operator const VkAttachmentDescription&() const
+    operator VkAttachmentDescription const&() const
     {
       return *reinterpret_cast<const VkAttachmentDescription*>(this);
     }
 
+    operator VkAttachmentDescription &()
+    {
+      return *reinterpret_cast<VkAttachmentDescription*>(this);
+    }
+
     bool operator==( AttachmentDescription const& rhs ) const
     {
       return ( flags == rhs.flags )
@@ -24728,11 +27959,16 @@ public:
       return *this;
     }
 
-    operator const VkAttachmentDescription2KHR&() const
+    operator VkAttachmentDescription2KHR const&() const
     {
       return *reinterpret_cast<const VkAttachmentDescription2KHR*>(this);
     }
 
+    operator VkAttachmentDescription2KHR &()
+    {
+      return *reinterpret_cast<VkAttachmentDescription2KHR*>(this);
+    }
+
     bool operator==( AttachmentDescription2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -24876,11 +28112,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorPoolCreateInfo&() const
+    operator VkDescriptorPoolCreateInfo const&() const
     {
       return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
     }
 
+    operator VkDescriptorPoolCreateInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this);
+    }
+
     bool operator==( DescriptorPoolCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25008,11 +28249,16 @@ public:
       return *this;
     }
 
-    operator const VkSubpassDependency&() const
+    operator VkSubpassDependency const&() const
     {
       return *reinterpret_cast<const VkSubpassDependency*>(this);
     }
 
+    operator VkSubpassDependency &()
+    {
+      return *reinterpret_cast<VkSubpassDependency*>(this);
+    }
+
     bool operator==( SubpassDependency const& rhs ) const
     {
       return ( srcSubpass == rhs.srcSubpass )
@@ -25124,11 +28370,16 @@ public:
       return *this;
     }
 
-    operator const VkSubpassDependency2KHR&() const
+    operator VkSubpassDependency2KHR const&() const
     {
       return *reinterpret_cast<const VkSubpassDependency2KHR*>(this);
     }
 
+    operator VkSubpassDependency2KHR &()
+    {
+      return *reinterpret_cast<VkSubpassDependency2KHR*>(this);
+    }
+
     bool operator==( SubpassDependency2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25196,11 +28447,16 @@ public:
 
   struct SurfaceFormatKHR
   {
-    operator const VkSurfaceFormatKHR&() const
+    operator VkSurfaceFormatKHR const&() const
     {
       return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
     }
 
+    operator VkSurfaceFormatKHR &()
+    {
+      return *reinterpret_cast<VkSurfaceFormatKHR*>(this);
+    }
+
     bool operator==( SurfaceFormatKHR const& rhs ) const
     {
       return ( format == rhs.format )
@@ -25219,11 +28475,16 @@ public:
 
   struct SurfaceFormat2KHR
   {
-    operator const VkSurfaceFormat2KHR&() const
+    operator VkSurfaceFormat2KHR const&() const
     {
       return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this);
     }
 
+    operator VkSurfaceFormat2KHR &()
+    {
+      return *reinterpret_cast<VkSurfaceFormat2KHR*>(this);
+    }
+
     bool operator==( SurfaceFormat2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25275,11 +28536,16 @@ public:
 
   struct DisplayPlaneCapabilitiesKHR
   {
-    operator const VkDisplayPlaneCapabilitiesKHR&() const
+    operator VkDisplayPlaneCapabilitiesKHR const&() const
     {
       return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
     }
 
+    operator VkDisplayPlaneCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this);
+    }
+
     bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
     {
       return ( supportedAlpha == rhs.supportedAlpha )
@@ -25312,11 +28578,16 @@ public:
 
   struct DisplayPlaneCapabilities2KHR
   {
-    operator const VkDisplayPlaneCapabilities2KHR&() const
+    operator VkDisplayPlaneCapabilities2KHR const&() const
     {
       return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(this);
     }
 
+    operator VkDisplayPlaneCapabilities2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this);
+    }
+
     bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25401,11 +28672,16 @@ public:
 
   struct DisplayPropertiesKHR
   {
-    operator const VkDisplayPropertiesKHR&() const
+    operator VkDisplayPropertiesKHR const&() const
     {
       return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
     }
 
+    operator VkDisplayPropertiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPropertiesKHR*>(this);
+    }
+
     bool operator==( DisplayPropertiesKHR const& rhs ) const
     {
       return ( display == rhs.display )
@@ -25517,11 +28793,16 @@ public:
       return *this;
     }
 
-    operator const VkDisplaySurfaceCreateInfoKHR&() const
+    operator VkDisplaySurfaceCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
     }
 
+    operator VkDisplaySurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this);
+    }
+
     bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25559,11 +28840,16 @@ public:
 
   struct SurfaceCapabilitiesKHR
   {
-    operator const VkSurfaceCapabilitiesKHR&() const
+    operator VkSurfaceCapabilitiesKHR const&() const
     {
       return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
     }
 
+    operator VkSurfaceCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this);
+    }
+
     bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
     {
       return ( minImageCount == rhs.minImageCount )
@@ -25598,11 +28884,16 @@ public:
 
   struct SurfaceCapabilities2KHR
   {
-    operator const VkSurfaceCapabilities2KHR&() const
+    operator VkSurfaceCapabilities2KHR const&() const
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this);
     }
 
+    operator VkSurfaceCapabilities2KHR &()
+    {
+      return *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this);
+    }
+
     bool operator==( SurfaceCapabilities2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25626,11 +28917,16 @@ public:
 
   struct DisplayProperties2KHR
   {
-    operator const VkDisplayProperties2KHR&() const
+    operator VkDisplayProperties2KHR const&() const
     {
       return *reinterpret_cast<const VkDisplayProperties2KHR*>(this);
     }
 
+    operator VkDisplayProperties2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayProperties2KHR*>(this);
+    }
+
     bool operator==( DisplayProperties2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25726,11 +29022,16 @@ public:
       return *this;
     }
 
-    operator const VkDebugReportCallbackCreateInfoEXT&() const
+    operator VkDebugReportCallbackCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
     }
 
+    operator VkDebugReportCallbackCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this);
+    }
+
     bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25797,7 +29098,8 @@ public:
     eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
     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
+    eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+    eAccelerationStructureNVX = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT
   };
 
   struct DebugMarkerObjectNameInfoEXT
@@ -25845,11 +29147,16 @@ public:
       return *this;
     }
 
-    operator const VkDebugMarkerObjectNameInfoEXT&() const
+    operator VkDebugMarkerObjectNameInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
     }
 
+    operator VkDebugMarkerObjectNameInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this);
+    }
+
     bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -25936,11 +29243,16 @@ public:
       return *this;
     }
 
-    operator const VkDebugMarkerObjectTagInfoEXT&() const
+    operator VkDebugMarkerObjectTagInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
     }
 
+    operator VkDebugMarkerObjectTagInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this);
+    }
+
     bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26005,11 +29317,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const
+    operator VkPipelineRasterizationStateRasterizationOrderAMD const&() const
     {
       return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
     }
 
+    operator VkPipelineRasterizationStateRasterizationOrderAMD &()
+    {
+      return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
+    }
+
     bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26088,11 +29405,16 @@ public:
       return *this;
     }
 
-    operator const VkExternalMemoryImageCreateInfoNV&() const
+    operator VkExternalMemoryImageCreateInfoNV const&() const
     {
       return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
     }
 
+    operator VkExternalMemoryImageCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this);
+    }
+
     bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26143,11 +29465,16 @@ public:
       return *this;
     }
 
-    operator const VkExportMemoryAllocateInfoNV&() const
+    operator VkExportMemoryAllocateInfoNV const&() const
     {
       return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
     }
 
+    operator VkExportMemoryAllocateInfoNV &()
+    {
+      return *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this);
+    }
+
     bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26207,11 +29534,16 @@ public:
       return *this;
     }
 
-    operator const VkImportMemoryWin32HandleInfoNV&() const
+    operator VkImportMemoryWin32HandleInfoNV const&() const
     {
       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
     }
 
+    operator VkImportMemoryWin32HandleInfoNV &()
+    {
+      return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this);
+    }
+
     bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26265,11 +29597,16 @@ public:
 
   struct ExternalImageFormatPropertiesNV
   {
-    operator const VkExternalImageFormatPropertiesNV&() const
+    operator VkExternalImageFormatPropertiesNV const&() const
     {
       return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
     }
 
+    operator VkExternalImageFormatPropertiesNV &()
+    {
+      return *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this);
+    }
+
     bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
     {
       return ( imageFormatProperties == rhs.imageFormatProperties )
@@ -26333,11 +29670,16 @@ public:
       return *this;
     }
 
-    operator const VkValidationFlagsEXT&() const
+    operator VkValidationFlagsEXT const&() const
     {
       return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
     }
 
+    operator VkValidationFlagsEXT &()
+    {
+      return *reinterpret_cast<VkValidationFlagsEXT*>(this);
+    }
+
     bool operator==( ValidationFlagsEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26396,11 +29738,16 @@ public:
 
   struct PhysicalDeviceSubgroupProperties
   {
-    operator const VkPhysicalDeviceSubgroupProperties&() const
+    operator VkPhysicalDeviceSubgroupProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(this);
     }
 
+    operator VkPhysicalDeviceSubgroupProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceSubgroupProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26533,11 +29880,16 @@ public:
       return *this;
     }
 
-    operator const VkIndirectCommandsTokenNVX&() const
+    operator VkIndirectCommandsTokenNVX const&() const
     {
       return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
     }
 
+    operator VkIndirectCommandsTokenNVX &()
+    {
+      return *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this);
+    }
+
     bool operator==( IndirectCommandsTokenNVX const& rhs ) const
     {
       return ( tokenType == rhs.tokenType )
@@ -26603,11 +29955,16 @@ public:
       return *this;
     }
 
-    operator const VkIndirectCommandsLayoutTokenNVX&() const
+    operator VkIndirectCommandsLayoutTokenNVX const&() const
     {
       return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
     }
 
+    operator VkIndirectCommandsLayoutTokenNVX &()
+    {
+      return *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this);
+    }
+
     bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
     {
       return ( tokenType == rhs.tokenType )
@@ -26681,11 +30038,16 @@ public:
       return *this;
     }
 
-    operator const VkIndirectCommandsLayoutCreateInfoNVX&() const
+    operator VkIndirectCommandsLayoutCreateInfoNVX const&() const
     {
       return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
     }
 
+    operator VkIndirectCommandsLayoutCreateInfoNVX &()
+    {
+      return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this);
+    }
+
     bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26815,11 +30177,16 @@ public:
       return *this;
     }
 
-    operator const VkObjectTableCreateInfoNVX&() const
+    operator VkObjectTableCreateInfoNVX const&() const
     {
       return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
     }
 
+    operator VkObjectTableCreateInfoNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this);
+    }
+
     bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -26888,11 +30255,16 @@ public:
       return *this;
     }
 
-    operator const VkObjectTableEntryNVX&() const
+    operator VkObjectTableEntryNVX const&() const
     {
       return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
     }
 
+    operator VkObjectTableEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableEntryNVX*>(this);
+    }
+
     bool operator==( ObjectTableEntryNVX const& rhs ) const
     {
       return ( type == rhs.type )
@@ -26955,11 +30327,16 @@ public:
       return *this;
     }
 
-    operator const VkObjectTablePipelineEntryNVX&() const
+    operator VkObjectTablePipelineEntryNVX const&() const
     {
       return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
     }
 
+    operator VkObjectTablePipelineEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this);
+    }
+
     bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
     {
       return ( type == rhs.type )
@@ -27034,11 +30411,16 @@ public:
       return *this;
     }
 
-    operator const VkObjectTableDescriptorSetEntryNVX&() const
+    operator VkObjectTableDescriptorSetEntryNVX const&() const
     {
       return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
     }
 
+    operator VkObjectTableDescriptorSetEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this);
+    }
+
     bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
     {
       return ( type == rhs.type )
@@ -27105,11 +30487,16 @@ public:
       return *this;
     }
 
-    operator const VkObjectTableVertexBufferEntryNVX&() const
+    operator VkObjectTableVertexBufferEntryNVX const&() const
     {
       return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
     }
 
+    operator VkObjectTableVertexBufferEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this);
+    }
+
     bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
     {
       return ( type == rhs.type )
@@ -27184,11 +30571,16 @@ public:
       return *this;
     }
 
-    operator const VkObjectTableIndexBufferEntryNVX&() const
+    operator VkObjectTableIndexBufferEntryNVX const&() const
     {
       return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
     }
 
+    operator VkObjectTableIndexBufferEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this);
+    }
+
     bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
     {
       return ( type == rhs.type )
@@ -27265,11 +30657,16 @@ public:
       return *this;
     }
 
-    operator const VkObjectTablePushConstantEntryNVX&() const
+    operator VkObjectTablePushConstantEntryNVX const&() const
     {
       return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
     }
 
+    operator VkObjectTablePushConstantEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this);
+    }
+
     bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
     {
       return ( type == rhs.type )
@@ -27361,11 +30758,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorSetLayoutCreateInfo&() const
+    operator VkDescriptorSetLayoutCreateInfo const&() const
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
     }
 
+    operator VkDescriptorSetLayoutCreateInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this);
+    }
+
     bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27464,11 +30866,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceExternalImageFormatInfo&() const
+    operator VkPhysicalDeviceExternalImageFormatInfo const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(this);
     }
 
+    operator VkPhysicalDeviceExternalImageFormatInfo &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this);
+    }
+
     bool operator==( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27537,11 +30944,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceExternalBufferInfo&() const
+    operator VkPhysicalDeviceExternalBufferInfo const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(this);
     }
 
+    operator VkPhysicalDeviceExternalBufferInfo &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this);
+    }
+
     bool operator==( PhysicalDeviceExternalBufferInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27598,11 +31010,16 @@ public:
       return *this;
     }
 
-    operator const VkExternalMemoryImageCreateInfo&() const
+    operator VkExternalMemoryImageCreateInfo const&() const
     {
       return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(this);
     }
 
+    operator VkExternalMemoryImageCreateInfo &()
+    {
+      return *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this);
+    }
+
     bool operator==( ExternalMemoryImageCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27655,11 +31072,16 @@ public:
       return *this;
     }
 
-    operator const VkExternalMemoryBufferCreateInfo&() const
+    operator VkExternalMemoryBufferCreateInfo const&() const
     {
       return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(this);
     }
 
+    operator VkExternalMemoryBufferCreateInfo &()
+    {
+      return *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this);
+    }
+
     bool operator==( ExternalMemoryBufferCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27712,11 +31134,16 @@ public:
       return *this;
     }
 
-    operator const VkExportMemoryAllocateInfo&() const
+    operator VkExportMemoryAllocateInfo const&() const
     {
       return *reinterpret_cast<const VkExportMemoryAllocateInfo*>(this);
     }
 
+    operator VkExportMemoryAllocateInfo &()
+    {
+      return *reinterpret_cast<VkExportMemoryAllocateInfo*>(this);
+    }
+
     bool operator==( ExportMemoryAllocateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27786,11 +31213,16 @@ public:
       return *this;
     }
 
-    operator const VkImportMemoryWin32HandleInfoKHR&() const
+    operator VkImportMemoryWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(this);
     }
 
+    operator VkImportMemoryWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27855,11 +31287,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryGetWin32HandleInfoKHR&() const
+    operator VkMemoryGetWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(this);
     }
 
+    operator VkMemoryGetWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27921,11 +31358,16 @@ public:
       return *this;
     }
 
-    operator const VkImportMemoryFdInfoKHR&() const
+    operator VkImportMemoryFdInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(this);
     }
 
+    operator VkImportMemoryFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this);
+    }
+
     bool operator==( ImportMemoryFdInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -27986,11 +31428,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryGetFdInfoKHR&() const
+    operator VkMemoryGetFdInfoKHR const&() const
     {
       return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(this);
     }
 
+    operator VkMemoryGetFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this);
+    }
+
     bool operator==( MemoryGetFdInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28051,11 +31498,16 @@ public:
       return *this;
     }
 
-    operator const VkImportMemoryHostPointerInfoEXT&() const
+    operator VkImportMemoryHostPointerInfoEXT const&() const
     {
       return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this);
     }
 
+    operator VkImportMemoryHostPointerInfoEXT &()
+    {
+      return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this);
+    }
+
     bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28113,11 +31565,16 @@ public:
 
   struct ExternalMemoryProperties
   {
-    operator const VkExternalMemoryProperties&() const
+    operator VkExternalMemoryProperties const&() const
     {
       return *reinterpret_cast<const VkExternalMemoryProperties*>(this);
     }
 
+    operator VkExternalMemoryProperties &()
+    {
+      return *reinterpret_cast<VkExternalMemoryProperties*>(this);
+    }
+
     bool operator==( ExternalMemoryProperties const& rhs ) const
     {
       return ( externalMemoryFeatures == rhs.externalMemoryFeatures )
@@ -28140,11 +31597,16 @@ public:
 
   struct ExternalImageFormatProperties
   {
-    operator const VkExternalImageFormatProperties&() const
+    operator VkExternalImageFormatProperties const&() const
     {
       return *reinterpret_cast<const VkExternalImageFormatProperties*>(this);
     }
 
+    operator VkExternalImageFormatProperties &()
+    {
+      return *reinterpret_cast<VkExternalImageFormatProperties*>(this);
+    }
+
     bool operator==( ExternalImageFormatProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28170,11 +31632,16 @@ public:
 
   struct ExternalBufferProperties
   {
-    operator const VkExternalBufferProperties&() const
+    operator VkExternalBufferProperties const&() const
     {
       return *reinterpret_cast<const VkExternalBufferProperties*>(this);
     }
 
+    operator VkExternalBufferProperties &()
+    {
+      return *reinterpret_cast<VkExternalBufferProperties*>(this);
+    }
+
     bool operator==( ExternalBufferProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28263,11 +31730,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceExternalSemaphoreInfo&() const
+    operator VkPhysicalDeviceExternalSemaphoreInfo const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(this);
     }
 
+    operator VkPhysicalDeviceExternalSemaphoreInfo &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this);
+    }
+
     bool operator==( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28320,11 +31792,16 @@ public:
       return *this;
     }
 
-    operator const VkExportSemaphoreCreateInfo&() const
+    operator VkExportSemaphoreCreateInfo const&() const
     {
       return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>(this);
     }
 
+    operator VkExportSemaphoreCreateInfo &()
+    {
+      return *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this);
+    }
+
     bool operator==( ExportSemaphoreCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28386,11 +31863,16 @@ public:
       return *this;
     }
 
-    operator const VkSemaphoreGetWin32HandleInfoKHR&() const
+    operator VkSemaphoreGetWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(this);
     }
 
+    operator VkSemaphoreGetWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28452,11 +31934,16 @@ public:
       return *this;
     }
 
-    operator const VkSemaphoreGetFdInfoKHR&() const
+    operator VkSemaphoreGetFdInfoKHR const&() const
     {
       return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(this);
     }
 
+    operator VkSemaphoreGetFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this);
+    }
+
     bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28512,11 +31999,16 @@ public:
 
   struct ExternalSemaphoreProperties
   {
-    operator const VkExternalSemaphoreProperties&() const
+    operator VkExternalSemaphoreProperties const&() const
     {
       return *reinterpret_cast<const VkExternalSemaphoreProperties*>(this);
     }
 
+    operator VkExternalSemaphoreProperties &()
+    {
+      return *reinterpret_cast<VkExternalSemaphoreProperties*>(this);
+    }
+
     bool operator==( ExternalSemaphoreProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28634,11 +32126,16 @@ public:
       return *this;
     }
 
-    operator const VkImportSemaphoreWin32HandleInfoKHR&() const
+    operator VkImportSemaphoreWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(this);
     }
 
+    operator VkImportSemaphoreWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28722,11 +32219,16 @@ public:
       return *this;
     }
 
-    operator const VkImportSemaphoreFdInfoKHR&() const
+    operator VkImportSemaphoreFdInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(this);
     }
 
+    operator VkImportSemaphoreFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this);
+    }
+
     bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28817,11 +32319,16 @@ public:
       return *this;
     }
 
-    operator const VkPhysicalDeviceExternalFenceInfo&() const
+    operator VkPhysicalDeviceExternalFenceInfo const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(this);
     }
 
+    operator VkPhysicalDeviceExternalFenceInfo &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this);
+    }
+
     bool operator==( PhysicalDeviceExternalFenceInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28874,11 +32381,16 @@ public:
       return *this;
     }
 
-    operator const VkExportFenceCreateInfo&() const
+    operator VkExportFenceCreateInfo const&() const
     {
       return *reinterpret_cast<const VkExportFenceCreateInfo*>(this);
     }
 
+    operator VkExportFenceCreateInfo &()
+    {
+      return *reinterpret_cast<VkExportFenceCreateInfo*>(this);
+    }
+
     bool operator==( ExportFenceCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -28940,11 +32452,16 @@ public:
       return *this;
     }
 
-    operator const VkFenceGetWin32HandleInfoKHR&() const
+    operator VkFenceGetWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(this);
     }
 
+    operator VkFenceGetWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29006,11 +32523,16 @@ public:
       return *this;
     }
 
-    operator const VkFenceGetFdInfoKHR&() const
+    operator VkFenceGetFdInfoKHR const&() const
     {
       return *reinterpret_cast<const VkFenceGetFdInfoKHR*>(this);
     }
 
+    operator VkFenceGetFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkFenceGetFdInfoKHR*>(this);
+    }
+
     bool operator==( FenceGetFdInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29066,11 +32588,16 @@ public:
 
   struct ExternalFenceProperties
   {
-    operator const VkExternalFenceProperties&() const
+    operator VkExternalFenceProperties const&() const
     {
       return *reinterpret_cast<const VkExternalFenceProperties*>(this);
     }
 
+    operator VkExternalFenceProperties &()
+    {
+      return *reinterpret_cast<VkExternalFenceProperties*>(this);
+    }
+
     bool operator==( ExternalFenceProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29188,11 +32715,16 @@ public:
       return *this;
     }
 
-    operator const VkImportFenceWin32HandleInfoKHR&() const
+    operator VkImportFenceWin32HandleInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(this);
     }
 
+    operator VkImportFenceWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this);
+    }
+
     bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29276,11 +32808,16 @@ public:
       return *this;
     }
 
-    operator const VkImportFenceFdInfoKHR&() const
+    operator VkImportFenceFdInfoKHR const&() const
     {
       return *reinterpret_cast<const VkImportFenceFdInfoKHR*>(this);
     }
 
+    operator VkImportFenceFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportFenceFdInfoKHR*>(this);
+    }
+
     bool operator==( ImportFenceFdInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29335,11 +32872,16 @@ public:
 
   struct SurfaceCapabilities2EXT
   {
-    operator const VkSurfaceCapabilities2EXT&() const
+    operator VkSurfaceCapabilities2EXT const&() const
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
     }
 
+    operator VkSurfaceCapabilities2EXT &()
+    {
+      return *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this);
+    }
+
     bool operator==( SurfaceCapabilities2EXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29410,11 +32952,16 @@ public:
       return *this;
     }
 
-    operator const VkSwapchainCounterCreateInfoEXT&() const
+    operator VkSwapchainCounterCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
     }
 
+    operator VkSwapchainCounterCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this);
+    }
+
     bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29472,11 +33019,16 @@ public:
       return *this;
     }
 
-    operator const VkDisplayPowerInfoEXT&() const
+    operator VkDisplayPowerInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
     }
 
+    operator VkDisplayPowerInfoEXT &()
+    {
+      return *reinterpret_cast<VkDisplayPowerInfoEXT*>(this);
+    }
+
     bool operator==( DisplayPowerInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29532,11 +33084,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceEventInfoEXT&() const
+    operator VkDeviceEventInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
     }
 
+    operator VkDeviceEventInfoEXT &()
+    {
+      return *reinterpret_cast<VkDeviceEventInfoEXT*>(this);
+    }
+
     bool operator==( DeviceEventInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29592,11 +33149,16 @@ public:
       return *this;
     }
 
-    operator const VkDisplayEventInfoEXT&() const
+    operator VkDisplayEventInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
     }
 
+    operator VkDisplayEventInfoEXT &()
+    {
+      return *reinterpret_cast<VkDisplayEventInfoEXT*>(this);
+    }
+
     bool operator==( DisplayEventInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29717,11 +33279,16 @@ public:
       return *this;
     }
 
-    operator const VkMemoryAllocateFlagsInfo&() const
+    operator VkMemoryAllocateFlagsInfo const&() const
     {
       return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(this);
     }
 
+    operator VkMemoryAllocateFlagsInfo &()
+    {
+      return *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this);
+    }
+
     bool operator==( MemoryAllocateFlagsInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29777,11 +33344,16 @@ public:
 
   struct DeviceGroupPresentCapabilitiesKHR
   {
-    operator const VkDeviceGroupPresentCapabilitiesKHR&() const
+    operator VkDeviceGroupPresentCapabilitiesKHR const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(this);
     }
 
+    operator VkDeviceGroupPresentCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this);
+    }
+
     bool operator==( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29850,11 +33422,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGroupPresentInfoKHR&() const
+    operator VkDeviceGroupPresentInfoKHR const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(this);
     }
 
+    operator VkDeviceGroupPresentInfoKHR &()
+    {
+      return *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this);
+    }
+
     bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -29909,11 +33486,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGroupSwapchainCreateInfoKHR&() const
+    operator VkDeviceGroupSwapchainCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(this);
     }
 
+    operator VkDeviceGroupSwapchainCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this);
+    }
+
     bool operator==( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -30110,11 +33692,16 @@ public:
       return *this;
     }
 
-    operator const VkSwapchainCreateInfoKHR&() const
+    operator VkSwapchainCreateInfoKHR const&() const
     {
       return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
     }
 
+    operator VkSwapchainCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this);
+    }
+
     bool operator==( SwapchainCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -30225,11 +33812,16 @@ public:
       return *this;
     }
 
-    operator const VkViewportSwizzleNV&() const
+    operator VkViewportSwizzleNV const&() const
     {
       return *reinterpret_cast<const VkViewportSwizzleNV*>(this);
     }
 
+    operator VkViewportSwizzleNV &()
+    {
+      return *reinterpret_cast<VkViewportSwizzleNV*>(this);
+    }
+
     bool operator==( ViewportSwizzleNV const& rhs ) const
     {
       return ( x == rhs.x )
@@ -30295,11 +33887,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineViewportSwizzleStateCreateInfoNV&() const
+    operator VkPipelineViewportSwizzleStateCreateInfoNV const&() const
     {
       return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
     }
 
+    operator VkPipelineViewportSwizzleStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+    }
+
     bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -30384,11 +33981,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineDiscardRectangleStateCreateInfoEXT&() const
+    operator VkPipelineDiscardRectangleStateCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
     }
 
+    operator VkPipelineDiscardRectangleStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
+    }
+
     bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -30537,11 +34139,16 @@ public:
       return *this;
     }
 
-    operator const VkSubpassDescription&() const
+    operator VkSubpassDescription const&() const
     {
       return *reinterpret_cast<const VkSubpassDescription*>(this);
     }
 
+    operator VkSubpassDescription &()
+    {
+      return *reinterpret_cast<VkSubpassDescription*>(this);
+    }
+
     bool operator==( SubpassDescription const& rhs ) const
     {
       return ( flags == rhs.flags )
@@ -30651,11 +34258,16 @@ public:
       return *this;
     }
 
-    operator const VkRenderPassCreateInfo&() const
+    operator VkRenderPassCreateInfo const&() const
     {
       return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
     }
 
+    operator VkRenderPassCreateInfo &()
+    {
+      return *reinterpret_cast<VkRenderPassCreateInfo*>(this);
+    }
+
     bool operator==( RenderPassCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -30798,11 +34410,16 @@ public:
       return *this;
     }
 
-    operator const VkSubpassDescription2KHR&() const
+    operator VkSubpassDescription2KHR const&() const
     {
       return *reinterpret_cast<const VkSubpassDescription2KHR*>(this);
     }
 
+    operator VkSubpassDescription2KHR &()
+    {
+      return *reinterpret_cast<VkSubpassDescription2KHR*>(this);
+    }
+
     bool operator==( SubpassDescription2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -30937,11 +34554,16 @@ public:
       return *this;
     }
 
-    operator const VkRenderPassCreateInfo2KHR&() const
+    operator VkRenderPassCreateInfo2KHR const&() const
     {
       return *reinterpret_cast<const VkRenderPassCreateInfo2KHR*>(this);
     }
 
+    operator VkRenderPassCreateInfo2KHR &()
+    {
+      return *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this);
+    }
+
     bool operator==( RenderPassCreateInfo2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -30989,11 +34611,16 @@ public:
 
   struct PhysicalDevicePointClippingProperties
   {
-    operator const VkPhysicalDevicePointClippingProperties&() const
+    operator VkPhysicalDevicePointClippingProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(this);
     }
 
+    operator VkPhysicalDevicePointClippingProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this);
+    }
+
     bool operator==( PhysicalDevicePointClippingProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31053,11 +34680,16 @@ public:
       return *this;
     }
 
-    operator const VkSamplerReductionModeCreateInfoEXT&() const
+    operator VkSamplerReductionModeCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(this);
     }
 
+    operator VkSamplerReductionModeCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this);
+    }
+
     bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31116,11 +34748,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineTessellationDomainOriginStateCreateInfo&() const
+    operator VkPipelineTessellationDomainOriginStateCreateInfo const&() const
     {
       return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
     }
 
+    operator VkPipelineTessellationDomainOriginStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
+    }
+
     bool operator==( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31259,11 +34896,16 @@ public:
       return *this;
     }
 
-    operator const VkSamplerYcbcrConversionCreateInfo&() const
+    operator VkSamplerYcbcrConversionCreateInfo const&() const
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(this);
     }
 
+    operator VkSamplerYcbcrConversionCreateInfo &()
+    {
+      return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this);
+    }
+
     bool operator==( SamplerYcbcrConversionCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31304,11 +34946,16 @@ public:
 #ifdef VK_USE_PLATFORM_ANDROID_ANDROID
   struct AndroidHardwareBufferFormatPropertiesANDROID
   {
-    operator const VkAndroidHardwareBufferFormatPropertiesANDROID&() const
+    operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const
     {
       return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
     }
 
+    operator VkAndroidHardwareBufferFormatPropertiesANDROID &()
+    {
+      return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
+    }
+
     bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31397,11 +35044,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineColorBlendAdvancedStateCreateInfoEXT&() const
+    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
     }
 
+    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
+    }
+
     bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31496,11 +35148,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineCoverageModulationStateCreateInfoNV&() const
+    operator VkPipelineCoverageModulationStateCreateInfoNV const&() const
     {
       return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(this);
     }
 
+    operator VkPipelineCoverageModulationStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this);
+    }
+
     bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31579,11 +35236,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceQueueGlobalPriorityCreateInfoEXT&() const
+    operator VkDeviceQueueGlobalPriorityCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
     }
 
+    operator VkDeviceQueueGlobalPriorityCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
+    }
+
     bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31721,11 +35383,16 @@ public:
       return *this;
     }
 
-    operator const VkDebugUtilsMessengerCreateInfoEXT&() const
+    operator VkDebugUtilsMessengerCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(this);
     }
 
+    operator VkDebugUtilsMessengerCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this);
+    }
+
     bool operator==( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31807,11 +35474,16 @@ public:
       return *this;
     }
 
-    operator const VkPipelineRasterizationConservativeStateCreateInfoEXT&() const
+    operator VkPipelineRasterizationConservativeStateCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
     }
 
+    operator VkPipelineRasterizationConservativeStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
+    }
+
     bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -31902,11 +35574,16 @@ public:
       return *this;
     }
 
-    operator const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT&() const
+    operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const&() const
     {
       return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
     }
 
+    operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
+    }
+
     bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -32007,11 +35684,16 @@ public:
       return *this;
     }
 
-    operator const VkConditionalRenderingBeginInfoEXT&() const
+    operator VkConditionalRenderingBeginInfoEXT const&() const
     {
       return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(this);
     }
 
+    operator VkConditionalRenderingBeginInfoEXT &()
+    {
+      return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this);
+    }
+
     bool operator==( ConditionalRenderingBeginInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -32037,6 +35719,615 @@ public:
   };
   static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
 
+  enum class ShadingRatePaletteEntryNV
+  {
+    eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
+    e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV,
+    e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV,
+    e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV,
+    e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV,
+    e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV,
+    e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV,
+    e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV,
+    e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV,
+    e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV,
+    e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV,
+    e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
+  };
+
+  struct ShadingRatePaletteNV
+  {
+    ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
+                          const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
+      : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
+      , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
+    {
+    }
+
+    ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
+    }
+
+    ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
+      return *this;
+    }
+    ShadingRatePaletteNV& setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ )
+    {
+      shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_;
+      return *this;
+    }
+
+    ShadingRatePaletteNV& setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
+    {
+      pShadingRatePaletteEntries = pShadingRatePaletteEntries_;
+      return *this;
+    }
+
+    operator VkShadingRatePaletteNV const&() const
+    {
+      return *reinterpret_cast<const VkShadingRatePaletteNV*>(this);
+    }
+
+    operator VkShadingRatePaletteNV &()
+    {
+      return *reinterpret_cast<VkShadingRatePaletteNV*>(this);
+    }
+
+    bool operator==( ShadingRatePaletteNV const& rhs ) const
+    {
+      return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount )
+          && ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries );
+    }
+
+    bool operator!=( ShadingRatePaletteNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t shadingRatePaletteEntryCount;
+    const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
+  };
+  static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
+
+  struct PipelineViewportShadingRateImageStateCreateInfoNV
+  {
+    PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = 0,
+                                                       uint32_t viewportCount_ = 0,
+                                                       const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
+      : shadingRateImageEnable( shadingRateImageEnable_ )
+      , viewportCount( viewportCount_ )
+      , pShadingRatePalettes( pShadingRatePalettes_ )
+    {
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
+      return *this;
+    }
+    PipelineViewportShadingRateImageStateCreateInfoNV& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV& setShadingRateImageEnable( Bool32 shadingRateImageEnable_ )
+    {
+      shadingRateImageEnable = shadingRateImageEnable_;
+      return *this;
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
+    {
+      viewportCount = viewportCount_;
+      return *this;
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV& setPShadingRatePalettes( const ShadingRatePaletteNV* pShadingRatePalettes_ )
+    {
+      pShadingRatePalettes = pShadingRatePalettes_;
+      return *this;
+    }
+
+    operator VkPipelineViewportShadingRateImageStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
+    }
+
+    operator VkPipelineViewportShadingRateImageStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
+    }
+
+    bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shadingRateImageEnable == rhs.shadingRateImageEnable )
+          && ( viewportCount == rhs.viewportCount )
+          && ( pShadingRatePalettes == rhs.pShadingRatePalettes );
+    }
+
+    bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 shadingRateImageEnable;
+    uint32_t viewportCount;
+    const ShadingRatePaletteNV* pShadingRatePalettes;
+  };
+  static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct CoarseSampleOrderCustomNV
+  {
+    CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations,
+                               uint32_t sampleCount_ = 0,
+                               uint32_t sampleLocationCount_ = 0,
+                               const CoarseSampleLocationNV* pSampleLocations_ = nullptr )
+      : shadingRate( shadingRate_ )
+      , sampleCount( sampleCount_ )
+      , sampleLocationCount( sampleLocationCount_ )
+      , pSampleLocations( pSampleLocations_ )
+    {
+    }
+
+    CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
+    }
+
+    CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
+      return *this;
+    }
+    CoarseSampleOrderCustomNV& setShadingRate( ShadingRatePaletteEntryNV shadingRate_ )
+    {
+      shadingRate = shadingRate_;
+      return *this;
+    }
+
+    CoarseSampleOrderCustomNV& setSampleCount( uint32_t sampleCount_ )
+    {
+      sampleCount = sampleCount_;
+      return *this;
+    }
+
+    CoarseSampleOrderCustomNV& setSampleLocationCount( uint32_t sampleLocationCount_ )
+    {
+      sampleLocationCount = sampleLocationCount_;
+      return *this;
+    }
+
+    CoarseSampleOrderCustomNV& setPSampleLocations( const CoarseSampleLocationNV* pSampleLocations_ )
+    {
+      pSampleLocations = pSampleLocations_;
+      return *this;
+    }
+
+    operator VkCoarseSampleOrderCustomNV const&() const
+    {
+      return *reinterpret_cast<const VkCoarseSampleOrderCustomNV*>(this);
+    }
+
+    operator VkCoarseSampleOrderCustomNV &()
+    {
+      return *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this);
+    }
+
+    bool operator==( CoarseSampleOrderCustomNV const& rhs ) const
+    {
+      return ( shadingRate == rhs.shadingRate )
+          && ( sampleCount == rhs.sampleCount )
+          && ( sampleLocationCount == rhs.sampleLocationCount )
+          && ( pSampleLocations == rhs.pSampleLocations );
+    }
+
+    bool operator!=( CoarseSampleOrderCustomNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ShadingRatePaletteEntryNV shadingRate;
+    uint32_t sampleCount;
+    uint32_t sampleLocationCount;
+    const CoarseSampleLocationNV* pSampleLocations;
+  };
+  static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
+
+  enum class CoarseSampleOrderTypeNV
+  {
+    eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
+    eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV,
+    ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV,
+    eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
+  };
+
+  struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
+  {
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault,
+                                                        uint32_t customSampleOrderCount_ = 0,
+                                                        const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
+      : sampleOrderType( sampleOrderType_ )
+      , customSampleOrderCount( customSampleOrderCount_ )
+      , pCustomSampleOrders( pCustomSampleOrders_ )
+    {
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
+      return *this;
+    }
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ )
+    {
+      sampleOrderType = sampleOrderType_;
+      return *this;
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setCustomSampleOrderCount( uint32_t customSampleOrderCount_ )
+    {
+      customSampleOrderCount = customSampleOrderCount_;
+      return *this;
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setPCustomSampleOrders( const CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
+    {
+      pCustomSampleOrders = pCustomSampleOrders_;
+      return *this;
+    }
+
+    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
+    }
+
+    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
+    }
+
+    bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( sampleOrderType == rhs.sampleOrderType )
+          && ( customSampleOrderCount == rhs.customSampleOrderCount )
+          && ( pCustomSampleOrders == rhs.pCustomSampleOrders );
+    }
+
+    bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    CoarseSampleOrderTypeNV sampleOrderType;
+    uint32_t customSampleOrderCount;
+    const CoarseSampleOrderCustomNV* pCustomSampleOrders;
+  };
+  static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  enum class GeometryInstanceFlagBitsNVX
+  {
+    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
+  };
+
+  using GeometryInstanceFlagsNVX = Flags<GeometryInstanceFlagBitsNVX, VkGeometryInstanceFlagsNVX>;
+
+  VULKAN_HPP_INLINE GeometryInstanceFlagsNVX operator|( GeometryInstanceFlagBitsNVX bit0, GeometryInstanceFlagBitsNVX bit1 )
+  {
+    return GeometryInstanceFlagsNVX( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE GeometryInstanceFlagsNVX operator~( GeometryInstanceFlagBitsNVX bits )
+  {
+    return ~( GeometryInstanceFlagsNVX( bits ) );
+  }
+
+  template <> struct FlagTraits<GeometryInstanceFlagBitsNVX>
+  {
+    enum
+    {
+      allFlags = VkFlags(GeometryInstanceFlagBitsNVX::eTriangleCullDisable) | VkFlags(GeometryInstanceFlagBitsNVX::eTriangleCullFlipWinding) | VkFlags(GeometryInstanceFlagBitsNVX::eForceOpaque) | VkFlags(GeometryInstanceFlagBitsNVX::eForceNoOpaque)
+    };
+  };
+
+  enum class GeometryFlagBitsNVX
+  {
+    eOpaque = VK_GEOMETRY_OPAQUE_BIT_NVX,
+    eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX
+  };
+
+  using GeometryFlagsNVX = Flags<GeometryFlagBitsNVX, VkGeometryFlagsNVX>;
+
+  VULKAN_HPP_INLINE GeometryFlagsNVX operator|( GeometryFlagBitsNVX bit0, GeometryFlagBitsNVX bit1 )
+  {
+    return GeometryFlagsNVX( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE GeometryFlagsNVX operator~( GeometryFlagBitsNVX bits )
+  {
+    return ~( GeometryFlagsNVX( bits ) );
+  }
+
+  template <> struct FlagTraits<GeometryFlagBitsNVX>
+  {
+    enum
+    {
+      allFlags = VkFlags(GeometryFlagBitsNVX::eOpaque) | VkFlags(GeometryFlagBitsNVX::eNoDuplicateAnyHitInvocation)
+    };
+  };
+
+  enum class BuildAccelerationStructureFlagBitsNVX
+  {
+    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
+  };
+
+  using BuildAccelerationStructureFlagsNVX = Flags<BuildAccelerationStructureFlagBitsNVX, VkBuildAccelerationStructureFlagsNVX>;
+
+  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNVX operator|( BuildAccelerationStructureFlagBitsNVX bit0, BuildAccelerationStructureFlagBitsNVX bit1 )
+  {
+    return BuildAccelerationStructureFlagsNVX( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNVX operator~( BuildAccelerationStructureFlagBitsNVX bits )
+  {
+    return ~( BuildAccelerationStructureFlagsNVX( bits ) );
+  }
+
+  template <> struct FlagTraits<BuildAccelerationStructureFlagBitsNVX>
+  {
+    enum
+    {
+      allFlags = VkFlags(BuildAccelerationStructureFlagBitsNVX::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNVX::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNVX::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNVX::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNVX::eLowMemory)
+    };
+  };
+
+  enum class CopyAccelerationStructureModeNVX
+  {
+    eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX,
+    eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX
+  };
+
+  enum class AccelerationStructureTypeNVX
+  {
+    eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX,
+    eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX
+  };
+
+  enum class GeometryTypeNVX
+  {
+    eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NVX,
+    eAabbs = VK_GEOMETRY_TYPE_AABBS_NVX
+  };
+
+  struct GeometryNVX
+  {
+    GeometryNVX( GeometryTypeNVX geometryType_ = GeometryTypeNVX::eTriangles,
+                 GeometryDataNVX geometry_ = GeometryDataNVX(),
+                 GeometryFlagsNVX flags_ = GeometryFlagsNVX() )
+      : geometryType( geometryType_ )
+      , geometry( geometry_ )
+      , flags( flags_ )
+    {
+    }
+
+    GeometryNVX( VkGeometryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryNVX ) );
+    }
+
+    GeometryNVX& operator=( VkGeometryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryNVX ) );
+      return *this;
+    }
+    GeometryNVX& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    GeometryNVX& setGeometryType( GeometryTypeNVX geometryType_ )
+    {
+      geometryType = geometryType_;
+      return *this;
+    }
+
+    GeometryNVX& setGeometry( GeometryDataNVX geometry_ )
+    {
+      geometry = geometry_;
+      return *this;
+    }
+
+    GeometryNVX& setFlags( GeometryFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkGeometryNVX const&() const
+    {
+      return *reinterpret_cast<const VkGeometryNVX*>(this);
+    }
+
+    operator VkGeometryNVX &()
+    {
+      return *reinterpret_cast<VkGeometryNVX*>(this);
+    }
+
+    bool operator==( GeometryNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( geometryType == rhs.geometryType )
+          && ( geometry == rhs.geometry )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( GeometryNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eGeometryNVX;
+
+  public:
+    const void* pNext = nullptr;
+    GeometryTypeNVX geometryType;
+    GeometryDataNVX geometry;
+    GeometryFlagsNVX flags;
+  };
+  static_assert( sizeof( GeometryNVX ) == sizeof( VkGeometryNVX ), "struct and wrapper have different size!" );
+
+  struct AccelerationStructureCreateInfoNVX
+  {
+    AccelerationStructureCreateInfoNVX( AccelerationStructureTypeNVX type_ = AccelerationStructureTypeNVX::eTopLevel,
+                                        BuildAccelerationStructureFlagsNVX flags_ = BuildAccelerationStructureFlagsNVX(),
+                                        DeviceSize compactedSize_ = 0,
+                                        uint32_t instanceCount_ = 0,
+                                        uint32_t geometryCount_ = 0,
+                                        const GeometryNVX* pGeometries_ = nullptr )
+      : type( type_ )
+      , flags( flags_ )
+      , compactedSize( compactedSize_ )
+      , instanceCount( instanceCount_ )
+      , geometryCount( geometryCount_ )
+      , pGeometries( pGeometries_ )
+    {
+    }
+
+    AccelerationStructureCreateInfoNVX( VkAccelerationStructureCreateInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNVX ) );
+    }
+
+    AccelerationStructureCreateInfoNVX& operator=( VkAccelerationStructureCreateInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNVX ) );
+      return *this;
+    }
+    AccelerationStructureCreateInfoNVX& setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNVX& setType( AccelerationStructureTypeNVX type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNVX& setFlags( BuildAccelerationStructureFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNVX& setCompactedSize( DeviceSize compactedSize_ )
+    {
+      compactedSize = compactedSize_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNVX& setInstanceCount( uint32_t instanceCount_ )
+    {
+      instanceCount = instanceCount_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNVX& setGeometryCount( uint32_t geometryCount_ )
+    {
+      geometryCount = geometryCount_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNVX& setPGeometries( const GeometryNVX* pGeometries_ )
+    {
+      pGeometries = pGeometries_;
+      return *this;
+    }
+
+    operator VkAccelerationStructureCreateInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkAccelerationStructureCreateInfoNVX*>(this);
+    }
+
+    operator VkAccelerationStructureCreateInfoNVX &()
+    {
+      return *reinterpret_cast<VkAccelerationStructureCreateInfoNVX*>(this);
+    }
+
+    bool operator==( AccelerationStructureCreateInfoNVX 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
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAccelerationStructureCreateInfoNVX;
+
+  public:
+    const void* pNext = nullptr;
+    AccelerationStructureTypeNVX type;
+    BuildAccelerationStructureFlagsNVX flags;
+    DeviceSize compactedSize;
+    uint32_t instanceCount;
+    uint32_t geometryCount;
+    const GeometryNVX* pGeometries;
+  };
+  static_assert( sizeof( AccelerationStructureCreateInfoNVX ) == sizeof( VkAccelerationStructureCreateInfoNVX ), "struct and wrapper have different size!" );
+
   template<typename Dispatch = DispatchLoaderStatic>
   Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() );
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -32548,6 +36839,55 @@ public:
     template<typename Dispatch = DispatchLoaderStatic>
     void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const;
 
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyAccelerationStructureNVX( AccelerationStructureNVX dst, AccelerationStructureNVX src, CopyAccelerationStructureModeNVX mode, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void writeAccelerationStructurePropertiesNVX( AccelerationStructureNVX accelerationStructure, QueryType queryType, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    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;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void buildAccelerationStructureNVX( AccelerationStructureTypeNVX type, uint32_t instanceCount, Buffer instanceData, DeviceSize instanceOffset, ArrayProxy<const GeometryNVX> geometries, BuildAccelerationStructureFlagsNVX flags, Bool32 update, AccelerationStructureNVX dst, AccelerationStructureNVX src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    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;
+
 
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
@@ -33598,6 +37938,156 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const
+  {
+    d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D*>( pExclusiveScissors ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d ) const
+  {
+    d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast<const VkRect2D*>( exclusiveScissors.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const
+  {
+    d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const
+  {
+    d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
+  {
+    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV*>( pShadingRatePalettes ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
+  {
+    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast<const VkShadingRatePaletteNV*>( shadingRatePalettes.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
+  {
+    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrderCount, reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( pCustomSampleOrders ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
+  {
+    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrders.size() , reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( customSampleOrders.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d) const
+  {
+    d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d ) const
+  {
+    d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+  {
+    d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+  {
+    d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  {
+    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  {
+    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNVX( AccelerationStructureNVX dst, AccelerationStructureNVX src, CopyAccelerationStructureModeNVX mode, Dispatch const &d) const
+  {
+    d.vkCmdCopyAccelerationStructureNVX( m_commandBuffer, static_cast<VkAccelerationStructureNVX>( dst ), static_cast<VkAccelerationStructureNVX>( src ), static_cast<VkCopyAccelerationStructureModeNVX>( mode ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNVX( AccelerationStructureNVX dst, AccelerationStructureNVX src, CopyAccelerationStructureModeNVX mode, Dispatch const &d ) const
+  {
+    d.vkCmdCopyAccelerationStructureNVX( m_commandBuffer, static_cast<VkAccelerationStructureNVX>( dst ), static_cast<VkAccelerationStructureNVX>( src ), static_cast<VkCopyAccelerationStructureModeNVX>( mode ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructurePropertiesNVX( AccelerationStructureNVX accelerationStructure, QueryType queryType, QueryPool queryPool, uint32_t query, Dispatch const &d) const
+  {
+    d.vkCmdWriteAccelerationStructurePropertiesNVX( m_commandBuffer, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), query );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructurePropertiesNVX( AccelerationStructureNVX accelerationStructure, QueryType queryType, QueryPool queryPool, uint32_t query, Dispatch const &d ) const
+  {
+    d.vkCmdWriteAccelerationStructurePropertiesNVX( m_commandBuffer, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), query );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  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
+  {
+    d.vkCmdBuildAccelerationStructureNVX( m_commandBuffer, static_cast<VkAccelerationStructureTypeNVX>( type ), instanceCount, static_cast<VkBuffer>( instanceData ), instanceOffset, geometryCount, reinterpret_cast<const VkGeometryNVX*>( pGeometries ), static_cast<VkBuildAccelerationStructureFlagsNVX>( flags ), update, static_cast<VkAccelerationStructureNVX>( dst ), static_cast<VkAccelerationStructureNVX>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNVX( AccelerationStructureTypeNVX type, uint32_t instanceCount, Buffer instanceData, DeviceSize instanceOffset, ArrayProxy<const GeometryNVX> geometries, BuildAccelerationStructureFlagsNVX flags, Bool32 update, AccelerationStructureNVX dst, AccelerationStructureNVX src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const
+  {
+    d.vkCmdBuildAccelerationStructureNVX( m_commandBuffer, static_cast<VkAccelerationStructureTypeNVX>( type ), instanceCount, static_cast<VkBuffer>( instanceData ), instanceOffset, geometries.size() , reinterpret_cast<const VkGeometryNVX*>( geometries.data() ), static_cast<VkBuildAccelerationStructureFlagsNVX>( flags ), update, static_cast<VkAccelerationStructureNVX>( dst ), static_cast<VkAccelerationStructureNVX>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  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
+  {
+    d.vkCmdTraceRaysNVX( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, width, height );
+  }
+#else
+  template<typename Dispatch>
+  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
+  {
+    d.vkCmdTraceRaysNVX( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, width, height );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   struct SubmitInfo
   {
     SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
@@ -33675,11 +38165,16 @@ public:
       return *this;
     }
 
-    operator const VkSubmitInfo&() const
+    operator VkSubmitInfo const&() const
     {
       return *reinterpret_cast<const VkSubmitInfo*>(this);
     }
 
+    operator VkSubmitInfo &()
+    {
+      return *reinterpret_cast<VkSubmitInfo*>(this);
+    }
+
     bool operator==( SubmitInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -33951,6 +38446,8 @@ public:
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   class Device;
 
+  template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNVX,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
+  using UniqueAccelerationStructureNVX = UniqueHandle<AccelerationStructureNVX,DispatchLoaderStatic>;
   template <typename Dispatch> class UniqueHandleTraits<Buffer,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
   using UniqueBuffer = UniqueHandle<Buffer,DispatchLoaderStatic>;
   template <typename Dispatch> class UniqueHandleTraits<BufferView,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
@@ -35198,8 +39695,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -35207,8 +39704,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -35216,8 +39713,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -35225,8 +39722,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -35337,8 +39834,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -35346,8 +39843,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -35395,8 +39892,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<T...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
 
@@ -35409,6 +39906,89 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNVX* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<AccelerationStructureNVX>::type createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<AccelerationStructureNVX,Dispatch>>::type createAccelerationStructureNVXUnique( const AccelerationStructureCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( AccelerationStructureNVX accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements2KHR getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindAccelerationStructureMemoryNVX( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNVX* pBindInfos, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindAccelerationStructureMemoryNVX( ArrayProxy<const BindAccelerationStructureMemoryInfoNVX> bindInfos, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getRaytracingShaderHandlesNVX( 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 <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getRaytracingShaderHandlesNVX( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, size_t dataSize, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createRaytracingPipelinesNVX( PipelineCache pipelineCache, uint32_t createInfoCount, const RaytracingPipelineCreateInfoNVX* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRaytracingPipelinesNVX( PipelineCache pipelineCache, ArrayProxy<const RaytracingPipelineCreateInfoNVX> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
+    ResultValueType<Pipeline>::type createRaytracingPipelineNVX( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRaytracingPipelinesNVXUnique( PipelineCache pipelineCache, ArrayProxy<const RaytracingPipelineCreateInfoNVX> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
+    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRaytracingPipelineNVXUnique( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
@@ -37991,10 +42571,10 @@ public:
     d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
     d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
@@ -38014,10 +42594,10 @@ public:
     d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
     d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
@@ -38037,10 +42617,10 @@ public:
     d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
     d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
@@ -38060,10 +42640,10 @@ public:
     d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
     d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
@@ -38318,10 +42898,10 @@ public:
     d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return support;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
     d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return structureChain;
@@ -38341,10 +42921,10 @@ public:
     d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return support;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
     d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return structureChain;
@@ -38461,10 +43041,10 @@ public:
     Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
     return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
     Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
@@ -38489,6 +43069,197 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCompileDeferredNVX( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNVX( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkCompileDeferredNVX( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNVX" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNVX* pAccelerationStructure, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateAccelerationStructureNVX( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkAccelerationStructureNVX*>( pAccelerationStructure ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<AccelerationStructureNVX>::type Device::createAccelerationStructureNVX( const AccelerationStructureCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    AccelerationStructureNVX accelerationStructure;
+    Result result = static_cast<Result>( d.vkCreateAccelerationStructureNVX( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNVX*>( &accelerationStructure ) ) );
+    return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVX" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNVX,Dispatch>>::type Device::createAccelerationStructureNVXUnique( const AccelerationStructureCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    AccelerationStructureNVX accelerationStructure;
+    Result result = static_cast<Result>( d.vkCreateAccelerationStructureNVX( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNVX*>( &accelerationStructure ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<AccelerationStructureNVX,Dispatch>( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVXUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyAccelerationStructureNVX( m_device, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNVX( AccelerationStructureNVX accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyAccelerationStructureNVX( m_device, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNVX accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyAccelerationStructureNVX( m_device, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNVX accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyAccelerationStructureNVX( m_device, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetAccelerationStructureMemoryRequirementsNVX( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNVX*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d ) const
+  {
+    MemoryRequirements2KHR memoryRequirements;
+    d.vkGetAccelerationStructureMemoryRequirementsNVX( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNVX*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetAccelerationStructureScratchMemoryRequirementsNVX( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNVX*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureScratchMemoryRequirementsNVX( const AccelerationStructureMemoryRequirementsInfoNVX & info, Dispatch const &d ) const
+  {
+    MemoryRequirements2KHR memoryRequirements;
+    d.vkGetAccelerationStructureScratchMemoryRequirementsNVX( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNVX*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNVX( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNVX* pBindInfos, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkBindAccelerationStructureMemoryNVX( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNVX*>( pBindInfos ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNVX( ArrayProxy<const BindAccelerationStructureMemoryInfoNVX> bindInfos, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNVX( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNVX*>( bindInfos.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNVX" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  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<Result>( d.vkGetRaytracingShaderHandlesNVX( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Allocator, typename Dispatch> 
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getRaytracingShaderHandlesNVX( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d ) const
+  {
+    std::vector<uint8_t,Allocator> data( dataSize );
+    Result result = static_cast<Result>( d.vkGetRaytracingShaderHandlesNVX( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( uint8_t ) , reinterpret_cast<void*>( data.data() ) ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getRaytracingShaderHandlesNVX" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetAccelerationStructureHandleNVX( m_device, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), dataSize, pData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Allocator, typename Dispatch> 
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getAccelerationStructureHandleNVX( AccelerationStructureNVX accelerationStructure, size_t dataSize, Dispatch const &d ) const
+  {
+    std::vector<uint8_t,Allocator> data( dataSize );
+    Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNVX( m_device, static_cast<VkAccelerationStructureNVX>( accelerationStructure ), data.size() * sizeof( uint8_t ) , reinterpret_cast<void*>( data.data() ) ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNVX" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createRaytracingPipelinesNVX( PipelineCache pipelineCache, uint32_t createInfoCount, const RaytracingPipelineCreateInfoNVX* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkRaytracingPipelineCreateInfoNVX*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Allocator, typename Dispatch> 
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRaytracingPipelinesNVX( PipelineCache pipelineCache, ArrayProxy<const RaytracingPipelineCreateInfoNVX> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
+    Result result = static_cast<Result>( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRaytracingPipelineCreateInfoNVX*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRaytracingPipelinesNVX" );
+  }
+  template <typename Allocator, typename Dispatch> 
+  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRaytracingPipelineNVX( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRaytracingPipelineCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+    return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRaytracingPipelineNVX" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Allocator, typename Dispatch> 
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRaytracingPipelinesNVXUnique( PipelineCache pipelineCache, ArrayProxy<const RaytracingPipelineCreateInfoNVX> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
+    std::vector<UniquePipeline, Allocator> pipelines;
+    pipelines.reserve( createInfos.size() );
+    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
+    Result result = static_cast<Result>(d.vkCreateRaytracingPipelinesNVX( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRaytracingPipelineCreateInfoNVX*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
+    {
+      pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
+    }
+
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRaytracingPipelinesNVXUnique" );
+  }
+  template <typename Allocator, typename Dispatch> 
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRaytracingPipelineNVXUnique( PipelineCache pipelineCache, const RaytracingPipelineCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateRaytracingPipelinesNVX( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRaytracingPipelineCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRaytracingPipelineNVXUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
 
   template <typename Dispatch> class UniqueHandleTraits<Device,Dispatch> {public: using deleter = ObjectDestroy<NoParent,Dispatch>; };
@@ -38544,6 +43315,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getProperties(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -38743,8 +43516,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getFeatures2(Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -38752,8 +43525,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -38761,8 +43534,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getProperties2(Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -38770,8 +43543,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<T...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -38793,8 +43566,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<T...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -38802,8 +43575,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<T...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -38942,8 +43715,8 @@ public:
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderStatic>
     ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename ...T, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<T...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderStatic>
@@ -39017,6 +43790,14 @@ public:
     d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
     return properties;
   }
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties(Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    PhysicalDeviceProperties& properties = structureChain.template get<PhysicalDeviceProperties>();
+    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
+    return structureChain;
+  }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -39536,10 +44317,10 @@ public:
     d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return features;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
     d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return structureChain;
@@ -39559,10 +44340,10 @@ public:
     d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return features;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
     d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return structureChain;
@@ -39582,10 +44363,10 @@ public:
     d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return properties;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getProperties2(Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2(Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
     d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return structureChain;
@@ -39605,10 +44386,10 @@ public:
     d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return properties;
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
     d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return structureChain;
@@ -39658,10 +44439,10 @@ public:
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
@@ -39681,10 +44462,10 @@ public:
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
@@ -40002,10 +44783,10 @@ public:
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
     return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
   }
-  template <typename ...T, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
   {
-    StructureChain<T...> structureChain;
+    StructureChain<X, Y, Z...> structureChain;
     SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
@@ -40236,11 +45017,16 @@ public:
       return *this;
     }
 
-    operator const VkCmdProcessCommandsInfoNVX&() const
+    operator VkCmdProcessCommandsInfoNVX const&() const
     {
       return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this);
     }
 
+    operator VkCmdProcessCommandsInfoNVX &()
+    {
+      return *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this);
+    }
+
     bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -40282,11 +45068,16 @@ public:
 
   struct PhysicalDeviceGroupProperties
   {
-    operator const VkPhysicalDeviceGroupProperties&() const
+    operator VkPhysicalDeviceGroupProperties const&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(this);
     }
 
+    operator VkPhysicalDeviceGroupProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this);
+    }
+
     bool operator==( PhysicalDeviceGroupProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -41219,11 +46010,16 @@ public:
       return *this;
     }
 
-    operator const VkDeviceGroupDeviceCreateInfo&() const
+    operator VkDeviceGroupDeviceCreateInfo const&() const
     {
       return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(this);
     }
 
+    operator VkDeviceGroupDeviceCreateInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this);
+    }
+
     bool operator==( DeviceGroupDeviceCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -41315,11 +46111,16 @@ public:
       return *this;
     }
 
-    operator const VkBaseOutStructure&() const
+    operator VkBaseOutStructure const&() const
     {
       return *reinterpret_cast<const VkBaseOutStructure*>(this);
     }
 
+    operator VkBaseOutStructure &()
+    {
+      return *reinterpret_cast<VkBaseOutStructure*>(this);
+    }
+
     bool operator==( BaseOutStructure const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -41358,11 +46159,16 @@ public:
       return *this;
     }
 
-    operator const VkBaseInStructure&() const
+    operator VkBaseInStructure const&() const
     {
       return *reinterpret_cast<const VkBaseInStructure*>(this);
     }
 
+    operator VkBaseInStructure &()
+    {
+      return *reinterpret_cast<VkBaseInStructure*>(this);
+    }
+
     bool operator==( BaseInStructure const& rhs ) const
     {
       return ( sType == rhs.sType )
@@ -41448,6 +46254,7 @@ public:
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceInlineUniformBlockPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetInlineUniformBlockEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DescriptorPoolCreateInfo, DescriptorPoolInlineUniformBlockCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
@@ -41486,6 +46293,28 @@ public:
   template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewASTCDecodeModeEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceASTCDecodeFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceASTCDecodeFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineRepresentativeFragmentTestStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportExclusiveScissorStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties, PhysicalDeviceShadingRateImagePropertiesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMeshShaderPropertiesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<WriteDescriptorSet, DescriptorAccelerationStructureInfoNVX>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRaytracingPropertiesNVX>{ enum { value = true }; };
   template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfo>{ enum { value = true }; };
   template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfo>{ enum { value = true }; };
@@ -41537,6 +46366,8 @@ public:
   template <> struct isStructureChainValid<InstanceCreateInfo, DebugUtilsMessengerCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DescriptorSetLayoutCreateInfo, DescriptorSetLayoutBindingFlagsCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportShadingRateImageStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportCoarseSampleOrderStateCreateInfoNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, DeviceGroupDeviceCreateInfo>{ enum { value = true }; };
   VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits)
   {
@@ -42051,6 +46882,7 @@ public:
     case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal: return "DepthAttachmentStencilReadOnlyOptimal";
     case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR";
     case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
+    case ImageLayout::eShadingRateOptimalNV: return "ShadingRateOptimalNV";
     default: return "invalid";
     }
   }
@@ -42153,6 +46985,7 @@ public:
     case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic";
     case DescriptorType::eInputAttachment: return "InputAttachment";
     case DescriptorType::eInlineUniformBlockEXT: return "InlineUniformBlockEXT";
+    case DescriptorType::eAccelerationStructureNVX: return "AccelerationStructureNVX";
     default: return "invalid";
     }
   }
@@ -42164,6 +46997,7 @@ public:
     case QueryType::eOcclusion: return "Occlusion";
     case QueryType::ePipelineStatistics: return "PipelineStatistics";
     case QueryType::eTimestamp: return "Timestamp";
+    case QueryType::eCompactedSizeNVX: return "CompactedSizeNVX";
     default: return "invalid";
     }
   }
@@ -42188,6 +47022,7 @@ public:
     {
     case PipelineBindPoint::eGraphics: return "Graphics";
     case PipelineBindPoint::eCompute: return "Compute";
+    case PipelineBindPoint::eRaytracingNVX: return "RaytracingNVX";
     default: return "invalid";
     }
   }
@@ -42885,6 +47720,7 @@ public:
     case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
     case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
     case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD";
+    case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV: return "PhysicalDeviceCornerSampledImageFeaturesNV";
     case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV";
     case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV";
     case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV";
@@ -42991,6 +47827,23 @@ public:
     case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT: return "PhysicalDeviceDescriptorIndexingPropertiesEXT";
     case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT: return "DescriptorSetVariableDescriptorCountAllocateInfoEXT";
     case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT: return "DescriptorSetVariableDescriptorCountLayoutSupportEXT";
+    case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV: return "PipelineViewportShadingRateImageStateCreateInfoNV";
+    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::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV: return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
+    case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
     case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT";
     case StructureType::ePhysicalDevice8BitStorageFeaturesKHR: return "PhysicalDevice8BitStorageFeaturesKHR";
     case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT";
@@ -43000,6 +47853,13 @@ public:
     case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
     case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT";
     case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT: return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
+    case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV: return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
+    case StructureType::ePhysicalDeviceMeshShaderFeaturesNV: return "PhysicalDeviceMeshShaderFeaturesNV";
+    case StructureType::ePhysicalDeviceMeshShaderPropertiesNV: return "PhysicalDeviceMeshShaderPropertiesNV";
+    case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV: return "PhysicalDeviceFragmentShaderBarycentricFeaturesNV";
+    case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV: return "PhysicalDeviceShaderImageFootprintFeaturesNV";
+    case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV: return "PipelineViewportExclusiveScissorStateCreateInfoNV";
+    case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV: return "PhysicalDeviceExclusiveScissorFeaturesNV";
     case StructureType::eCheckpointDataNV: return "CheckpointDataNV";
     case StructureType::eQueueFamilyCheckpointPropertiesNV: return "QueueFamilyCheckpointPropertiesNV";
     case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR: return "PhysicalDeviceVulkanMemoryModelFeaturesKHR";
@@ -43033,6 +47893,9 @@ public:
     case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV";
     case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT";
     case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT";
+    case DynamicState::eViewportShadingRatePaletteNV: return "ViewportShadingRatePaletteNV";
+    case DynamicState::eViewportCoarseSampleOrderNV: return "ViewportCoarseSampleOrderNV";
+    case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
     default: return "invalid";
     }
   }
@@ -43088,6 +47951,7 @@ public:
     case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX";
     case ObjectType::eDebugUtilsMessengerEXT: return "DebugUtilsMessengerEXT";
     case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT";
+    case ObjectType::eAccelerationStructureNVX: return "AccelerationStructureNVX";
     default: return "invalid";
     }
   }
@@ -43205,6 +48069,9 @@ public:
     case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX";
     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";
     default: return "invalid";
     }
   }
@@ -43234,6 +48101,9 @@ public:
     if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | ";
     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 | ";
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
 
@@ -43251,6 +48121,7 @@ public:
     case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer";
     case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer";
     case BufferUsageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
+    case BufferUsageFlagBits::eRaytracingNVX: return "RaytracingNVX";
     default: return "invalid";
     }
   }
@@ -43269,6 +48140,7 @@ public:
     if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | ";
     if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | ";
     if (value & BufferUsageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
+    if (value & BufferUsageFlagBits::eRaytracingNVX) result += "RaytracingNVX | ";
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
 
@@ -43307,6 +48179,14 @@ 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::eTaskNV: return "TaskNV";
+    case ShaderStageFlagBits::eMeshNV: return "MeshNV";
     default: return "invalid";
     }
   }
@@ -43323,6 +48203,14 @@ 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::eTaskNV) result += "TaskNV | ";
+    if (value & ShaderStageFlagBits::eMeshNV) result += "MeshNV | ";
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
 
@@ -43338,6 +48226,7 @@ public:
     case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
     case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment";
     case ImageUsageFlagBits::eInputAttachment: return "InputAttachment";
+    case ImageUsageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
     default: return "invalid";
     }
   }
@@ -43354,6 +48243,7 @@ public:
     if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
     if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | ";
     if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | ";
+    if (value & ImageUsageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | ";
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
 
@@ -43373,6 +48263,7 @@ public:
     case ImageCreateFlagBits::eExtendedUsage: return "ExtendedUsage";
     case ImageCreateFlagBits::eProtected: return "Protected";
     case ImageCreateFlagBits::eDisjoint: return "Disjoint";
+    case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV";
     case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT";
     default: return "invalid";
     }
@@ -43394,6 +48285,7 @@ public:
     if (value & ImageCreateFlagBits::eExtendedUsage) result += "ExtendedUsage | ";
     if (value & ImageCreateFlagBits::eProtected) result += "Protected | ";
     if (value & ImageCreateFlagBits::eDisjoint) result += "Disjoint | ";
+    if (value & ImageCreateFlagBits::eCornerSampledNV) result += "CornerSampledNV | ";
     if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | ";
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
@@ -43407,6 +48299,7 @@ public:
     case PipelineCreateFlagBits::eDerivative: return "Derivative";
     case PipelineCreateFlagBits::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex";
     case PipelineCreateFlagBits::eDispatchBase: return "DispatchBase";
+    case PipelineCreateFlagBits::eDeferCompileNVX: return "DeferCompileNVX";
     default: return "invalid";
     }
   }
@@ -43420,6 +48313,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 | ";
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
 
@@ -43714,6 +48608,10 @@ public:
     case PipelineStageFlagBits::eAllCommands: return "AllCommands";
     case PipelineStageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
     case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX";
+    case PipelineStageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
+    case PipelineStageFlagBits::eRaytracingNVX: return "RaytracingNVX";
+    case PipelineStageFlagBits::eTaskShaderNV: return "TaskShaderNV";
+    case PipelineStageFlagBits::eMeshShaderNV: return "MeshShaderNV";
     default: return "invalid";
     }
   }
@@ -43741,6 +48639,10 @@ public:
     if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | ";
     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::eTaskShaderNV) result += "TaskShaderNV | ";
+    if (value & PipelineStageFlagBits::eMeshShaderNV) result += "MeshShaderNV | ";
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
 
@@ -44087,6 +48989,7 @@ public:
     case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt";
     case DebugReportObjectTypeEXT::eSamplerYcbcrConversion: return "SamplerYcbcrConversion";
     case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate";
+    case DebugReportObjectTypeEXT::eAccelerationStructureNVX: return "AccelerationStructureNVX";
     default: return "invalid";
     }
   }
@@ -44854,6 +49757,135 @@ public:
     return "{" + result.substr(0, result.size() - 3) + "}";
   }
 
+  VULKAN_HPP_INLINE std::string to_string(ShadingRatePaletteEntryNV value)
+  {
+    switch (value)
+    {
+    case ShadingRatePaletteEntryNV::eNoInvocations: return "NoInvocations";
+    case ShadingRatePaletteEntryNV::e16InvocationsPerPixel: return "16InvocationsPerPixel";
+    case ShadingRatePaletteEntryNV::e8InvocationsPerPixel: return "8InvocationsPerPixel";
+    case ShadingRatePaletteEntryNV::e4InvocationsPerPixel: return "4InvocationsPerPixel";
+    case ShadingRatePaletteEntryNV::e2InvocationsPerPixel: return "2InvocationsPerPixel";
+    case ShadingRatePaletteEntryNV::e1InvocationPerPixel: return "1InvocationPerPixel";
+    case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels";
+    case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels";
+    case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels";
+    case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels";
+    case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels";
+    case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels";
+    default: return "invalid";
+    }
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(CoarseSampleOrderTypeNV value)
+  {
+    switch (value)
+    {
+    case CoarseSampleOrderTypeNV::eDefault: return "Default";
+    case CoarseSampleOrderTypeNV::eCustom: return "Custom";
+    case CoarseSampleOrderTypeNV::ePixelMajor: return "PixelMajor";
+    case CoarseSampleOrderTypeNV::eSampleMajor: return "SampleMajor";
+    default: return "invalid";
+    }
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagBitsNVX value)
+  {
+    switch (value)
+    {
+    case GeometryInstanceFlagBitsNVX::eTriangleCullDisable: return "TriangleCullDisable";
+    case GeometryInstanceFlagBitsNVX::eTriangleCullFlipWinding: return "TriangleCullFlipWinding";
+    case GeometryInstanceFlagBitsNVX::eForceOpaque: return "ForceOpaque";
+    case GeometryInstanceFlagBitsNVX::eForceNoOpaque: return "ForceNoOpaque";
+    default: return "invalid";
+    }
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagsNVX 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 | ";
+    return "{" + result.substr(0, result.size() - 3) + "}";
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(GeometryFlagBitsNVX value)
+  {
+    switch (value)
+    {
+    case GeometryFlagBitsNVX::eOpaque: return "Opaque";
+    case GeometryFlagBitsNVX::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation";
+    default: return "invalid";
+    }
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(GeometryFlagsNVX value)
+  {
+    if (!value) return "{}";
+    std::string result;
+    if (value & GeometryFlagBitsNVX::eOpaque) result += "Opaque | ";
+    if (value & GeometryFlagBitsNVX::eNoDuplicateAnyHitInvocation) result += "NoDuplicateAnyHitInvocation | ";
+    return "{" + result.substr(0, result.size() - 3) + "}";
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagBitsNVX 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";
+    default: return "invalid";
+    }
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagsNVX 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 | ";
+    return "{" + result.substr(0, result.size() - 3) + "}";
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(CopyAccelerationStructureModeNVX value)
+  {
+    switch (value)
+    {
+    case CopyAccelerationStructureModeNVX::eClone: return "Clone";
+    case CopyAccelerationStructureModeNVX::eCompact: return "Compact";
+    default: return "invalid";
+    }
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(AccelerationStructureTypeNVX value)
+  {
+    switch (value)
+    {
+    case AccelerationStructureTypeNVX::eTopLevel: return "TopLevel";
+    case AccelerationStructureTypeNVX::eBottomLevel: return "BottomLevel";
+    default: return "invalid";
+    }
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(GeometryTypeNVX value)
+  {
+    switch (value)
+    {
+    case GeometryTypeNVX::eTriangles: return "Triangles";
+    case GeometryTypeNVX::eAabbs: return "Aabbs";
+    default: return "invalid";
+    }
+  }
+
   class DispatchLoaderDynamic
   {
   public:
@@ -44866,6 +49898,7 @@ public:
     PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
     PFN_vkAllocateMemory vkAllocateMemory = 0;
     PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
+    PFN_vkBindAccelerationStructureMemoryNVX vkBindAccelerationStructureMemoryNVX = 0;
     PFN_vkBindBufferMemory vkBindBufferMemory = 0;
     PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
     PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
@@ -44880,11 +49913,14 @@ public:
     PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
     PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
     PFN_vkCmdBindPipeline vkCmdBindPipeline = 0;
+    PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0;
     PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0;
     PFN_vkCmdBlitImage vkCmdBlitImage = 0;
+    PFN_vkCmdBuildAccelerationStructureNVX vkCmdBuildAccelerationStructureNVX = 0;
     PFN_vkCmdClearAttachments vkCmdClearAttachments = 0;
     PFN_vkCmdClearColorImage vkCmdClearColorImage = 0;
     PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0;
+    PFN_vkCmdCopyAccelerationStructureNVX vkCmdCopyAccelerationStructureNVX = 0;
     PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0;
     PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0;
     PFN_vkCmdCopyImage vkCmdCopyImage = 0;
@@ -44905,6 +49941,9 @@ public:
     PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
     PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
     PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0;
+    PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
+    PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0;
+    PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0;
     PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0;
     PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0;
     PFN_vkCmdEndQuery vkCmdEndQuery = 0;
@@ -44926,12 +49965,14 @@ public:
     PFN_vkCmdResolveImage vkCmdResolveImage = 0;
     PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0;
     PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0;
+    PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0;
     PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0;
     PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0;
     PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
     PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
     PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
     PFN_vkCmdSetEvent vkCmdSetEvent = 0;
+    PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
     PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
     PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
     PFN_vkCmdSetScissor vkCmdSetScissor = 0;
@@ -44939,11 +49980,16 @@ public:
     PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0;
     PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0;
     PFN_vkCmdSetViewport vkCmdSetViewport = 0;
+    PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0;
     PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0;
+    PFN_vkCmdTraceRaysNVX vkCmdTraceRaysNVX = 0;
     PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
     PFN_vkCmdWaitEvents vkCmdWaitEvents = 0;
+    PFN_vkCmdWriteAccelerationStructurePropertiesNVX vkCmdWriteAccelerationStructurePropertiesNVX = 0;
     PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;
     PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
+    PFN_vkCompileDeferredNVX vkCompileDeferredNVX = 0;
+    PFN_vkCreateAccelerationStructureNVX vkCreateAccelerationStructureNVX = 0;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@@ -44981,6 +50027,7 @@ public:
     PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
     PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
     PFN_vkCreateQueryPool vkCreateQueryPool = 0;
+    PFN_vkCreateRaytracingPipelinesNVX vkCreateRaytracingPipelinesNVX = 0;
     PFN_vkCreateRenderPass vkCreateRenderPass = 0;
     PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
     PFN_vkCreateSampler vkCreateSampler = 0;
@@ -45009,6 +50056,7 @@ public:
     PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
     PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0;
     PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;
+    PFN_vkDestroyAccelerationStructureNVX vkDestroyAccelerationStructureNVX = 0;
     PFN_vkDestroyBuffer vkDestroyBuffer = 0;
     PFN_vkDestroyBufferView vkDestroyBufferView = 0;
     PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
@@ -45055,6 +50103,9 @@ 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;
 #ifdef VK_USE_PLATFORM_ANDROID_ANDROID
     PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
 #endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
@@ -45169,6 +50220,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_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
     PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
     PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
@@ -45241,6 +50293,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"));
       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"));
@@ -45255,11 +50308,14 @@ public:
       vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(device ? device.getProcAddr( "vkCmdBindDescriptorSets") : instance.getProcAddr( "vkCmdBindDescriptorSets"));
       vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(device ? device.getProcAddr( "vkCmdBindIndexBuffer") : instance.getProcAddr( "vkCmdBindIndexBuffer"));
       vkCmdBindPipeline = PFN_vkCmdBindPipeline(device ? device.getProcAddr( "vkCmdBindPipeline") : instance.getProcAddr( "vkCmdBindPipeline"));
+      vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(device ? device.getProcAddr( "vkCmdBindShadingRateImageNV") : instance.getProcAddr( "vkCmdBindShadingRateImageNV"));
       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"));
       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"));
       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"));
@@ -45280,6 +50336,9 @@ public:
       vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(device ? device.getProcAddr( "vkCmdDrawIndirect") : instance.getProcAddr( "vkCmdDrawIndirect"));
       vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndirectCountAMD"));
       vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndirectCountKHR"));
+      vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksIndirectCountNV") : instance.getProcAddr( "vkCmdDrawMeshTasksIndirectCountNV"));
+      vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksIndirectNV") : instance.getProcAddr( "vkCmdDrawMeshTasksIndirectNV"));
+      vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksNV") : instance.getProcAddr( "vkCmdDrawMeshTasksNV"));
       vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(device ? device.getProcAddr( "vkCmdEndConditionalRenderingEXT") : instance.getProcAddr( "vkCmdEndConditionalRenderingEXT"));
       vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdEndDebugUtilsLabelEXT"));
       vkCmdEndQuery = PFN_vkCmdEndQuery(device ? device.getProcAddr( "vkCmdEndQuery") : instance.getProcAddr( "vkCmdEndQuery"));
@@ -45301,12 +50360,14 @@ public:
       vkCmdResolveImage = PFN_vkCmdResolveImage(device ? device.getProcAddr( "vkCmdResolveImage") : instance.getProcAddr( "vkCmdResolveImage"));
       vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(device ? device.getProcAddr( "vkCmdSetBlendConstants") : instance.getProcAddr( "vkCmdSetBlendConstants"));
       vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(device ? device.getProcAddr( "vkCmdSetCheckpointNV") : instance.getProcAddr( "vkCmdSetCheckpointNV"));
+      vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(device ? device.getProcAddr( "vkCmdSetCoarseSampleOrderNV") : instance.getProcAddr( "vkCmdSetCoarseSampleOrderNV"));
       vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(device ? device.getProcAddr( "vkCmdSetDepthBias") : instance.getProcAddr( "vkCmdSetDepthBias"));
       vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(device ? device.getProcAddr( "vkCmdSetDepthBounds") : instance.getProcAddr( "vkCmdSetDepthBounds"));
       vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(device ? device.getProcAddr( "vkCmdSetDeviceMask") : instance.getProcAddr( "vkCmdSetDeviceMask"));
       vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(device ? device.getProcAddr( "vkCmdSetDeviceMaskKHR") : instance.getProcAddr( "vkCmdSetDeviceMaskKHR"));
       vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(device ? device.getProcAddr( "vkCmdSetDiscardRectangleEXT") : instance.getProcAddr( "vkCmdSetDiscardRectangleEXT"));
       vkCmdSetEvent = PFN_vkCmdSetEvent(device ? device.getProcAddr( "vkCmdSetEvent") : instance.getProcAddr( "vkCmdSetEvent"));
+      vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(device ? device.getProcAddr( "vkCmdSetExclusiveScissorNV") : instance.getProcAddr( "vkCmdSetExclusiveScissorNV"));
       vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(device ? device.getProcAddr( "vkCmdSetLineWidth") : instance.getProcAddr( "vkCmdSetLineWidth"));
       vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(device ? device.getProcAddr( "vkCmdSetSampleLocationsEXT") : instance.getProcAddr( "vkCmdSetSampleLocationsEXT"));
       vkCmdSetScissor = PFN_vkCmdSetScissor(device ? device.getProcAddr( "vkCmdSetScissor") : instance.getProcAddr( "vkCmdSetScissor"));
@@ -45314,11 +50375,16 @@ public:
       vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(device ? device.getProcAddr( "vkCmdSetStencilReference") : instance.getProcAddr( "vkCmdSetStencilReference"));
       vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(device ? device.getProcAddr( "vkCmdSetStencilWriteMask") : instance.getProcAddr( "vkCmdSetStencilWriteMask"));
       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"));
       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"));
       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"));
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
       vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR"));
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@@ -45356,6 +50422,7 @@ public:
       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"));
       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"));
@@ -45384,6 +50451,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"));
       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"));
@@ -45430,6 +50498,9 @@ 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"));
 #ifdef VK_USE_PLATFORM_ANDROID_ANDROID
       vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(device ? device.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID") : instance.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID"));
 #endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
@@ -45544,6 +50615,7 @@ public:
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
       vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(device ? device.getProcAddr( "vkGetRandROutputDisplayEXT") : instance.getProcAddr( "vkGetRandROutputDisplayEXT"));
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
+      vkGetRaytracingShaderHandlesNVX = PFN_vkGetRaytracingShaderHandlesNVX(device ? device.getProcAddr( "vkGetRaytracingShaderHandlesNVX") : instance.getProcAddr( "vkGetRaytracingShaderHandlesNVX"));
       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 fe45014..2d1b3f5 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -43,7 +43,7 @@ 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 84
+#define VK_HEADER_VERSION 85
 
 
 #define VK_NULL_HANDLE 0
@@ -298,6 +298,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
     VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
@@ -404,6 +405,23 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
+    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_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,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
     VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
@@ -413,6 +431,13 @@ typedef enum VkStructureType {
     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,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000,
@@ -806,6 +831,7 @@ typedef enum VkQueryType {
     VK_QUERY_TYPE_OCCLUSION = 0,
     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
     VK_QUERY_TYPE_TIMESTAMP = 2,
+    VK_QUERY_TYPE_COMPACTED_SIZE_NVX = 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),
@@ -835,6 +861,7 @@ typedef enum VkImageLayout {
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
+    VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
@@ -1068,6 +1095,9 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
     VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
     VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
+    VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
+    VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
+    VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
     VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
     VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
     VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
@@ -1131,6 +1161,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_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),
@@ -1159,6 +1190,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_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),
@@ -1230,6 +1262,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_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,
@@ -1297,6 +1330,7 @@ typedef enum VkImageUsageFlagBits {
     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
+    VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100,
     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkImageUsageFlagBits;
 typedef VkFlags VkImageUsageFlags;
@@ -1314,6 +1348,7 @@ typedef enum VkImageCreateFlagBits {
     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
     VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
     VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
+    VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
@@ -1393,6 +1428,10 @@ typedef enum VkPipelineStageFlagBits {
     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
     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_TASK_SHADER_BIT_NV = 0x00080000,
+    VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkPipelineStageFlagBits;
 typedef VkFlags VkPipelineStageFlags;
@@ -1481,6 +1520,7 @@ typedef enum VkBufferUsageFlagBits {
     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
+    VK_BUFFER_USAGE_RAYTRACING_BIT_NVX = 0x00000400,
     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkBufferUsageFlagBits;
 typedef VkFlags VkBufferUsageFlags;
@@ -1495,6 +1535,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_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
@@ -1511,6 +1552,14 @@ 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_TASK_BIT_NV = 0x00000040,
+    VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkShaderStageFlagBits;
 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
@@ -1596,6 +1645,9 @@ typedef enum VkAccessFlagBits {
     VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
     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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkAccessFlagBits;
 typedef VkFlags VkAccessFlags;
@@ -4062,6 +4114,8 @@ typedef struct VkMemoryRequirements2 {
     VkMemoryRequirements    memoryRequirements;
 } VkMemoryRequirements2;
 
+typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
+
 typedef struct VkSparseImageMemoryRequirements2 {
     VkStructureType                    sType;
     void*                              pNext;
@@ -5826,8 +5880,6 @@ typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
 
 typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
 
-typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
-
 typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
 
 
@@ -6049,6 +6101,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_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,
@@ -6355,6 +6408,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
 
 
+#define VK_NV_corner_sampled_image 1
+#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
+#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"
+
+typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           cornerSampledImage;
+} VkPhysicalDeviceCornerSampledImageFeaturesNV;
+
+
+
 #define VK_IMG_format_pvrtc 1
 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
@@ -7711,6 +7776,397 @@ typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT {
 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
 
 
+#define VK_NV_shading_rate_image 1
+#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
+#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
+
+
+typedef enum VkShadingRatePaletteEntryNV {
+    VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
+    VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
+    VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
+    VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
+    VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
+    VK_SHADING_RATE_PALETTE_ENTRY_BEGIN_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
+    VK_SHADING_RATE_PALETTE_ENTRY_END_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV,
+    VK_SHADING_RATE_PALETTE_ENTRY_RANGE_SIZE_NV = (VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV + 1),
+    VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF
+} VkShadingRatePaletteEntryNV;
+
+typedef enum VkCoarseSampleOrderTypeNV {
+    VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
+    VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
+    VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
+    VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
+    VK_COARSE_SAMPLE_ORDER_TYPE_BEGIN_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
+    VK_COARSE_SAMPLE_ORDER_TYPE_END_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV,
+    VK_COARSE_SAMPLE_ORDER_TYPE_RANGE_SIZE_NV = (VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV + 1),
+    VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkCoarseSampleOrderTypeNV;
+
+typedef struct VkShadingRatePaletteNV {
+    uint32_t                              shadingRatePaletteEntryCount;
+    const VkShadingRatePaletteEntryNV*    pShadingRatePaletteEntries;
+} VkShadingRatePaletteNV;
+
+typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkBool32                         shadingRateImageEnable;
+    uint32_t                         viewportCount;
+    const VkShadingRatePaletteNV*    pShadingRatePalettes;
+} VkPipelineViewportShadingRateImageStateCreateInfoNV;
+
+typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shadingRateImage;
+    VkBool32           shadingRateCoarseSampleOrder;
+} VkPhysicalDeviceShadingRateImageFeaturesNV;
+
+typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkExtent2D         shadingRateTexelSize;
+    uint32_t           shadingRatePaletteSize;
+    uint32_t           shadingRateMaxCoarseSamples;
+} VkPhysicalDeviceShadingRateImagePropertiesNV;
+
+typedef struct VkCoarseSampleLocationNV {
+    uint32_t    pixelX;
+    uint32_t    pixelY;
+    uint32_t    sample;
+} VkCoarseSampleLocationNV;
+
+typedef struct VkCoarseSampleOrderCustomNV {
+    VkShadingRatePaletteEntryNV        shadingRate;
+    uint32_t                           sampleCount;
+    uint32_t                           sampleLocationCount;
+    const VkCoarseSampleLocationNV*    pSampleLocations;
+} VkCoarseSampleOrderCustomNV;
+
+typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkCoarseSampleOrderTypeNV             sampleOrderType;
+    uint32_t                              customSampleOrderCount;
+    const VkCoarseSampleOrderCustomNV*    pCustomSampleOrders;
+} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(
+    VkCommandBuffer                             commandBuffer,
+    VkImageView                                 imageView,
+    VkImageLayout                               imageLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstViewport,
+    uint32_t                                    viewportCount,
+    const VkShadingRatePaletteNV*               pShadingRatePalettes);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(
+    VkCommandBuffer                             commandBuffer,
+    VkCoarseSampleOrderTypeNV                   sampleOrderType,
+    uint32_t                                    customSampleOrderCount,
+    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 {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           vertexData;
+    VkDeviceSize       vertexOffset;
+    uint32_t           vertexCount;
+    VkDeviceSize       vertexStride;
+    VkFormat           vertexFormat;
+    VkBuffer           indexData;
+    VkDeviceSize       indexOffset;
+    uint32_t           indexCount;
+    VkIndexType        indexType;
+    VkBuffer           transformData;
+    VkDeviceSize       transformOffset;
+} VkGeometryTrianglesNVX;
+
+typedef struct VkGeometryAABBNVX {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           aabbData;
+    uint32_t           numAABBs;
+    uint32_t           stride;
+    VkDeviceSize       offset;
+} VkGeometryAABBNVX;
+
+typedef struct VkGeometryDataNVX {
+    VkGeometryTrianglesNVX    triangles;
+    VkGeometryAABBNVX         aabbs;
+} VkGeometryDataNVX;
+
+typedef struct VkGeometryNVX {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkGeometryTypeNVX     geometryType;
+    VkGeometryDataNVX     geometry;
+    VkGeometryFlagsNVX    flags;
+} VkGeometryNVX;
+
+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 VkAccelerationStructureMemoryRequirementsInfoNVX {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkAccelerationStructureNVX    accelerationStructure;
+} VkAccelerationStructureMemoryRequirementsInfoNVX;
+
+typedef struct VkPhysicalDeviceRaytracingPropertiesNVX {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           shaderHeaderSize;
+    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 cmdBuf, 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 cmdBuf, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkCopyAccelerationStructureModeNVX mode);
+typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNVX)(VkCommandBuffer cmdBuf, 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 cmdBuf, VkAccelerationStructureNVX accelerationStructure, VkQueryType queryType, VkQueryPool queryPool, uint32_t query);
+typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNVX)(VkDevice device, VkPipeline pipeline, uint32_t shader);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNVX(
+    VkDevice                                    device,
+    const VkAccelerationStructureCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkAccelerationStructureNVX*                 pAccelerationStructure);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNVX(
+    VkDevice                                    device,
+    VkAccelerationStructureNVX                  accelerationStructure,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNVX(
+    VkDevice                                    device,
+    const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo,
+    VkMemoryRequirements2KHR*                   pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureScratchMemoryRequirementsNVX(
+    VkDevice                                    device,
+    const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo,
+    VkMemoryRequirements2KHR*                   pMemoryRequirements);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNVX(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNVX(
+    VkCommandBuffer                             cmdBuf,
+    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);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNVX(
+    VkCommandBuffer                             cmdBuf,
+    VkAccelerationStructureNVX                  dst,
+    VkAccelerationStructureNVX                  src,
+    VkCopyAccelerationStructureModeNVX          mode);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNVX(
+    VkCommandBuffer                             cmdBuf,
+    VkBuffer                                    raygenShaderBindingTableBuffer,
+    VkDeviceSize                                raygenShaderBindingOffset,
+    VkBuffer                                    missShaderBindingTableBuffer,
+    VkDeviceSize                                missShaderBindingOffset,
+    VkDeviceSize                                missShaderBindingStride,
+    VkBuffer                                    hitShaderBindingTableBuffer,
+    VkDeviceSize                                hitShaderBindingOffset,
+    VkDeviceSize                                hitShaderBindingStride,
+    uint32_t                                    width,
+    uint32_t                                    height);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRaytracingPipelinesNVX(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkRaytracingPipelineCreateInfoNVX*    pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRaytracingShaderHandlesNVX(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    uint32_t                                    firstGroup,
+    uint32_t                                    groupCount,
+    size_t                                      dataSize,
+    void*                                       pData);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNVX(
+    VkDevice                                    device,
+    VkAccelerationStructureNVX                  accelerationStructure,
+    size_t                                      dataSize,
+    void*                                       pData);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructurePropertiesNVX(
+    VkCommandBuffer                             cmdBuf,
+    VkAccelerationStructureNVX                  accelerationStructure,
+    VkQueryType                                 queryType,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNVX(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    uint32_t                                    shader);
+#endif
+
+#define VK_NV_representative_fragment_test 1
+#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1
+#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
+
+typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           representativeFragmentTest;
+} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+
+typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           representativeFragmentTestEnable;
+} VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
+
+
+
 #define VK_EXT_global_priority 1
 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
@@ -7845,6 +8301,133 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
 
 
+#define VK_NV_compute_shader_derivatives 1
+#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
+#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
+
+typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           computeDerivativeGroupQuads;
+    VkBool32           computeDerivativeGroupLinear;
+} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
+
+
+
+#define VK_NV_mesh_shader 1
+#define VK_NV_MESH_SHADER_SPEC_VERSION    1
+#define VK_NV_MESH_SHADER_EXTENSION_NAME  "VK_NV_mesh_shader"
+
+typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           taskShader;
+    VkBool32           meshShader;
+} VkPhysicalDeviceMeshShaderFeaturesNV;
+
+typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxDrawMeshTasksCount;
+    uint32_t           maxTaskWorkGroupInvocations;
+    uint32_t           maxTaskWorkGroupSize[3];
+    uint32_t           maxTaskTotalMemorySize;
+    uint32_t           maxTaskOutputCount;
+    uint32_t           maxMeshWorkGroupInvocations;
+    uint32_t           maxMeshWorkGroupSize[3];
+    uint32_t           maxMeshTotalMemorySize;
+    uint32_t           maxMeshOutputVertices;
+    uint32_t           maxMeshOutputPrimitives;
+    uint32_t           maxMeshMultiviewViewCount;
+    uint32_t           meshOutputPerVertexGranularity;
+    uint32_t           meshOutputPerPrimitiveGranularity;
+} VkPhysicalDeviceMeshShaderPropertiesNV;
+
+typedef struct VkDrawMeshTasksIndirectCommandNV {
+    uint32_t    taskCount;
+    uint32_t    firstTask;
+} VkDrawMeshTasksIndirectCommandNV;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    taskCount,
+    uint32_t                                    firstTask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    uint32_t                                    drawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+#endif
+
+#define VK_NV_fragment_shader_barycentric 1
+#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
+#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"
+
+typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fragmentShaderBarycentric;
+} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+
+
+
+#define VK_NV_shader_image_footprint 1
+#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1
+#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
+
+typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           imageFootprint;
+} VkPhysicalDeviceShaderImageFootprintFeaturesNV;
+
+
+
+#define VK_NV_scissor_exclusive 1
+#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
+#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
+
+typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           exclusiveScissorCount;
+    const VkRect2D*    pExclusiveScissors;
+} VkPipelineViewportExclusiveScissorStateCreateInfoNV;
+
+typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           exclusiveScissor;
+} VkPhysicalDeviceExclusiveScissorFeaturesNV;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstExclusiveScissor,
+    uint32_t                                    exclusiveScissorCount,
+    const VkRect2D*                             pExclusiveScissors);
+#endif
+
 #define VK_NV_device_diagnostic_checkpoints 1
 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"
diff --git a/registry/validusage.json b/registry/validusage.json
index 8a2daae..cc1bb9e 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.1.84",
-    "comment": "from git branch: master commit: 9d4ae0fcf4d2157548db32456b58f7ae7db21e81",
-    "date": "2018-09-10 16:15:15Z"
+    "api version": "1.1.85",
+    "comment": "from git branch: master commit: 9858c1e89e21246f779226d2be779fd33bb6a50d",
+    "date": "2018-09-19 19:31:34Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -198,7 +198,7 @@
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRaytracingPropertiesNVX\">VkPhysicalDeviceRaytracingPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>"
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique",
@@ -318,7 +318,7 @@
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeaturesKHR\">VkPhysicalDevice8BitStorageFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeaturesEXT\">VkPhysicalDeviceDescriptorIndexingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceShaderDrawParameterFeatures\">VkPhysicalDeviceShaderDrawParameterFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointerFeatures\">VkPhysicalDeviceVariablePointerFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeaturesKHR\">VkPhysicalDeviceVulkanMemoryModelFeaturesKHR</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeaturesKHR\">VkPhysicalDevice8BitStorageFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeaturesEXT\">VkPhysicalDeviceDescriptorIndexingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceShaderDrawParameterFeatures\">VkPhysicalDeviceShaderDrawParameterFeatures</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceVariablePointerFeatures\">VkPhysicalDeviceVariablePointerFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeaturesKHR\">VkPhysicalDeviceVulkanMemoryModelFeaturesKHR</a>"
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-sType-unique",
@@ -1000,6 +1000,16 @@
           "vuid": "VUID-VkSubmitInfo-commonparent",
           "text": " Each of the elements of <code>pCommandBuffers</code>, the elements of <code>pSignalSemaphores</code>, and the elements of <code>pWaitSemaphores</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
         }
+      ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-02089",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, each element of <code>pWaitDstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-02090",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, each element of <code>pWaitDstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        }
       ]
     },
     "VkD3D12FenceSubmitInfoKHR": {
@@ -2288,6 +2298,16 @@
           "vuid": "VUID-vkCmdSetEvent-commandBuffer-01152",
           "text": " <code>commandBuffer</code>&#8217;s current device mask <strong class=\"purple\">must</strong> include exactly one physical device."
         }
+      ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-vkCmdSetEvent-stageMask-02107",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>stageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetEvent-stageMask-02108",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>stageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        }
       ]
     },
     "vkCmdResetEvent": {
@@ -2346,6 +2366,16 @@
           "vuid": "VUID-vkCmdResetEvent-commandBuffer-01157",
           "text": " <code>commandBuffer</code>&#8217;s current device mask <strong class=\"purple\">must</strong> include exactly one physical device."
         }
+      ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-vkCmdResetEvent-stageMask-02109",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>stageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdResetEvent-stageMask-02110",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>stageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        }
       ]
     },
     "vkCmdWaitEvents": {
@@ -2444,6 +2474,24 @@
           "vuid": "VUID-vkCmdWaitEvents-commandBuffer-01167",
           "text": " <code>commandBuffer</code>&#8217;s current device mask <strong class=\"purple\">must</strong> include exactly one physical device."
         }
+      ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-vkCmdWaitEvents-srcStageMask-02111",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-srcStageMask-02112",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-dstStageMask-02113",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-dstStageMask-02114",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        }
       ]
     },
     "vkCmdPipelineBarrier": {
@@ -2554,6 +2602,24 @@
           "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-01186",
           "text": " If <code>vkCmdPipelineBarrier</code> is called outside of a render pass instance, <code>dependencyFlags</code> <strong class=\"purple\">must</strong> not include <code>VK_DEPENDENCY_VIEW_LOCAL_BIT</code>"
         }
+      ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-02115",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-02116",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-02117",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-02118",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        }
       ]
     },
     "VkMemoryBarrier": {
@@ -2802,6 +2868,12 @@
           "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01659",
           "text": " If either <code>oldLayout</code> or <code>newLayout</code> is <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code> then <code>image</code> <strong class=\"purple\">must</strong> have been created with <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code> set"
         }
+      ],
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-VkImageMemoryBarrier-oldLayout-02088",
+          "text": " If either <code>oldLayout</code> or <code>newLayout</code> is <code>VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV</code> then <code>image</code> <strong class=\"purple\">must</strong> have been created with <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code> set"
+        }
       ]
     },
     "vkQueueWaitIdle": {
@@ -3186,7 +3258,7 @@
         },
         {
           "vuid": "VUID-VkSubpassDependency-srcSubpass-01989",
-          "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code>, <code>srcStageMask</code> and <code>dstStageMask</code> <strong class=\"purple\">must</strong> not set any bits that are not <code>VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT</code>, or not one of the <a href=\"#synchronization-pipeline-stages-types\">graphics pipeline stages</a>"
+          "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code>, <code>srcStageMask</code> and <code>dstStageMask</code> <strong class=\"purple\">must</strong> not set any bits that are neither <code>VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT</code>, nor one of the <a href=\"#synchronization-pipeline-stages-types\">graphics pipeline stages</a>"
         },
         {
           "vuid": "VUID-VkSubpassDependency-srcSubpass-00867",
@@ -3194,11 +3266,15 @@
         },
         {
           "vuid": "VUID-VkSubpassDependency-srcAccessMask-00868",
-          "text": " Any access flag included in <code>srcAccessMask</code> <strong class=\"purple\">must</strong> be supported by one of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>."
+          "text": " Any access flag included in <code>srcAccessMask</code> <strong class=\"purple\">must</strong> be supported by one of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
         },
         {
           "vuid": "VUID-VkSubpassDependency-dstAccessMask-00869",
-          "text": " Any access flag included in <code>dstAccessMask</code> <strong class=\"purple\">must</strong> be supported by one of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>."
+          "text": " Any access flag included in <code>dstAccessMask</code> <strong class=\"purple\">must</strong> be supported by one of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDependency-srcSubpass-02243",
+          "text": " If <code>srcSubpass</code> equals <code>dstSubpass</code>, and <code>srcStageMask</code> and <code>dstStageMask</code> both include a <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stage</a>, then <code>dependencyFlags</code> <strong class=\"purple\">must</strong> include <code>VK_DEPENDENCY_BY_REGION_BIT</code>"
         },
         {
           "vuid": "VUID-VkSubpassDependency-srcStageMask-parameter",
@@ -3242,6 +3318,24 @@
           "vuid": "VUID-VkSubpassDependency-srcSubpass-00872",
           "text": " If <code>srcSubpass</code> equals <code>dstSubpass</code> and that subpass has more than one bit set in the view mask, then <code>dependencyFlags</code> <strong class=\"purple\">must</strong> include <code>VK_DEPENDENCY_VIEW_LOCAL_BIT</code>"
         }
+      ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkSubpassDependency-srcStageMask-02099",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDependency-srcStageMask-02100",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDependency-dstStageMask-02101",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDependency-dstStageMask-02102",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        }
       ]
     },
     "vkCreateRenderPass2KHR": {
@@ -3557,8 +3651,8 @@
           "text": " <code>srcSubpass</code> and <code>dstSubpass</code> <strong class=\"purple\">must</strong> not both be equal to <code>VK_SUBPASS_EXTERNAL</code>"
         },
         {
-          "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-03086",
-          "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code>, <code>srcStageMask</code> and <code>dstStageMask</code> <strong class=\"purple\">must</strong> only contain one of <code>VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT</code>, <code>VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT</code>, <code>VK_PIPELINE_STAGE_VERTEX_INPUT_BIT</code>, <code>VK_PIPELINE_STAGE_VERTEX_SHADER_BIT</code>, <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code>, <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>, <code>VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT</code>, <code>VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT</code>, <code>VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT</code>, <code>VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT</code>, <code>VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT</code>, <code>VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT</code>, or <code>VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT</code>"
+          "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-02244",
+          "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code>, <code>srcStageMask</code> and <code>dstStageMask</code> <strong class=\"purple\">must</strong> not set any bits that are neither <code>VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT</code>, nor one of the <a href=\"#synchronization-pipeline-stages-types\">graphics pipeline stages</a>"
         },
         {
           "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-03087",
@@ -3581,6 +3675,10 @@
           "text": " If <code>dependencyFlags</code> includes <code>VK_DEPENDENCY_VIEW_LOCAL_BIT</code>, <code>dstSubpass</code> <strong class=\"purple\">must</strong> not be equal to <code>VK_SUBPASS_EXTERNAL</code>"
         },
         {
+          "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-02245",
+          "text": " If <code>srcSubpass</code> equals <code>dstSubpass</code>, and <code>srcStageMask</code> and <code>dstStageMask</code> both include a <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stage</a>, then <code>dependencyFlags</code> <strong class=\"purple\">must</strong> include <code>VK_DEPENDENCY_BY_REGION_BIT</code>"
+        },
+        {
           "vuid": "VUID-VkSubpassDependency2KHR-dependencyFlags-03092",
           "text": " If <code>dependencyFlags</code> does not include <code>VK_DEPENDENCY_VIEW_LOCAL_BIT</code>, <code>viewOffset</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
@@ -3620,6 +3718,24 @@
           "vuid": "VUID-VkSubpassDependency2KHR-dependencyFlags-parameter",
           "text": " <code>dependencyFlags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkDependencyFlagBits\">VkDependencyFlagBits</a> values"
         }
+      ],
+      "(VK_KHR_create_renderpass2)+(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkSubpassDependency2KHR-srcStageMask-02103",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDependency2KHR-srcStageMask-02104",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDependency2KHR-dstStageMask-02105",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkSubpassDependency2KHR-dstStageMask-02106",
+          "text": " If the <a href=\"#features-features-taskShader\">task shaders</a> feature is not enabled, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV</code>"
+        }
       ]
     },
     "vkDestroyRenderPass": {
@@ -4675,6 +4791,24 @@
           "text": " If <code>pSpecializationInfo</code> is not <code>NULL</code>, <code>pSpecializationInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkSpecializationInfo</code> structure"
         }
       ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02091",
+          "text": " If the <a href=\"#features-features-meshShader\">mesh shader</a> feature is not enabled, <code>stage</code> <strong class=\"purple\">must</strong> not be <code>VK_SHADER_STAGE_MESH_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02092",
+          "text": " If the <a href=\"#features-features-taskShader\">task shader</a> feature is not enabled, <code>stage</code> <strong class=\"purple\">must</strong> not be <code>VK_SHADER_STAGE_TASK_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02093",
+          "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_MESH_BIT_NV</code>, the identified entry point <strong class=\"purple\">must</strong> have an <code>OpExecutionMode</code> instruction that specifies a maximum output vertex count, <code>OutputVertices</code>, that is greater than <code>0</code> and less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxMeshOutputVertices</code>."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02094",
+          "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_MESH_BIT_NV</code>, the identified entry point <strong class=\"purple\">must</strong> have an <code>OpExecutionMode</code> instruction that specifies a maximum output primitive count, <code>OutputPrimitivesNV</code>, that is greater than <code>0</code> and less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxMeshOutputPrimitives</code>."
+        }
+      ],
       "(VK_EXT_shader_stencil_export)": [
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-01511",
@@ -4745,10 +4879,6 @@
           "text": " The <code>stage</code> member of each element of <code>pStages</code> <strong class=\"purple\">must</strong> be unique"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00727",
-          "text": " The <code>stage</code> member of one element of <code>pStages</code> <strong class=\"purple\">must</strong> be <code>VK_SHADER_STAGE_VERTEX_BIT</code>"
-        },
-        {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00728",
           "text": " The <code>stage</code> member of each element of <code>pStages</code> <strong class=\"purple\">must</strong> not be <code>VK_SHADER_STAGE_COMPUTE_BIT</code>"
         },
@@ -4865,12 +4995,24 @@
           "text": " The number of resources in <code>layout</code> accessible to each shader stage that is used by the pipeline <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxPerStageResources</code>"
         },
         {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02097",
+          "text": " If <code>pStages</code> includes a vertex shader stage, <code>pVertexInputState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineVertexInputStateCreateInfo\">VkPipelineVertexInputStateCreateInfo</a> structure"
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02098",
+          "text": " If <code>pStages</code> includes a vertex shader stage, <code>pInputAssemblyState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineInputAssemblyStateCreateInfo\">VkPipelineInputAssemblyStateCreateInfo</a> structure"
+        },
+        {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO</code>"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineDiscardRectangleStateCreateInfoEXT\">VkPipelineDiscardRectangleStateCreateInfoEXT</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineDiscardRectangleStateCreateInfoEXT\">VkPipelineDiscardRectangleStateCreateInfoEXT</a> or <a href=\"#VkPipelineRepresentativeFragmentTestStateCreateInfoNV\">VkPipelineRepresentativeFragmentTestStateCreateInfoNV</a>"
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-unique",
+          "text": " Each <code>sType</code> member in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be unique"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-parameter",
@@ -4881,14 +5023,6 @@
           "text": " <code>pStages</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>stageCount</code> valid <code>VkPipelineShaderStageCreateInfo</code> structures"
         },
         {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter",
-          "text": " <code>pVertexInputState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineVertexInputStateCreateInfo</code> structure"
-        },
-        {
-          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter",
-          "text": " <code>pInputAssemblyState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineInputAssemblyStateCreateInfo</code> structure"
-        },
-        {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter",
           "text": " <code>pRasterizationState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineRasterizationStateCreateInfo</code> structure"
         },
@@ -4913,6 +5047,22 @@
           "text": " Each of <code>basePipelineHandle</code>, <code>layout</code>, and <code>renderPass</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
         }
       ],
+      "!(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00727",
+          "text": " The <code>stage</code> member of one element of <code>pStages</code> <strong class=\"purple\">must</strong> be <code>VK_SHADER_STAGE_VERTEX_BIT</code>"
+        }
+      ],
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02095",
+          "text": " The geometric shader stages provided in <code>pStages</code> <strong class=\"purple\">must</strong> be either from the mesh shading pipeline (<code>stage</code> is <code>VK_SHADER_STAGE_TASK_BIT_NV</code> or <code>VK_SHADER_STAGE_MESH_BIT_NV</code>) or from the primitive shading pipeline (<code>stage</code> is <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code>, or <code>VK_SHADER_STAGE_GEOEMETRY_BIT</code>)."
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-02096",
+          "text": " The <code>stage</code> member of one element of <code>pStages</code> <strong class=\"purple\">must</strong> be either <code>VK_SHADER_STAGE_VERTEX_BIT</code> or <code>VK_SHADER_STAGE_MESH_BIT_NV</code>."
+        }
+      ],
       "!(VK_VERSION_1_1,VK_KHR_maintenance2)": [
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00743",
@@ -5326,6 +5476,122 @@
         }
       ]
     },
+    "vkCreateRaytracingPipelinesNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkCreateRaytracingPipelinesNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pipelineCache-parameter",
+          "text": " If <code>pipelineCache</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>pipelineCache</code> <strong class=\"purple\">must</strong> be a valid <code>VkPipelineCache</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pCreateInfos-parameter",
+          "text": " <code>pCreateInfos</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>createInfoCount</code> valid <code>VkRaytracingPipelineCreateInfoNVX</code> structures"
+        },
+        {
+          "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pAllocator-parameter",
+          "text": " If <code>pAllocator</code> is not <code>NULL</code>, <code>pAllocator</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAllocationCallbacks</code> structure"
+        },
+        {
+          "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pPipelines-parameter",
+          "text": " <code>pPipelines</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>createInfoCount</code> <code>VkPipeline</code> handles"
+        },
+        {
+          "vuid": "VUID-vkCreateRaytracingPipelinesNVX-createInfoCount-arraylength",
+          "text": " <code>createInfoCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        },
+        {
+          "vuid": "VUID-vkCreateRaytracingPipelinesNVX-pipelineCache-parent",
+          "text": " If <code>pipelineCache</code> is a valid handle, it <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
+        }
+      ]
+    },
+    "VkRaytracingPipelineCreateInfoNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX</code>"
+        },
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-flags-parameter",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkPipelineCreateFlagBits\">VkPipelineCreateFlagBits</a> values"
+        },
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-pStages-parameter",
+          "text": " <code>pStages</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>stageCount</code> valid <code>VkPipelineShaderStageCreateInfo</code> structures"
+        },
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-pGroupNumbers-parameter",
+          "text": " <code>pGroupNumbers</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>stageCount</code> <code>uint32_t</code> values"
+        },
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-layout-parameter",
+          "text": " <code>layout</code> <strong class=\"purple\">must</strong> be a valid <code>VkPipelineLayout</code> handle"
+        },
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-stageCount-arraylength",
+          "text": " <code>stageCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        },
+        {
+          "vuid": "VUID-VkRaytracingPipelineCreateInfoNVX-commonparent",
+          "text": " Both of <code>basePipelineHandle</code>, and <code>layout</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
+    "vkGetRaytracingShaderHandlesNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-pipeline-parameter",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a valid <code>VkPipeline</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-pData-parameter",
+          "text": " <code>pData</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>dataSize</code> bytes"
+        },
+        {
+          "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-dataSize-arraylength",
+          "text": " <code>dataSize</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        },
+        {
+          "vuid": "VUID-vkGetRaytracingShaderHandlesNVX-pipeline-parent",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
+        }
+      ]
+    },
+    "vkCompileDeferredNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkCompileDeferredNVX-pipeline-02237",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> have been created with VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX."
+        },
+        {
+          "vuid": "VUID-vkCompileDeferredNVX-shader-02238",
+          "text": " <code>shader</code> <strong class=\"purple\">must</strong> not have been called as a deferred compile before."
+        },
+        {
+          "vuid": "VUID-vkCompileDeferredNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCompileDeferredNVX-pipeline-parameter",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a valid <code>VkPipeline</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCompileDeferredNVX-pipeline-parent",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
+        }
+      ]
+    },
     "VkAllocationCallbacks": {
       "core": [
         {
@@ -5492,7 +5758,7 @@
       "(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 <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BIT_ANDROID</code>:"
+          "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>:"
         },
         {
           "vuid": "VUID-VkMemoryAllocateInfo-pNext-01874",
@@ -6762,7 +7028,7 @@
         },
         {
           "vuid": "VUID-VkImageCreateInfo-mipLevels-00958",
-          "text": " <code>mipLevels</code> <strong class=\"purple\">must</strong> be less than or equal to <span class=\"eq\">{lfloor}log<sub>2</sub>(max(<code>extent.width</code>, <code>extent.height</code>, <code>extent.depth</code>)){rfloor} &#43; 1</span>."
+          "text": " <code>mipLevels</code> <strong class=\"purple\">must</strong> be less than or equal to the number of levels in the complete mipmap chain based on <span class=\"eq\"><code>extent.width</code></span>, <span class=\"eq\"><code>extent.height</code></span>, and <span class=\"eq\"><code>extent.depth</code></span>."
         },
         {
           "vuid": "VUID-VkImageCreateInfo-extent-00959",
@@ -6996,6 +7262,38 @@
           "vuid": "VUID-VkImageCreateInfo-flags-01533",
           "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> <code>format</code> <strong class=\"purple\">must</strong> be a depth or depth/stencil format"
         }
+      ],
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-VkImageCreateInfo-flags-02050",
+          "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code>, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code> or <code>VK_IMAGE_TYPE_3D</code>"
+        },
+        {
+          "vuid": "VUID-VkImageCreateInfo-flags-02051",
+          "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code>, it <strong class=\"purple\">must</strong> not contain <code>VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT</code> and the <code>format</code> <strong class=\"purple\">must</strong> not be a depth/stencil format"
+        },
+        {
+          "vuid": "VUID-VkImageCreateInfo-flags-02052",
+          "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> and <code>imageType</code> is <code>VK_IMAGE_TYPE_2D</code>, <code>extent</code>::<code>width</code> and <code>extent</code>::<code>height</code> <strong class=\"purple\">must</strong> be greater than <code>1</code>"
+        },
+        {
+          "vuid": "VUID-VkImageCreateInfo-flags-02053",
+          "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> and <code>imageType</code> is <code>VK_IMAGE_TYPE_3D</code>, <code>extent</code>::<code>width</code>, <code>extent</code>::<code>height</code>, and <code>extent</code>::<code>depth</code> <strong class=\"purple\">must</strong> be greater than <code>1</code>"
+        }
+      ],
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-VkImageCreateInfo-imageType-02082",
+          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code>."
+        },
+        {
+          "vuid": "VUID-VkImageCreateInfo-samples-02083",
+          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>samples</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLE_COUNT_1_BIT</code>."
+        },
+        {
+          "vuid": "VUID-VkImageCreateInfo-tiling-02084",
+          "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_OPTIMAL</code>."
+        }
       ]
     },
     "VkDedicatedAllocationImageCreateInfoNV": {
@@ -7225,10 +7523,6 @@
           "text": " If <code>image</code> was created with <code>VK_IMAGE_TILING_LINEAR</code>, <code>format</code> <strong class=\"purple\">must</strong> be format that has at least one supported feature bit present in the value of <code>VkFormatProperties</code>::<code>linearTilingFeatures</code> returned by <code>vkGetPhysicalDeviceFormatProperties</code> with the same value of <code>format</code>"
         },
         {
-          "vuid": "VUID-VkImageViewCreateInfo-image-01007",
-          "text": " <code>image</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value containing at least one of <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>, <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>, or <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>"
-        },
-        {
           "vuid": "VUID-VkImageViewCreateInfo-image-01008",
           "text": " If <code>image</code> was created with <code>VK_IMAGE_TILING_LINEAR</code> and <code>usage</code> contains <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>, <code>format</code> <strong class=\"purple\">must</strong> be supported for sampled images, as specified by the <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT</code> flag in <code>VkFormatProperties</code>::<code>linearTilingFeatures</code> returned by <code>vkGetPhysicalDeviceFormatProperties</code> with the same value of <code>format</code>"
         },
@@ -7323,6 +7617,26 @@
           "text": " If <code>subresourceRange</code>::<code>layerCount</code> is not <code>VK_REMAINING_ARRAY_LAYERS</code>, <code>image</code> is a 3D image created with <code>VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT</code> set, and <code>viewType</code> is <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>, <code>subresourceRange</code>::<code>layerCount</code> <strong class=\"purple\">must</strong> be non-zero and <span class=\"eq\"><code>subresourceRange</code>::<code>baseArrayLayer</code> &#43; <code>subresourceRange</code>::<code>layerCount</code></span> <strong class=\"purple\">must</strong> be less than or equal to the <code>extent.depth</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created"
         }
       ],
+      "!(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-VkImageViewCreateInfo-image-01007",
+          "text": " <code>image</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value containing at least one of <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>, <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>, or <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>"
+        }
+      ],
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-VkImageViewCreateInfo-image-02085",
+          "text": " <code>image</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value containing at least one of <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>, <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>, <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>, or <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkImageViewCreateInfo-image-02086",
+          "text": " If <code>image</code> was created with <code>usage</code> containing <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>viewType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>"
+        },
+        {
+          "vuid": "VUID-VkImageViewCreateInfo-image-02087",
+          "text": " If <code>image</code> was created with <code>usage</code> containing <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>format</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_R8_UINT</code>"
+        }
+      ],
       "!(VK_ANDROID_external_memory_android_hardware_buffer)": [
         {
           "vuid": "VUID-VkImageViewCreateInfo-image-01012",
@@ -8250,82 +8564,358 @@
         }
       ]
     },
-    "vkCreateSampler": {
-      "core": [
+    "vkCreateAccelerationStructureNVX": {
+      "(VK_NVX_raytracing)": [
         {
-          "vuid": "VUID-vkCreateSampler-device-parameter",
+          "vuid": "VUID-vkCreateAccelerationStructureNVX-device-parameter",
           "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
         },
         {
-          "vuid": "VUID-vkCreateSampler-pCreateInfo-parameter",
-          "text": " <code>pCreateInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkSamplerCreateInfo</code> structure"
+          "vuid": "VUID-vkCreateAccelerationStructureNVX-pCreateInfo-parameter",
+          "text": " <code>pCreateInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAccelerationStructureCreateInfoNVX</code> structure"
         },
         {
-          "vuid": "VUID-vkCreateSampler-pAllocator-parameter",
+          "vuid": "VUID-vkCreateAccelerationStructureNVX-pAllocator-parameter",
           "text": " If <code>pAllocator</code> is not <code>NULL</code>, <code>pAllocator</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAllocationCallbacks</code> structure"
         },
         {
-          "vuid": "VUID-vkCreateSampler-pSampler-parameter",
-          "text": " <code>pSampler</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>VkSampler</code> handle"
+          "vuid": "VUID-vkCreateAccelerationStructureNVX-pAccelerationStructure-parameter",
+          "text": " <code>pAccelerationStructure</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>VkAccelerationStructureNVX</code> handle"
         }
       ]
     },
-    "VkSamplerCreateInfo": {
-      "core": [
+    "VkAccelerationStructureCreateInfoNVX": {
+      "(VK_NVX_raytracing)": [
         {
-          "vuid": "VUID-VkSamplerCreateInfo-mipLodBias-01069",
-          "text": " The absolute value of <code>mipLodBias</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxSamplerLodBias</code>"
+          "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-geometryCount-02239",
+          "text": " <code>geometryCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceRaytracingPropertiesNVX</code>::<code>maxGeometryCount</code>"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-maxLod-01973",
-          "text": " <code>maxLod</code> <strong class=\"purple\">must</strong> be greater than or equal to <code>minLod</code>"
+          "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX</code>"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01070",
-          "text": " If the <a href=\"#features-features-samplerAnisotropy\">anisotropic sampling</a> feature is not enabled, <code>anisotropyEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+          "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01071",
-          "text": " If <code>anisotropyEnable</code> is <code>VK_TRUE</code>, <code>maxAnisotropy</code> <strong class=\"purple\">must</strong> be between <code>1.0</code> and <code>VkPhysicalDeviceLimits</code>::<code>maxSamplerAnisotropy</code>, inclusive"
+          "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-type-parameter",
+          "text": " <code>type</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkAccelerationStructureTypeNVX\">VkAccelerationStructureTypeNVX</a> value"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072",
-          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>minFilter</code> and <code>magFilter</code> <strong class=\"purple\">must</strong> be equal"
+          "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-flags-parameter",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkBuildAccelerationStructureFlagBitsNVX\">VkBuildAccelerationStructureFlagBitsNVX</a> values"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073",
-          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>mipmapMode</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLER_MIPMAP_MODE_NEAREST</code>"
+          "vuid": "VUID-VkAccelerationStructureCreateInfoNVX-pGeometries-parameter",
+          "text": " If <code>geometryCount</code> is not <code>0</code>, <code>pGeometries</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>geometryCount</code> valid <code>VkGeometryNVX</code> structures"
+        }
+      ]
+    },
+    "VkGeometryNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkGeometryNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_GEOMETRY_NVX</code>"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074",
-          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>minLod</code> and <code>maxLod</code> <strong class=\"purple\">must</strong> be zero"
+          "vuid": "VUID-VkGeometryNVX-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075",
-          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>addressModeU</code> and <code>addressModeV</code> <strong class=\"purple\">must</strong> each be either <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code> or <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER</code>"
+          "vuid": "VUID-VkGeometryNVX-geometryType-parameter",
+          "text": " <code>geometryType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkGeometryTypeNVX\">VkGeometryTypeNVX</a> value"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076",
-          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>anisotropyEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+          "vuid": "VUID-VkGeometryNVX-geometry-parameter",
+          "text": " <code>geometry</code> <strong class=\"purple\">must</strong> be a valid <code>VkGeometryDataNVX</code> structure"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077",
-          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>compareEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+          "vuid": "VUID-VkGeometryNVX-flags-parameter",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkGeometryFlagBitsNVX\">VkGeometryFlagBitsNVX</a> values"
+        }
+      ]
+    },
+    "VkGeometryDataNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkGeometryDataNVX-triangles-parameter",
+          "text": " <code>triangles</code> <strong class=\"purple\">must</strong> be a valid <code>VkGeometryTrianglesNVX</code> structure"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01078",
-          "text": " If any of <code>addressModeU</code>, <code>addressModeV</code> or <code>addressModeW</code> are <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER</code>, <code>borderColor</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkBorderColor\">VkBorderColor</a> value"
+          "vuid": "VUID-VkGeometryDataNVX-aabbs-parameter",
+          "text": " <code>aabbs</code> <strong class=\"purple\">must</strong> be a valid <code>VkGeometryAABBNVX</code> structure"
+        }
+      ]
+    },
+    "VkGeometryTrianglesNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkGeometryTrianglesNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX</code>"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079",
-          "text": " If the <code><a href=\"#VK_KHR_sampler_mirror_clamp_to_edge\">VK_KHR_sampler_mirror_clamp_to_edge</a></code> extension is not enabled, <code>addressModeU</code>, <code>addressModeV</code> and <code>addressModeW</code> <strong class=\"purple\">must</strong> not be <code>VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE</code>"
+          "vuid": "VUID-VkGeometryTrianglesNVX-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01080",
-          "text": " If <code>compareEnable</code> is <code>VK_TRUE</code>, <code>compareOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCompareOp\">VkCompareOp</a> value"
+          "vuid": "VUID-VkGeometryTrianglesNVX-vertexData-parameter",
+          "text": " If <code>vertexData</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>vertexData</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-sType-sType",
+          "vuid": "VUID-VkGeometryTrianglesNVX-vertexFormat-parameter",
+          "text": " <code>vertexFormat</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkFormat\">VkFormat</a> value"
+        },
+        {
+          "vuid": "VUID-VkGeometryTrianglesNVX-indexData-parameter",
+          "text": " If <code>indexData</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>indexData</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-VkGeometryTrianglesNVX-indexType-parameter",
+          "text": " <code>indexType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkIndexType\">VkIndexType</a> value"
+        },
+        {
+          "vuid": "VUID-VkGeometryTrianglesNVX-transformData-parameter",
+          "text": " If <code>transformData</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>transformData</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-VkGeometryTrianglesNVX-commonparent",
+          "text": " Each of <code>indexData</code>, <code>transformData</code>, and <code>vertexData</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
+    "VkGeometryAABBNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkGeometryAABBNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX</code>"
+        },
+        {
+          "vuid": "VUID-VkGeometryAABBNVX-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkGeometryAABBNVX-aabbData-parameter",
+          "text": " If <code>aabbData</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>aabbData</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        }
+      ]
+    },
+    "vkDestroyAccelerationStructureNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkDestroyAccelerationStructureNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkDestroyAccelerationStructureNVX-accelerationStructure-parameter",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-vkDestroyAccelerationStructureNVX-pAllocator-parameter",
+          "text": " If <code>pAllocator</code> is not <code>NULL</code>, <code>pAllocator</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAllocationCallbacks</code> structure"
+        },
+        {
+          "vuid": "VUID-vkDestroyAccelerationStructureNVX-accelerationStructure-parent",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
+        }
+      ]
+    },
+    "vkGetAccelerationStructureMemoryRequirementsNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNVX-pInfo-parameter",
+          "text": " <code>pInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAccelerationStructureMemoryRequirementsInfoNVX</code> structure"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureMemoryRequirementsNVX-pMemoryRequirements-parameter",
+          "text": " <code>pMemoryRequirements</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>VkMemoryRequirements2KHR</code> structure"
+        }
+      ]
+    },
+    "vkGetAccelerationStructureScratchMemoryRequirementsNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkGetAccelerationStructureScratchMemoryRequirementsNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureScratchMemoryRequirementsNVX-pInfo-parameter",
+          "text": " <code>pInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAccelerationStructureMemoryRequirementsInfoNVX</code> structure"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureScratchMemoryRequirementsNVX-pMemoryRequirements-parameter",
+          "text": " <code>pMemoryRequirements</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>VkMemoryRequirements2KHR</code> structure"
+        }
+      ]
+    },
+    "VkAccelerationStructureMemoryRequirementsInfoNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX</code>"
+        },
+        {
+          "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNVX-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkAccelerationStructureMemoryRequirementsInfoNVX-accelerationStructure-parameter",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        }
+      ]
+    },
+    "vkBindAccelerationStructureMemoryNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkBindAccelerationStructureMemoryNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkBindAccelerationStructureMemoryNVX-pBindInfos-parameter",
+          "text": " <code>pBindInfos</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>bindInfoCount</code> valid <code>VkBindAccelerationStructureMemoryInfoNVX</code> structures"
+        },
+        {
+          "vuid": "VUID-vkBindAccelerationStructureMemoryNVX-bindInfoCount-arraylength",
+          "text": " <code>bindInfoCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        }
+      ]
+    },
+    "VkBindAccelerationStructureMemoryInfoNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX</code>"
+        },
+        {
+          "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-accelerationStructure-parameter",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-memory-parameter",
+          "text": " <code>memory</code> <strong class=\"purple\">must</strong> be a valid <code>VkDeviceMemory</code> handle"
+        },
+        {
+          "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-pDeviceIndices-parameter",
+          "text": " If <code>deviceIndexCount</code> is not <code>0</code>, <code>pDeviceIndices</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>deviceIndexCount</code> <code>uint32_t</code> values"
+        },
+        {
+          "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNVX-commonparent",
+          "text": " Both of <code>accelerationStructure</code>, and <code>memory</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
+    "vkGetAccelerationStructureHandleNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkGetAccelerationStructureHandleNVX-dataSize-02240",
+          "text": " <code>dataSize</code> <strong class=\"purple\">must</strong> be large enough to contain the result of the query, as described above"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureHandleNVX-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureHandleNVX-accelerationStructure-parameter",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureHandleNVX-pData-parameter",
+          "text": " <code>pData</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>dataSize</code> bytes"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureHandleNVX-dataSize-arraylength",
+          "text": " <code>dataSize</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        },
+        {
+          "vuid": "VUID-vkGetAccelerationStructureHandleNVX-accelerationStructure-parent",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
+        }
+      ]
+    },
+    "vkCreateSampler": {
+      "core": [
+        {
+          "vuid": "VUID-vkCreateSampler-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCreateSampler-pCreateInfo-parameter",
+          "text": " <code>pCreateInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkSamplerCreateInfo</code> structure"
+        },
+        {
+          "vuid": "VUID-vkCreateSampler-pAllocator-parameter",
+          "text": " If <code>pAllocator</code> is not <code>NULL</code>, <code>pAllocator</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAllocationCallbacks</code> structure"
+        },
+        {
+          "vuid": "VUID-vkCreateSampler-pSampler-parameter",
+          "text": " <code>pSampler</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>VkSampler</code> handle"
+        }
+      ]
+    },
+    "VkSamplerCreateInfo": {
+      "core": [
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-mipLodBias-01069",
+          "text": " The absolute value of <code>mipLodBias</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxSamplerLodBias</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-maxLod-01973",
+          "text": " <code>maxLod</code> <strong class=\"purple\">must</strong> be greater than or equal to <code>minLod</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01070",
+          "text": " If the <a href=\"#features-features-samplerAnisotropy\">anisotropic sampling</a> feature is not enabled, <code>anisotropyEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01071",
+          "text": " If <code>anisotropyEnable</code> is <code>VK_TRUE</code>, <code>maxAnisotropy</code> <strong class=\"purple\">must</strong> be between <code>1.0</code> and <code>VkPhysicalDeviceLimits</code>::<code>maxSamplerAnisotropy</code>, inclusive"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072",
+          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>minFilter</code> and <code>magFilter</code> <strong class=\"purple\">must</strong> be equal"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073",
+          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>mipmapMode</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLER_MIPMAP_MODE_NEAREST</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074",
+          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>minLod</code> and <code>maxLod</code> <strong class=\"purple\">must</strong> be zero"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075",
+          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>addressModeU</code> and <code>addressModeV</code> <strong class=\"purple\">must</strong> each be either <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code> or <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076",
+          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>anisotropyEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077",
+          "text": " If <code>unnormalizedCoordinates</code> is <code>VK_TRUE</code>, <code>compareEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01078",
+          "text": " If any of <code>addressModeU</code>, <code>addressModeV</code> or <code>addressModeW</code> are <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER</code>, <code>borderColor</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkBorderColor\">VkBorderColor</a> value"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079",
+          "text": " If the <code><a href=\"#VK_KHR_sampler_mirror_clamp_to_edge\">VK_KHR_sampler_mirror_clamp_to_edge</a></code> extension is not enabled, <code>addressModeU</code>, <code>addressModeV</code> and <code>addressModeW</code> <strong class=\"purple\">must</strong> not be <code>VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE</code>"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01080",
+          "text": " If <code>compareEnable</code> is <code>VK_TRUE</code>, <code>compareOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCompareOp\">VkCompareOp</a> value"
+        },
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO</code>"
         },
         {
@@ -8744,11 +9334,7 @@
         },
         {
           "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-parameter",
-          "text": " If <code>bindingCount</code> is not <code>0</code>, <code>pBindingFlags</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>bindingCount</code> valid combinations of <a href=\"#VkDescriptorBindingFlagBitsEXT\">VkDescriptorBindingFlagBitsEXT</a> values"
-        },
-        {
-          "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-requiredbitmask",
-          "text": " Each element of <code>pBindingFlags</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
+          "text": " If <code>bindingCount</code> is not <code>0</code>, and <code>pBindingFlags</code> is not <code>NULL</code>, <code>pBindingFlags</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>bindingCount</code> valid combinations of <a href=\"#VkDescriptorBindingFlagBitsEXT\">VkDescriptorBindingFlagBitsEXT</a> values"
         }
       ],
       "(VK_EXT_descriptor_indexing)+(VK_KHR_push_descriptor)": [
@@ -9562,7 +10148,11 @@
         },
         {
           "vuid": "VUID-VkWriteDescriptorSet-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDescriptorAccelerationStructureInfoNVX\">VkDescriptorAccelerationStructureInfoNVX</a> or <a href=\"#VkWriteDescriptorSetInlineUniformBlockEXT\">VkWriteDescriptorSetInlineUniformBlockEXT</a>"
+        },
+        {
+          "vuid": "VUID-VkWriteDescriptorSet-sType-unique",
+          "text": " Each <code>sType</code> member in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be unique"
         },
         {
           "vuid": "VUID-VkWriteDescriptorSet-descriptorType-parameter",
@@ -9657,10 +10247,6 @@
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT</code>"
         },
         {
-          "vuid": "VUID-VkWriteDescriptorSetInlineUniformBlockEXT-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
-        },
-        {
           "vuid": "VUID-VkWriteDescriptorSetInlineUniformBlockEXT-pData-parameter",
           "text": " <code>pData</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>dataSize</code> bytes"
         },
@@ -10114,6 +10700,26 @@
         }
       ]
     },
+    "VkDescriptorAccelerationStructureInfoNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-accelerationStructureCount-02236",
+          "text": " <code>accelerationStructureCount</code> <strong class=\"purple\">must</strong> be equal to descriptorCount in the extended structure."
+        },
+        {
+          "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX</code>"
+        },
+        {
+          "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-pAccelerationStructures-parameter",
+          "text": " <code>pAccelerationStructures</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>accelerationStructureCount</code> valid <code>VkAccelerationStructureNVX</code> handles"
+        },
+        {
+          "vuid": "VUID-VkDescriptorAccelerationStructureInfoNVX-accelerationStructureCount-arraylength",
+          "text": " <code>accelerationStructureCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        }
+      ]
+    },
     "vkCreateQueryPool": {
       "core": [
         {
@@ -12582,6 +13188,12 @@
           "vuid": "VUID-vkCmdDraw-sampleLocationsEnable-01512",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDraw-flags-02042",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "vkCmdDrawIndexed": {
@@ -12710,6 +13322,12 @@
           "vuid": "VUID-vkCmdDrawIndexed-sampleLocationsEnable-01513",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-flags-02043",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "vkCmdDrawIndirect": {
@@ -12874,6 +13492,12 @@
           "vuid": "VUID-vkCmdDrawIndirect-sampleLocationsEnable-01514",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-flags-02044",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "VkDrawIndirectCommand": {
@@ -13066,6 +13690,12 @@
           "vuid": "VUID-vkCmdDrawIndirectCountKHR-sampleLocationsEnable-03171",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_KHR_draw_indirect_count)+(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCountKHR-flags-02045",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "vkCmdDrawIndirectCountAMD": {
@@ -13236,6 +13866,12 @@
           "vuid": "VUID-vkCmdDrawIndirectCountAMD-sampleLocationsEnable-01515",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_AMD_draw_indirect_count)+(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCountAMD-flags-02046",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "vkCmdDrawIndexedIndirect": {
@@ -13400,6 +14036,12 @@
           "vuid": "VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-01516",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-flags-02047",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "VkDrawIndexedIndirectCommand": {
@@ -13596,6 +14238,12 @@
           "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-sampleLocationsEnable-03174",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_KHR_draw_indirect_count)+(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-flags-02048",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "vkCmdDrawIndexedIndirectCountAMD": {
@@ -13766,6 +14414,12 @@
           "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-sampleLocationsEnable-01517",
           "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
         }
+      ],
+      "(VK_AMD_draw_indirect_count)+(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-flags-02049",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "vkCmdBeginConditionalRenderingEXT": {
@@ -13840,58 +14494,520 @@
         }
       ]
     },
-    "VkPipelineVertexInputStateCreateInfo": {
-      "core": [
+    "vkCmdDrawMeshTasksNV": {
+      "(VK_NV_mesh_shader)": [
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613",
-          "text": " <code>vertexBindingDescriptionCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputBindings</code>"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-taskCount-02119",
+          "text": " <code>taskCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxDrawMeshTasksCount</code>"
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614",
-          "text": " <code>vertexAttributeDescriptionCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputAttributes</code>"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-renderPass-02120",
+          "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-binding-00615",
-          "text": " For every <code>binding</code> specified by each element of <code>pVertexAttributeDescriptions</code>, a <code>VkVertexInputBindingDescription</code> <strong class=\"purple\">must</strong> exist in <code>pVertexBindingDescriptions</code> with the same value of <code>binding</code>"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-subpass-02121",
+          "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616",
-          "text": " All elements of <code>pVertexBindingDescriptions</code> <strong class=\"purple\">must</strong> describe distinct binding numbers"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02122",
+          "text": " For each set <em>n</em> that is statically used by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, a descriptor set <strong class=\"purple\">must</strong> have been bound to <em>n</em> at <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, with a <code>VkPipelineLayout</code> that is compatible for set <em>n</em>, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617",
-          "text": " All elements of <code>pVertexAttributeDescriptions</code> <strong class=\"purple\">must</strong> describe distinct attribute locations"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02123",
+          "text": " For each push constant that is statically used by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, a push constant value <strong class=\"purple\">must</strong> have been set for <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, with a <code>VkPipelineLayout</code> that is compatible for push constants, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-sType-sType",
-          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO</code>"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02124",
+          "text": " Descriptors in each bound descriptor set, specified via <code>vkCmdBindDescriptorSets</code>, <strong class=\"purple\">must</strong> be valid if they are statically used by the currently bound <code>VkPipeline</code> object, specified via <code>vkCmdBindPipeline</code>"
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineVertexInputDivisorStateCreateInfoEXT\">VkPipelineVertexInputDivisorStateCreateInfoEXT</a>"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02125",
+          "text": " A valid graphics pipeline <strong class=\"purple\">must</strong> be bound to the current command buffer with <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask",
-          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02126",
+          "text": " If the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> requires any dynamic state, that state <strong class=\"purple\">must</strong> have been set on the current command buffer"
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter",
-          "text": " If <code>vertexBindingDescriptionCount</code> is not <code>0</code>, <code>pVertexBindingDescriptions</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>vertexBindingDescriptionCount</code> valid <code>VkVertexInputBindingDescription</code> structures"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02127",
+          "text": " Every input attachment used by the current subpass <strong class=\"purple\">must</strong> be bound to the pipeline via a descriptor set"
         },
         {
-          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter",
-          "text": " If <code>vertexAttributeDescriptionCount</code> is not <code>0</code>, <code>pVertexAttributeDescriptions</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>vertexAttributeDescriptionCount</code> valid <code>VkVertexInputAttributeDescription</code> structures"
-        }
-      ]
-    },
-    "VkVertexInputBindingDescription": {
-      "core": [
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02128",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used to sample from any <code>VkImage</code> with a <code>VkImageView</code> of the type <code>VK_IMAGE_VIEW_TYPE_3D</code>, <code>VK_IMAGE_VIEW_TYPE_CUBE</code>, <code>VK_IMAGE_VIEW_TYPE_1D_ARRAY</code>, <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code> or <code>VK_IMAGE_VIEW_TYPE_CUBE_ARRAY</code>, in any shader stage"
+        },
         {
-          "vuid": "VUID-VkVertexInputBindingDescription-binding-00618",
-          "text": " <code>binding</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputBindings</code>"
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02129",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions with <code>ImplicitLod</code>, <code>Dref</code> or <code>Proj</code> in their name, in any shader stage"
         },
         {
-          "vuid": "VUID-VkVertexInputBindingDescription-stride-00619",
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02130",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions that includes a LOD bias or any offset values, in any shader stage"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02131",
+          "text": " If the <a href=\"#features-features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and any shader stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> accesses a uniform buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of that buffer specified in the currently bound descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02132",
+          "text": " If the <a href=\"#features-features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and any shader stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> accesses a storage buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of that buffer specified in the currently bound descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-linearTilingFeatures-02133",
+          "text": " Any <code>VkImageView</code> being sampled with <code>VK_FILTER_LINEAR</code> as a result of this command <strong class=\"purple\">must</strong> be of a format which supports linear filtering, as specified by the <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT</code> flag in <code>VkFormatProperties</code>::<code>linearTilingFeatures</code> (for a linear image) or <code>VkFormatProperties</code>::<code>optimalTilingFeatures</code>(for an optimally tiled image) returned by <code>vkGetPhysicalDeviceFormatProperties</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02134",
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-renderpass",
+          "text": " This command <strong class=\"purple\">must</strong> only be called inside of a render pass instance"
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-linearTilingFeatures-02135",
+          "text": " Any <a href=\"#VkImageView\">VkImageView</a> being sampled with <code>VK_FILTER_CUBIC_IMG</code> as a result of this command <strong class=\"purple\">must</strong> be of a format which supports cubic filtering, as specified by the <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG</code> flag in <code>VkFormatProperties</code>::<code>linearTilingFeatures</code> (for a linear image) or <code>VkFormatProperties</code>::<code>optimalTilingFeatures</code>(for an optimally tiled image) returned by <code>vkGetPhysicalDeviceFormatProperties</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02136",
+          "text": " Any <a href=\"#VkImageView\">VkImageView</a> being sampled with <code>VK_FILTER_CUBIC_IMG</code> as a result of this command <strong class=\"purple\">must</strong> not have a <a href=\"#VkImageViewType\">VkImageViewType</a> of <code>VK_IMAGE_VIEW_TYPE_3D</code>, <code>VK_IMAGE_VIEW_TYPE_CUBE</code>, or <code>VK_IMAGE_VIEW_TYPE_CUBE_ARRAY</code>"
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_KHR_multiview)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-maxMultiviewInstanceIndex-02137",
+          "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-02138",
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer, and any pipeline stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> reads from or writes to any image or buffer, that image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-02139",
+          "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> writes to any image or buffer, that image or buffer <strong class=\"purple\">must</strong> not be an unprotected image or unprotected buffer."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-02140",
+          "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> reads from or writes to any image or buffer, the image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-sampleLocationsEnable-02141",
+          "text": " If the currently bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-flags-02142",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
+      ]
+    },
+    "vkCmdDrawMeshTasksIndirectNV": {
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02143",
+          "text": " If <code>buffer</code> is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02144",
+          "text": " <code>buffer</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-offset-02145",
+          "text": " <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146",
+          "text": " If <code>drawCount</code> is greater than <code>1</code>, <code>stride</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code> and <strong class=\"purple\">must</strong> be greater than or equal to <code>sizeof</code>(<code>VkDrawMeshTasksIndirectCommandNV</code>)"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02147",
+          "text": " If the <a href=\"#features-features-multiDrawIndirect\">multi-draw indirect</a> feature is not enabled, <code>drawCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or <code>1</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-renderPass-02148",
+          "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-subpass-02149",
+          "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02150",
+          "text": " For each set <em>n</em> that is statically used by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, a descriptor set <strong class=\"purple\">must</strong> have been bound to <em>n</em> at <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, with a <code>VkPipelineLayout</code> that is compatible for set <em>n</em>, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02151",
+          "text": " For each push constant that is statically used by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, a push constant value <strong class=\"purple\">must</strong> have been set for <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, with a <code>VkPipelineLayout</code> that is compatible for push constants, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02152",
+          "text": " Descriptors in each bound descriptor set, specified via <code>vkCmdBindDescriptorSets</code>, <strong class=\"purple\">must</strong> be valid if they are statically used by the currently bound <code>VkPipeline</code> object, specified via <code>vkCmdBindPipeline</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02153",
+          "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point&#8217;s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02154",
+          "text": " A valid graphics pipeline <strong class=\"purple\">must</strong> be bound to the current command buffer with <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02155",
+          "text": " If the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> requires any dynamic state, that state <strong class=\"purple\">must</strong> have been set on the current command buffer"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02156",
+          "text": " If <code>drawCount</code> is equal to <code>1</code>, <span class=\"eq\">(<code>offset</code> &#43; <code>sizeof</code>(<a href=\"#VkDrawMeshTasksIndirectCommandNV\">VkDrawMeshTasksIndirectCommandNV</a>))</span> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>buffer</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02157",
+          "text": " If <code>drawCount</code> is greater than <code>1</code>, <span class=\"eq\">(<code>stride</code> {times} (<code>drawCount</code> - 1) &#43; <code>offset</code> &#43; <code>sizeof</code>(<a href=\"#VkDrawMeshTasksIndirectCommandNV\">VkDrawMeshTasksIndirectCommandNV</a>))</span> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>buffer</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02158",
+          "text": " <code>drawCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxDrawIndirectCount</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02159",
+          "text": " Every input attachment used by the current subpass <strong class=\"purple\">must</strong> be bound to the pipeline via a descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02160",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used to sample from any <code>VkImage</code> with a <code>VkImageView</code> of the type <code>VK_IMAGE_VIEW_TYPE_3D</code>, <code>VK_IMAGE_VIEW_TYPE_CUBE</code>, <code>VK_IMAGE_VIEW_TYPE_1D_ARRAY</code>, <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code> or <code>VK_IMAGE_VIEW_TYPE_CUBE_ARRAY</code>, in any shader stage"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02161",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions with <code>ImplicitLod</code>, <code>Dref</code> or <code>Proj</code> in their name, in any shader stage"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02162",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions that includes a LOD bias or any offset values, in any shader stage"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02163",
+          "text": " If the <a href=\"#features-features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and any shader stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> accesses a uniform buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of that buffer specified in the currently bound descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02164",
+          "text": " If the <a href=\"#features-features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and any shader stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> accesses a storage buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of that buffer specified in the currently bound descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-linearTilingFeatures-02165",
+          "text": " Any <code>VkImageView</code> being sampled with <code>VK_FILTER_LINEAR</code> as a result of this command <strong class=\"purple\">must</strong> be of a format which supports linear filtering, as specified by the <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT</code> flag in <code>VkFormatProperties</code>::<code>linearTilingFeatures</code> (for a linear image) or <code>VkFormatProperties</code>::<code>optimalTilingFeatures</code>(for an optimally tiled image) returned by <code>vkGetPhysicalDeviceFormatProperties</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02166",
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-parameter",
+          "text": " <code>buffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-renderpass",
+          "text": " This command <strong class=\"purple\">must</strong> only be called inside of a render pass instance"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commonparent",
+          "text": " Both of <code>buffer</code>, and <code>commandBuffer</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-linearTilingFeatures-02167",
+          "text": " Any <a href=\"#VkImageView\">VkImageView</a> being sampled with <code>VK_FILTER_CUBIC_IMG</code> as a result of this command <strong class=\"purple\">must</strong> be of a format which supports cubic filtering, as specified by the <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG</code> flag in <code>VkFormatProperties</code>::<code>linearTilingFeatures</code> (for a linear image) or <code>VkFormatProperties</code>::<code>optimalTilingFeatures</code>(for an optimally tiled image) returned by <code>vkGetPhysicalDeviceFormatProperties</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02168",
+          "text": " Any <a href=\"#VkImageView\">VkImageView</a> being sampled with <code>VK_FILTER_CUBIC_IMG</code> as a result of this command <strong class=\"purple\">must</strong> not have a <a href=\"#VkImageViewType\">VkImageViewType</a> of <code>VK_IMAGE_VIEW_TYPE_3D</code>, <code>VK_IMAGE_VIEW_TYPE_CUBE</code>, or <code>VK_IMAGE_VIEW_TYPE_CUBE_ARRAY</code>"
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_KHR_multiview)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-maxMultiviewInstanceIndex-02169",
+          "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02170",
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer, and any pipeline stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> reads from or writes to any image or buffer, that image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02171",
+          "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> writes to any image or buffer, that image or buffer <strong class=\"purple\">must</strong> not be an unprotected image or unprotected buffer."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02172",
+          "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> reads from or writes to any image or buffer, the image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-sampleLocationsEnable-02173",
+          "text": " If the currently bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-flags-02174",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
+      ]
+    },
+    "VkDrawMeshTasksIndirectCommandNV": {
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkDrawMeshTasksIndirectCommandNV-taskCount-02175",
+          "text": " <code>taskCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxDrawMeshTasksCount</code>"
+        }
+      ]
+    },
+    "vkCmdDrawMeshTasksIndirectCountNV": {
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02176",
+          "text": " If <code>buffer</code> is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02177",
+          "text": " <code>buffer</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02178",
+          "text": " If <code>countBuffer</code> is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02179",
+          "text": " <code>countBuffer</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-offset-02180",
+          "text": " <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBufferOffset-02181",
+          "text": " <code>countBufferOffset</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stride-02182",
+          "text": " <code>stride</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code> and <strong class=\"purple\">must</strong> be greater than or equal to <code>sizeof</code>(<code>VkDrawMeshTasksIndirectCommandNV</code>)"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maxDrawCount-02183",
+          "text": " If <code>maxDrawCount</code> is greater than or equal to <code>1</code>, <span class=\"eq\">(<code>stride</code> {times} (<code>maxDrawCount</code> - 1) &#43; <code>offset</code> &#43; <code>sizeof</code>(<code>VkDrawMeshTasksIndirectCommandNV</code>))</span> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>buffer</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-renderPass-02184",
+          "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-subpass-02185",
+          "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02186",
+          "text": " For each set <em>n</em> that is statically used by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, a descriptor set <strong class=\"purple\">must</strong> have been bound to <em>n</em> at <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, with a <code>VkPipelineLayout</code> that is compatible for set <em>n</em>, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02187",
+          "text": " For each push constant that is statically used by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, a push constant value <strong class=\"purple\">must</strong> have been set for <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>, with a <code>VkPipelineLayout</code> that is compatible for push constants, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02188",
+          "text": " Descriptors in each bound descriptor set, specified via <code>vkCmdBindDescriptorSets</code>, <strong class=\"purple\">must</strong> be valid if they are statically used by the currently bound <code>VkPipeline</code> object, specified via <code>vkCmdBindPipeline</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02189",
+          "text": " A valid graphics pipeline <strong class=\"purple\">must</strong> be bound to the current command buffer with <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02190",
+          "text": " If the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> requires any dynamic state, that state <strong class=\"purple\">must</strong> have been set on the current command buffer"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02191",
+          "text": " If the count stored in <code>countBuffer</code> is equal to <code>1</code>, <span class=\"eq\">(<code>offset</code> &#43; <code>sizeof</code>(<code>VkDrawMeshTasksIndirectCommandNV</code>))</span> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>buffer</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02192",
+          "text": " If the count stored in <code>countBuffer</code> is greater than <code>1</code>, <span class=\"eq\">(<code>stride</code> {times} (<code>drawCount</code> - 1) &#43; <code>offset</code> &#43; <code>sizeof</code>(<code>VkDrawMeshTasksIndirectCommandNV</code>))</span> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>buffer</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02193",
+          "text": " The count stored in <code>countBuffer</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxDrawIndirectCount</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02194",
+          "text": " Every input attachment used by the current subpass <strong class=\"purple\">must</strong> be bound to the pipeline via a descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02195",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used to sample from any <code>VkImage</code> with a <code>VkImageView</code> of the type <code>VK_IMAGE_VIEW_TYPE_3D</code>, <code>VK_IMAGE_VIEW_TYPE_CUBE</code>, <code>VK_IMAGE_VIEW_TYPE_1D_ARRAY</code>, <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code> or <code>VK_IMAGE_VIEW_TYPE_CUBE_ARRAY</code>, in any shader stage"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02196",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions with <code>ImplicitLod</code>, <code>Dref</code> or <code>Proj</code> in their name, in any shader stage"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02197",
+          "text": " If any <code>VkSampler</code> object that is accessed from a shader by the <code>VkPipeline</code> currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> uses unnormalized coordinates, it <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions that includes a LOD bias or any offset values, in any shader stage"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02198",
+          "text": " If the <a href=\"#features-features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and any shader stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> accesses a uniform buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of that buffer specified in the currently bound descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02199",
+          "text": " If the <a href=\"#features-features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and any shader stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> accesses a storage buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of that buffer specified in the currently bound descriptor set"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-linearTilingFeatures-02200",
+          "text": " Any <code>VkImageView</code> being sampled with <code>VK_FILTER_LINEAR</code> as a result of this command <strong class=\"purple\">must</strong> be of a format which supports linear filtering, as specified by the <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT</code> flag in <code>VkFormatProperties</code>::<code>linearTilingFeatures</code> (for a linear image) or <code>VkFormatProperties</code>::<code>optimalTilingFeatures</code>(for an optimally tiled image) returned by <code>vkGetPhysicalDeviceFormatProperties</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02201",
+          "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-parameter",
+          "text": " <code>buffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-parameter",
+          "text": " <code>countBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-renderpass",
+          "text": " This command <strong class=\"purple\">must</strong> only be called inside of a render pass instance"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent",
+          "text": " Each of <code>buffer</code>, <code>commandBuffer</code>, and <code>countBuffer</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_KHR_multiview)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maxMultiviewInstanceIndex-02202",
+          "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02203",
+          "text": " If <code>commandBuffer</code> is an unprotected command buffer, and any pipeline stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> reads from or writes to any image or buffer, that image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02204",
+          "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> writes to any image or buffer, that image or buffer <strong class=\"purple\">must</strong> not be an unprotected image or unprotected buffer."
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02205",
+          "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the <code>VkPipeline</code> object currently bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code> reads from or writes to any image or buffer, the image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
+        }
+      ],
+      "(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-sampleLocationsEnable-02206",
+          "text": " If the currently bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
+        }
+      ]
+    },
+    "VkPipelineVertexInputStateCreateInfo": {
+      "core": [
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613",
+          "text": " <code>vertexBindingDescriptionCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputBindings</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614",
+          "text": " <code>vertexAttributeDescriptionCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputAttributes</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-binding-00615",
+          "text": " For every <code>binding</code> specified by each element of <code>pVertexAttributeDescriptions</code>, a <code>VkVertexInputBindingDescription</code> <strong class=\"purple\">must</strong> exist in <code>pVertexBindingDescriptions</code> with the same value of <code>binding</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616",
+          "text": " All elements of <code>pVertexBindingDescriptions</code> <strong class=\"purple\">must</strong> describe distinct binding numbers"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617",
+          "text": " All elements of <code>pVertexAttributeDescriptions</code> <strong class=\"purple\">must</strong> describe distinct attribute locations"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineVertexInputDivisorStateCreateInfoEXT\">VkPipelineVertexInputDivisorStateCreateInfoEXT</a>"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter",
+          "text": " If <code>vertexBindingDescriptionCount</code> is not <code>0</code>, <code>pVertexBindingDescriptions</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>vertexBindingDescriptionCount</code> valid <code>VkVertexInputBindingDescription</code> structures"
+        },
+        {
+          "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter",
+          "text": " If <code>vertexAttributeDescriptionCount</code> is not <code>0</code>, <code>pVertexAttributeDescriptions</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>vertexAttributeDescriptionCount</code> valid <code>VkVertexInputAttributeDescription</code> structures"
+        }
+      ]
+    },
+    "VkVertexInputBindingDescription": {
+      "core": [
+        {
+          "vuid": "VUID-VkVertexInputBindingDescription-binding-00618",
+          "text": " <code>binding</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputBindings</code>"
+        },
+        {
+          "vuid": "VUID-VkVertexInputBindingDescription-stride-00619",
           "text": " <code>stride</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputBindingStride</code>"
         },
         {
@@ -14164,7 +15280,7 @@
         },
         {
           "vuid": "VUID-VkPipelineViewportStateCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineViewportSwizzleStateCreateInfoNV\">VkPipelineViewportSwizzleStateCreateInfoNV</a> or <a href=\"#VkPipelineViewportWScalingStateCreateInfoNV\">VkPipelineViewportWScalingStateCreateInfoNV</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineViewportCoarseSampleOrderStateCreateInfoNV\">VkPipelineViewportCoarseSampleOrderStateCreateInfoNV</a>, <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>, <a href=\"#VkPipelineViewportShadingRateImageStateCreateInfoNV\">VkPipelineViewportShadingRateImageStateCreateInfoNV</a>, <a href=\"#VkPipelineViewportSwizzleStateCreateInfoNV\">VkPipelineViewportSwizzleStateCreateInfoNV</a>, or <a href=\"#VkPipelineViewportWScalingStateCreateInfoNV\">VkPipelineViewportWScalingStateCreateInfoNV</a>"
         },
         {
           "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-unique",
@@ -14389,97 +15505,349 @@
           "text": " <code>rasterizationSamples</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value"
         },
         {
-          "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter",
-          "text": " If <code>pSampleMask</code> is not <code>NULL</code>, <code>pSampleMask</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of \\(\\lceil{\\mathit{rasterizationSamples} \\over 32}\\rceil\\) <code>VkSampleMask</code> values"
-        }
-      ],
-      "(VK_NV_framebuffer_mixed_samples)": [
+          "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter",
+          "text": " If <code>pSampleMask</code> is not <code>NULL</code>, <code>pSampleMask</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of \\(\\lceil{\\mathit{rasterizationSamples} \\over 32}\\rceil\\) <code>VkSampleMask</code> values"
+        }
+      ],
+      "(VK_NV_framebuffer_mixed_samples)": [
+        {
+          "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415",
+          "text": " If the subpass has any color attachments and <code>rasterizationSamples</code> is greater than the number of color samples, then <code>sampleShadingEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+        }
+      ]
+    },
+    "VkPipelineRasterizationStateRasterizationOrderAMD": {
+      "(VK_AMD_rasterization_order)": [
+        {
+          "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter",
+          "text": " <code>rasterizationOrder</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkRasterizationOrderAMD\">VkRasterizationOrderAMD</a> value"
+        }
+      ]
+    },
+    "VkPipelineSampleLocationsStateCreateInfoEXT": {
+      "(VK_EXT_sample_locations)": [
+        {
+          "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter",
+          "text": " <code>sampleLocationsInfo</code> <strong class=\"purple\">must</strong> be a valid <code>VkSampleLocationsInfoEXT</code> structure"
+        }
+      ]
+    },
+    "VkSampleLocationsInfoEXT": {
+      "(VK_EXT_sample_locations)": [
+        {
+          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526",
+          "text": " <code>sampleLocationsPerPixel</code> <strong class=\"purple\">must</strong> be a bit value that is set in <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>::<code>sampleLocationSampleCounts</code>"
+        },
+        {
+          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527",
+          "text": " <code>sampleLocationsCount</code> <strong class=\"purple\">must</strong> equal <span class=\"eq\"><code>sampleLocationsPerPixel</code> {times} <code>sampleLocationGridSize.width</code> {times} <code>sampleLocationGridSize.height</code></span>"
+        },
+        {
+          "vuid": "VUID-VkSampleLocationsInfoEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT</code>"
+        },
+        {
+          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter",
+          "text": " <code>sampleLocationsPerPixel</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value"
+        },
+        {
+          "vuid": "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter",
+          "text": " <code>pSampleLocations</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>sampleLocationsCount</code> <code>VkSampleLocationEXT</code> structures"
+        },
+        {
+          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength",
+          "text": " <code>sampleLocationsCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        }
+      ]
+    },
+    "vkCmdSetSampleLocationsEXT": {
+      "(VK_EXT_sample_locations)": [
+        {
+          "vuid": "VUID-vkCmdSetSampleLocationsEXT-None-01528",
+          "text": " The bound graphics pipeline <strong class=\"purple\">must</strong> have been created with the <code>VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT</code> dynamic state enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529",
+          "text": " The <code>sampleLocationsPerPixel</code> member of <code>pSampleLocationsInfo</code> <strong class=\"purple\">must</strong> equal the <code>rasterizationSamples</code> member of the <a href=\"#VkPipelineMultisampleStateCreateInfo\">VkPipelineMultisampleStateCreateInfo</a> structure the bound graphics pipeline has been created with"
+        },
+        {
+          "vuid": "VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530",
+          "text": " If <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>::<code>variableSampleLocations</code> is <code>VK_FALSE</code> then the current render pass <strong class=\"purple\">must</strong> have been begun by specifying a <a href=\"#VkRenderPassSampleLocationsBeginInfoEXT\">VkRenderPassSampleLocationsBeginInfoEXT</a> structure whose <code>pPostSubpassSampleLocations</code> member contains an element with a <code>subpassIndex</code> matching the current subpass index and the <code>sampleLocationsInfo</code> member of that element <strong class=\"purple\">must</strong> match the sample locations state pointed to by <code>pSampleLocationsInfo</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter",
+          "text": " <code>pSampleLocationsInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkSampleLocationsInfoEXT</code> structure"
+        },
+        {
+          "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        }
+      ]
+    },
+    "VkPipelineViewportShadingRateImageStateCreateInfoNV": {
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02054",
+          "text": " If the <a href=\"#features-features-multiViewport\">multiple viewports</a> feature is not enabled, <code>viewportCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or <code>1</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02055",
+          "text": " <code>viewportCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxViewports</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-shadingRateImageEnable-02056",
+          "text": " If <code>shadingRateImageEnable</code> is <code>VK_TRUE</code>, <code>viewportCount</code> <strong class=\"purple\">must</strong> be equal to the <code>viewportCount</code> member of <code>VkPipelineViewportStateCreateInfo</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-pDynamicStates-02057",
+          "text": " If no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> is <code>VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV</code>, <code>pShadingRatePalettes</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>viewportCount</code> <code>VkShadingRatePaletteNV</code> structures"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-pShadingRatePalettes-parameter",
+          "text": " If <code>viewportCount</code> is not <code>0</code>, and <code>pShadingRatePalettes</code> is not <code>NULL</code>, <code>pShadingRatePalettes</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>viewportCount</code> valid <code>VkShadingRatePaletteNV</code> structures"
+        }
+      ]
+    },
+    "vkCmdBindShadingRateImageNV": {
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-None-02058",
+          "text": " The <a href=\"#features-features-shadingRateImage\">shading rate image</a> feature <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02059",
+          "text": " If <code>imageView</code> is not <code>VK_NULL_HANDLE</code>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageView\">VkImageView</a> handle of type <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02060",
+          "text": " If <code>imageView</code> is not <code>VK_NULL_HANDLE</code>, it <strong class=\"purple\">must</strong> have a format of <code>VK_FORMAT_R8_UINT</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02061",
+          "text": " If <code>imageView</code> is not <code>VK_NULL_HANDLE</code>, the image <strong class=\"purple\">must</strong> have been created with <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code> set"
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02062",
+          "text": " If <code>imageView</code> is not <code>VK_NULL_HANDLE</code>, <code>imageLayout</code> <strong class=\"purple\">must</strong> match the actual <code>VkImageLayout</code> of each subresource accessible from <code>imageView</code> at the time the subresource is accessed."
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-imageLayout-02063",
+          "text": " If <code>imageView</code> is not <code>VK_NULL_HANDLE</code>, <code>imageLayout</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV</code> or <code>VK_IMAGE_LAYOUT_GENERAL</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-parameter",
+          "text": " <code>imageView</code> <strong class=\"purple\">must</strong> be a valid <code>VkImageView</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-imageLayout-parameter",
+          "text": " <code>imageLayout</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageLayout\">VkImageLayout</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        },
+        {
+          "vuid": "VUID-vkCmdBindShadingRateImageNV-commonparent",
+          "text": " Both of <code>commandBuffer</code>, and <code>imageView</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
+    "vkCmdSetViewportShadingRatePaletteNV": {
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-None-02064",
+          "text": " The <a href=\"#features-features-shadingRateImage\">shading rate image</a> feature <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-None-02065",
+          "text": " The bound graphics pipeline <strong class=\"purple\">must</strong> have been created with the <code>VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV</code> dynamic state enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02066",
+          "text": " <code>firstViewport</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxViewports</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02067",
+          "text": " The sum of <code>firstViewport</code> and <code>viewportCount</code> <strong class=\"purple\">must</strong> be between <code>1</code> and <code>VkPhysicalDeviceLimits</code>::<code>maxViewports</code>, inclusive"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02068",
+          "text": " If the <a href=\"#features-features-multiViewport\">multiple viewports</a> feature is not enabled, <code>firstViewport</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-viewportCount-02069",
+          "text": " If the <a href=\"#features-features-multiViewport\">multiple viewports</a> feature is not enabled, <code>viewportCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-pShadingRatePalettes-parameter",
+          "text": " <code>pShadingRatePalettes</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>viewportCount</code> valid <code>VkShadingRatePaletteNV</code> structures"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        },
         {
-          "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415",
-          "text": " If the subpass has any color attachments and <code>rasterizationSamples</code> is greater than the number of color samples, then <code>sampleShadingEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+          "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-viewportCount-arraylength",
+          "text": " <code>viewportCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         }
       ]
     },
-    "VkPipelineRasterizationStateRasterizationOrderAMD": {
-      "(VK_AMD_rasterization_order)": [
+    "VkShadingRatePaletteNV": {
+      "(VK_NV_shading_rate_image)": [
         {
-          "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType",
-          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD</code>"
+          "vuid": "VUID-VkShadingRatePaletteNV-shadingRatePaletteEntryCount-02071",
+          "text": " <code>shadingRatePaletteEntryCount</code> <strong class=\"purple\">must</strong> be between <code>1</code> and <code>VkPhysicalDeviceShadingRateImagePropertiesNV</code>::<code>shadingRatePaletteSize</code>, inclusive"
         },
         {
-          "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter",
-          "text": " <code>rasterizationOrder</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkRasterizationOrderAMD\">VkRasterizationOrderAMD</a> value"
+          "vuid": "VUID-VkShadingRatePaletteNV-pShadingRatePaletteEntries-parameter",
+          "text": " <code>pShadingRatePaletteEntries</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>shadingRatePaletteEntryCount</code> valid <a href=\"#VkShadingRatePaletteEntryNV\">VkShadingRatePaletteEntryNV</a> values"
+        },
+        {
+          "vuid": "VUID-VkShadingRatePaletteNV-shadingRatePaletteEntryCount-arraylength",
+          "text": " <code>shadingRatePaletteEntryCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         }
       ]
     },
-    "VkPipelineSampleLocationsStateCreateInfoEXT": {
-      "(VK_EXT_sample_locations)": [
+    "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV": {
+      "(VK_NV_shading_rate_image)": [
         {
-          "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType",
-          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT</code>"
+          "vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sampleOrderType-02072",
+          "text": " If <code>sampleOrderType</code> is not <code>VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV</code>, <code>customSamplerOrderCount</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
         {
-          "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter",
-          "text": " <code>sampleLocationsInfo</code> <strong class=\"purple\">must</strong> be a valid <code>VkSampleLocationsInfoEXT</code> structure"
+          "vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-pCustomSampleOrders-02234",
+          "text": " The array <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> not contain two structures with matching values for both the <code>shadingRate</code> and <code>sampleCount</code> members."
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sampleOrderType-parameter",
+          "text": " <code>sampleOrderType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCoarseSampleOrderTypeNV\">VkCoarseSampleOrderTypeNV</a> value"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-pCustomSampleOrders-parameter",
+          "text": " If <code>customSampleOrderCount</code> is not <code>0</code>, <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>customSampleOrderCount</code> valid <code>VkCoarseSampleOrderCustomNV</code> structures"
         }
       ]
     },
-    "VkSampleLocationsInfoEXT": {
-      "(VK_EXT_sample_locations)": [
+    "VkCoarseSampleOrderCustomNV": {
+      "(VK_NV_shading_rate_image)": [
         {
-          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526",
-          "text": " <code>sampleLocationsPerPixel</code> <strong class=\"purple\">must</strong> be a bit value that is set in <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>::<code>sampleLocationSampleCounts</code>"
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-shadingRate-02073",
+          "text": " <code>shadingRate</code> <strong class=\"purple\">must</strong> be a shading rate that generates fragments with more than one pixel."
         },
         {
-          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527",
-          "text": " <code>sampleLocationsCount</code> <strong class=\"purple\">must</strong> equal <span class=\"eq\"><code>sampleLocationsPerPixel</code> {times} <code>sampleLocationGridSize.width</code> {times} <code>sampleLocationGridSize.height</code></span>"
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleCount-02074",
+          "text": " <code>sampleCount</code> <strong class=\"purple\">must</strong> correspond to a sample count enumerated in <a href=\"#VkSampleCountFlags\">VkSampleCountFlags</a> whose corresponding bit is set in <code>VkPhysicalDeviceLimits</code>::<code>framebufferNoAttachmentsSampleCounts</code>."
         },
         {
-          "vuid": "VUID-VkSampleLocationsInfoEXT-sType-sType",
-          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT</code>"
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02075",
+          "text": " <code>sampleLocationCount</code> <strong class=\"purple\">must</strong> be equal to the product of <code>sampleCount</code>, the fragment width for <code>shadingRate</code>, and the fragment height for <code>shadingRate</code>."
         },
         {
-          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter",
-          "text": " <code>sampleLocationsPerPixel</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> value"
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02076",
+          "text": " <code>sampleLocationCount</code> <strong class=\"purple\">must</strong> be less than or equal to the value of <code>VkPhysicalDeviceShadingRateImagePropertiesNV</code>::<code>shadingRateMaxCoarseSamples</code>."
         },
         {
-          "vuid": "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter",
-          "text": " <code>pSampleLocations</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>sampleLocationsCount</code> <code>VkSampleLocationEXT</code> structures"
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-02077",
+          "text": " The array <code>pSampleLocations</code> <strong class=\"purple\">must</strong> contain exactly one entry for every combination of valid values for <code>pixelX</code>, <code>pixelY</code>, and <code>sample</code> in the structure <a href=\"#VkCoarseSampleOrderCustomNV\">VkCoarseSampleOrderCustomNV</a>."
         },
         {
-          "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength",
-          "text": " <code>sampleLocationsCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-shadingRate-parameter",
+          "text": " <code>shadingRate</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkShadingRatePaletteEntryNV\">VkShadingRatePaletteEntryNV</a> value"
+        },
+        {
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-parameter",
+          "text": " <code>pSampleLocations</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>sampleLocationCount</code> <code>VkCoarseSampleLocationNV</code> structures"
+        },
+        {
+          "vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-arraylength",
+          "text": " <code>sampleLocationCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         }
       ]
     },
-    "vkCmdSetSampleLocationsEXT": {
-      "(VK_EXT_sample_locations)": [
+    "VkCoarseSampleLocationNV": {
+      "(VK_NV_shading_rate_image)": [
         {
-          "vuid": "VUID-vkCmdSetSampleLocationsEXT-None-01528",
-          "text": " The bound graphics pipeline <strong class=\"purple\">must</strong> have been created with the <code>VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT</code> dynamic state enabled"
+          "vuid": "VUID-VkCoarseSampleLocationNV-pixelX-02078",
+          "text": " <code>pixelX</code> <strong class=\"purple\">must</strong> be less than the width (in pixels) of the fragment."
         },
         {
-          "vuid": "VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529",
-          "text": " The <code>sampleLocationsPerPixel</code> member of <code>pSampleLocationsInfo</code> <strong class=\"purple\">must</strong> equal the <code>rasterizationSamples</code> member of the <a href=\"#VkPipelineMultisampleStateCreateInfo\">VkPipelineMultisampleStateCreateInfo</a> structure the bound graphics pipeline has been created with"
+          "vuid": "VUID-VkCoarseSampleLocationNV-pixelY-02079",
+          "text": " <code>pixelY</code> <strong class=\"purple\">must</strong> be less than the height (in pixels) of the fragment."
         },
         {
-          "vuid": "VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530",
-          "text": " If <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>::<code>variableSampleLocations</code> is <code>VK_FALSE</code> then the current render pass <strong class=\"purple\">must</strong> have been begun by specifying a <a href=\"#VkRenderPassSampleLocationsBeginInfoEXT\">VkRenderPassSampleLocationsBeginInfoEXT</a> structure whose <code>pPostSubpassSampleLocations</code> member contains an element with a <code>subpassIndex</code> matching the current subpass index and the <code>sampleLocationsInfo</code> member of that element <strong class=\"purple\">must</strong> match the sample locations state pointed to by <code>pSampleLocationsInfo</code>"
+          "vuid": "VUID-VkCoarseSampleLocationNV-sample-02080",
+          "text": " <code>sample</code> <strong class=\"purple\">must</strong> be less than the number of coverage samples in each pixel belonging to the fragment."
+        }
+      ]
+    },
+    "vkCmdSetCoarseSampleOrderNV": {
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-sampleOrderType-02081",
+          "text": " If <code>sampleOrderType</code> is not <code>VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV</code>, <code>customSamplerOrderCount</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
         {
-          "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter",
+          "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-pCustomSampleOrders-02235",
+          "text": " The array <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> not contain two structures with matching values for both the <code>shadingRate</code> and <code>sampleCount</code> members."
+        },
+        {
+          "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-parameter",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
         },
         {
-          "vuid": "VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter",
-          "text": " <code>pSampleLocationsInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkSampleLocationsInfoEXT</code> structure"
+          "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-sampleOrderType-parameter",
+          "text": " <code>sampleOrderType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCoarseSampleOrderTypeNV\">VkCoarseSampleOrderTypeNV</a> value"
         },
         {
-          "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording",
+          "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-pCustomSampleOrders-parameter",
+          "text": " If <code>customSampleOrderCount</code> is not <code>0</code>, <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>customSampleOrderCount</code> valid <code>VkCoarseSampleOrderCustomNV</code> structures"
+        },
+        {
+          "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-recording",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
         },
         {
-          "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool",
+          "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-cmdpool",
           "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
         }
       ]
@@ -14672,6 +16040,94 @@
         }
       ]
     },
+    "VkPipelineViewportExclusiveScissorStateCreateInfoNV": {
+      "(VK_NV_scissor_exclusive)": [
+        {
+          "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027",
+          "text": " If the <a href=\"#features-features-multiViewport\">multiple viewports</a> feature is not enabled, <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or <code>1</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02028",
+          "text": " <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxViewports</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029",
+          "text": " <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or identical to the <code>viewportCount</code> member of <code>VkPipelineViewportStateCreateInfo</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pDynamicStates-02030",
+          "text": " If no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> is <code>VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV</code> and <code>exclusiveScissorCount</code> is not <code>0</code>, <code>pExclusiveScissors</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>exclusiveScissorCount</code> <code>VkRect2D</code> structures"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pExclusiveScissors-parameter",
+          "text": " If <code>exclusiveScissorCount</code> is not <code>0</code>, and <code>pExclusiveScissors</code> is not <code>NULL</code>, <code>pExclusiveScissors</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>exclusiveScissorCount</code> <code>VkRect2D</code> structures"
+        }
+      ]
+    },
+    "vkCmdSetExclusiveScissorNV": {
+      "(VK_NV_scissor_exclusive)": [
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-None-02031",
+          "text": " The <a href=\"#features-features-exclusiveScissor\">exclusive scissor</a> feature <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-None-02032",
+          "text": " The bound graphics pipeline <strong class=\"purple\">must</strong> have been created with the <code>VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV</code> dynamic state enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02033",
+          "text": " <code>firstExclusiveScissor</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxViewports</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02034",
+          "text": " The sum of <code>firstExclusiveScissor</code> and <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be between <code>1</code> and <code>VkPhysicalDeviceLimits</code>::<code>maxViewports</code>, inclusive"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035",
+          "text": " If the <a href=\"#features-features-multiViewport\">multiple viewports</a> feature is not enabled, <code>firstExclusiveScissor</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036",
+          "text": " If the <a href=\"#features-features-multiViewport\">multiple viewports</a> feature is not enabled, <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-x-02037",
+          "text": " The <code>x</code> and <code>y</code> members of <code>offset</code> in each member of <code>pExclusiveScissors</code> <strong class=\"purple\">must</strong> be greater than or equal to <code>0</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-offset-02038",
+          "text": " Evaluation of <span class=\"eq\">(<code>offset.x</code> &#43; <code>extent.width</code>)</span> for each member of <code>pExclusiveScissors</code> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-offset-02039",
+          "text": " Evaluation of <span class=\"eq\">(<code>offset.y</code> &#43; <code>extent.height</code>)</span> for each member of <code>pExclusiveScissors</code> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-pExclusiveScissors-parameter",
+          "text": " <code>pExclusiveScissors</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>exclusiveScissorCount</code> <code>VkRect2D</code> structures"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        },
+        {
+          "vuid": "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-arraylength",
+          "text": " <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        }
+      ]
+    },
     "VkPipelineDepthStencilStateCreateInfo": {
       "core": [
         {
@@ -14848,6 +16304,14 @@
         }
       ]
     },
+    "VkPipelineRepresentativeFragmentTestStateCreateInfoNV": {
+      "(VK_NV_representative_fragment_test)": [
+        {
+          "vuid": "VUID-VkPipelineRepresentativeFragmentTestStateCreateInfoNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV</code>"
+        }
+      ]
+    },
     "VkPipelineCoverageToColorStateCreateInfoNV": {
       "(VK_NV_fragment_coverage_to_color)": [
         {
@@ -15128,6 +16592,12 @@
           "vuid": "VUID-vkCmdDispatch-commandBuffer-01846",
           "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the <code>VkPipeline</code> object bound to <code>VK_PIPELINE_POINT_COMPUTE</code> reads from any image or buffer, the image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
         }
+      ],
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDispatch-flags-02040",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "vkCmdDispatchIndirect": {
@@ -15236,6 +16706,12 @@
           "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-01849",
           "text": " If <code>commandBuffer</code> is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the <code>VkPipeline</code> object bound to <code>VK_PIPELINE_POINT_COMPUTE</code> reads from any image or buffer, the image or buffer <strong class=\"purple\">must</strong> not be a protected image or protected buffer."
         }
+      ],
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-vkCmdDispatchIndirect-flags-02041",
+          "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+        }
       ]
     },
     "VkDispatchIndirectCommand": {
@@ -18390,6 +19866,166 @@
         }
       ]
     },
+    "VkPhysicalDeviceRaytracingPropertiesNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceRaytracingPropertiesNVX-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX</code>"
+        }
+      ]
+    },
+    "vkCmdTraceRaysNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkCmdTraceRaysNVX-cmdBuf-parameter",
+          "text": " <code>cmdBuf</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdTraceRaysNVX-raygenShaderBindingTableBuffer-parameter",
+          "text": " <code>raygenShaderBindingTableBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdTraceRaysNVX-missShaderBindingTableBuffer-parameter",
+          "text": " <code>missShaderBindingTableBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdTraceRaysNVX-hitShaderBindingTableBuffer-parameter",
+          "text": " <code>hitShaderBindingTableBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdTraceRaysNVX-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdTraceRaysNVX-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, or compute operations"
+        },
+        {
+          "vuid": "VUID-vkCmdTraceRaysNVX-commonparent",
+          "text": " Each of <code>cmdBuf</code>, <code>hitShaderBindingTableBuffer</code>, <code>missShaderBindingTableBuffer</code>, and <code>raygenShaderBindingTableBuffer</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
+    "vkCmdBuildAccelerationStructureNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-geometryCount-02241",
+          "text": " <code>geometryCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceRaytracingPropertiesNVX</code>::<code>maxGeometryCount</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-cmdBuf-parameter",
+          "text": " <code>cmdBuf</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-type-parameter",
+          "text": " <code>type</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkAccelerationStructureTypeNVX\">VkAccelerationStructureTypeNVX</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-instanceData-parameter",
+          "text": " If <code>instanceData</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>instanceData</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-pGeometries-parameter",
+          "text": " If <code>geometryCount</code> is not <code>0</code>, <code>pGeometries</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>geometryCount</code> valid <code>VkGeometryNVX</code> structures"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-flags-parameter",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkBuildAccelerationStructureFlagBitsNVX\">VkBuildAccelerationStructureFlagBitsNVX</a> values"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-dst-parameter",
+          "text": " <code>dst</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-src-parameter",
+          "text": " If <code>src</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>src</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-scratch-parameter",
+          "text": " <code>scratch</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, or compute operations"
+        },
+        {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNVX-commonparent",
+          "text": " Each of <code>cmdBuf</code>, <code>dst</code>, <code>instanceData</code>, <code>scratch</code>, and <code>src</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
+    "vkCmdWriteAccelerationStructurePropertiesNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-queryType-02242",
+          "text": " <code>queryType</code> <strong class=\"purple\">must</strong> be VK_QUERY_TYPE_COMPACTED_SIZE_NVX"
+        },
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-cmdBuf-parameter",
+          "text": " <code>cmdBuf</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-accelerationStructure-parameter",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-queryType-parameter",
+          "text": " <code>queryType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkQueryType\">VkQueryType</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-queryPool-parameter",
+          "text": " <code>queryPool</code> <strong class=\"purple\">must</strong> be a valid <code>VkQueryPool</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, or compute operations"
+        },
+        {
+          "vuid": "VUID-vkCmdWriteAccelerationStructurePropertiesNVX-commonparent",
+          "text": " Each of <code>accelerationStructure</code>, <code>cmdBuf</code>, and <code>queryPool</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
+    "vkCmdCopyAccelerationStructureNVX": {
+      "(VK_NVX_raytracing)": [
+        {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-cmdBuf-parameter",
+          "text": " <code>cmdBuf</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-dst-parameter",
+          "text": " <code>dst</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-src-parameter",
+          "text": " <code>src</code> <strong class=\"purple\">must</strong> be a valid <code>VkAccelerationStructureNVX</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-mode-parameter",
+          "text": " <code>mode</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCopyAccelerationStructureModeNVX\">VkCopyAccelerationStructureModeNVX</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics, or compute operations"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNVX-commonparent",
+          "text": " Each of <code>cmdBuf</code>, <code>dst</code>, and <code>src</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
+        }
+      ]
+    },
     "vkEnumerateInstanceLayerProperties": {
       "core": [
         {
@@ -18570,6 +20206,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceMeshShaderFeaturesNV": {
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceDescriptorIndexingFeaturesEXT": {
       "(VK_EXT_descriptor_indexing)": [
         {
@@ -18610,6 +20254,62 @@
         }
       ]
     },
+    "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV": {
+      "(VK_NV_representative_fragment_test)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceExclusiveScissorFeaturesNV": {
+      "(VK_NV_scissor_exclusive)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceExclusiveScissorFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceCornerSampledImageFeaturesNV": {
+      "(VK_NV_corner_sampled_image)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceCornerSampledImageFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceComputeShaderDerivativesFeaturesNV": {
+      "(VK_NV_compute_shader_derivatives)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceComputeShaderDerivativesFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV": {
+      "(VK_NV_fragment_shader_barycentric)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceShaderImageFootprintFeaturesNV": {
+      "(VK_NV_shader_image_footprint)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShaderImageFootprintFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceShadingRateImageFeaturesNV": {
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShadingRateImageFeaturesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV</code>"
+        }
+      ]
+    },
     "VkPhysicalDevicePushDescriptorPropertiesKHR": {
       "(VK_KHR_push_descriptor)": [
         {
@@ -18714,6 +20414,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceMeshShaderPropertiesNV": {
+      "(VK_NV_mesh_shader)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceMeshShaderPropertiesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceDescriptorIndexingPropertiesEXT": {
       "(VK_EXT_descriptor_indexing)": [
         {
@@ -18746,6 +20454,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceShadingRateImagePropertiesNV": {
+      "(VK_NV_shading_rate_image)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShadingRateImagePropertiesNV-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV</code>"
+        }
+      ]
+    },
     "vkGetPhysicalDeviceMultisamplePropertiesEXT": {
       "(VK_EXT_sample_locations)": [
         {
diff --git a/registry/vk.xml b/registry/vk.xml
index 9cd1c72..fb1eb50 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -147,7 +147,7 @@ server.
         <type category="define">// Vulkan 1.1 version number
 #define <name>VK_API_VERSION_1_1</name> <type>VK_MAKE_VERSION</type>(1, 1, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 84</type>
+#define <name>VK_HEADER_VERSION</name> 85</type>
 
         <type category="define">
 #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
@@ -247,6 +247,9 @@ server.
         <type requires="VkSubgroupFeatureFlagBits"        category="bitmask">typedef <type>VkFlags</type> <name>VkSubgroupFeatureFlags</name>;</type>
         <type requires="VkIndirectCommandsLayoutUsageFlagBitsNVX"  category="bitmask">typedef <type>VkFlags</type> <name>VkIndirectCommandsLayoutUsageFlagsNVX</name>;</type>
         <type requires="VkObjectEntryUsageFlagBitsNVX"             category="bitmask">typedef <type>VkFlags</type> <name>VkObjectEntryUsageFlagsNVX</name>;</type>
+        <type requires="VkGeometryFlagBitsNVX"            category="bitmask">typedef <type>VkFlags</type> <name>VkGeometryFlagsNVX</name>;</type>
+        <type requires="VkGeometryInstanceFlagBitsNVX"    category="bitmask">typedef <type>VkFlags</type> <name>VkGeometryInstanceFlagsNVX</name>;</type>
+        <type requires="VkBuildAccelerationStructureFlagBitsNVX" category="bitmask">typedef <type>VkFlags</type> <name>VkBuildAccelerationStructureFlagsNVX</name>;</type>
 
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorUpdateTemplateCreateFlags</name>;</type>
         <type                                             category="bitmask" name="VkDescriptorUpdateTemplateCreateFlagsKHR" alias="VkDescriptorUpdateTemplateCreateFlags"/>
@@ -341,6 +344,7 @@ server.
         <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkSamplerYcbcrConversion</name>)</type>
         <type category="handle" name="VkSamplerYcbcrConversionKHR"   alias="VkSamplerYcbcrConversion"/>
         <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkValidationCacheEXT</name>)</type>
+        <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkAccelerationStructureNVX</name>)</type>
 
             <comment>WSI extensions</comment>
         <type category="handle"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDisplayKHR</name>)</type>
@@ -458,6 +462,12 @@ server.
         <type name="VkShaderInfoTypeAMD" category="enum"/>
         <type name="VkQueueGlobalPriorityEXT" category="enum"/>
         <type name="VkConservativeRasterizationModeEXT" category="enum"/>
+        <type name="VkGeometryFlagBitsNVX" category="enum"/>
+        <type name="VkGeometryInstanceFlagBitsNVX" category="enum"/>
+        <type name="VkBuildAccelerationStructureFlagBitsNVX" category="enum"/>
+        <type name="VkCopyAccelerationStructureModeNVX" category="enum"/>
+        <type name="VkAccelerationStructureTypeNVX" category="enum"/>
+        <type name="VkGeometryTypeNVX" category="enum"/>
 
             <comment>WSI extensions</comment>
         <type name="VkColorSpaceKHR" category="enum"/>
@@ -513,8 +523,10 @@ server.
 
             <comment>Enumerated types in the header, but not used by the API</comment>
         <type name="VkVendorId" category="enum"/>
+        <type name="VkShadingRatePaletteEntryNV" category="enum"/>
+        <type name="VkCoarseSampleOrderTypeNV" category="enum"/>
 
-            <comment>The PFN_vk*Function types are used by VkAllocationCallbacks below</comment>
+        <comment>The PFN_vk*Function types are used by VkAllocationCallbacks below</comment>
         <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkInternalAllocationNotification</name>)(
     <type>void</type>*                                       pUserData,
     <type>size_t</type>                                      size,
@@ -1144,8 +1156,8 @@ server.
             <member optional="true"><type>VkPipelineCreateFlags</type>  <name>flags</name><comment>Pipeline creation flags</comment></member>
             <member><type>uint32_t</type>               <name>stageCount</name></member>
             <member len="stageCount">const <type>VkPipelineShaderStageCreateInfo</type>* <name>pStages</name><comment>One entry for each active shader stage</comment></member>
-            <member>const <type>VkPipelineVertexInputStateCreateInfo</type>* <name>pVertexInputState</name></member>
-            <member>const <type>VkPipelineInputAssemblyStateCreateInfo</type>* <name>pInputAssemblyState</name></member>
+            <member noautovalidity="true" optional="true">const <type>VkPipelineVertexInputStateCreateInfo</type>* <name>pVertexInputState</name></member>
+            <member noautovalidity="true" optional="true">const <type>VkPipelineInputAssemblyStateCreateInfo</type>* <name>pInputAssemblyState</name></member>
             <member noautovalidity="true" optional="true">const <type>VkPipelineTessellationStateCreateInfo</type>* <name>pTessellationState</name></member>
             <member noautovalidity="true" optional="true">const <type>VkPipelineViewportStateCreateInfo</type>* <name>pViewportState</name></member>
             <member>const <type>VkPipelineRasterizationStateCreateInfo</type>* <name>pRasterizationState</name></member>
@@ -2833,7 +2845,7 @@ server.
             <member><type>uint32_t</type>               <name>maxDescriptorSetInlineUniformBlocks</name></member>
             <member><type>uint32_t</type>               <name>maxDescriptorSetUpdateAfterBindInlineUniformBlocks</name></member>
         </type>
-        <type category="struct" name="VkWriteDescriptorSetInlineUniformBlockEXT">
+        <type category="struct" name="VkWriteDescriptorSetInlineUniformBlockEXT" structextends="VkWriteDescriptorSet">
             <member values="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*            <name>pNext</name></member>
             <member><type>uint32_t</type>               <name>dataSize</name></member>
@@ -3072,7 +3084,7 @@ server.
             <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*            <name>pNext</name></member>
             <member optional="true"><type>uint32_t</type>               <name>bindingCount</name></member>
-            <member len="bindingCount">const <type>VkDescriptorBindingFlagsEXT</type>* <name>pBindingFlags</name></member>
+            <member len="bindingCount" optional="true">const <type>VkDescriptorBindingFlagsEXT</type>* <name>pBindingFlags</name></member>
         </type>
         <type category="struct" name="VkDescriptorSetVariableDescriptorCountAllocateInfoEXT" structextends="VkDescriptorSetAllocateInfo">
             <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
@@ -3258,6 +3270,200 @@ server.
             <member noautovalidity="true"><type>void</type>*      <name>pNext</name></member>
             <member><type>VkBool32</type>                         <name>decodeModeSharedExponent</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"><type>VkStructureType</type><name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*    <name>pNext</name></member>
+            <member><type>VkBool32</type>                       <name>representativeFragmentTest</name></member>
+        </type>
+        <type category="struct" name="VkPipelineRepresentativeFragmentTestStateCreateInfoNV" structextends="VkGraphicsPipelineCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*    <name>pNext</name></member>
+            <member><type>VkBool32</type>       <name>representativeFragmentTestEnable</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceExclusiveScissorFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>
+            <member><type>VkBool32</type>                         <name>exclusiveScissor</name></member>
+        </type>
+        <type category="struct" name="VkPipelineViewportExclusiveScissorStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                                    <name>pNext</name></member>
+            <member optional="true"><type>uint32_t</type>                                       <name>exclusiveScissorCount</name></member>
+            <member len="exclusiveScissorCount" optional="true">const <type>VkRect2D</type>*    <name>pExclusiveScissors</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceCornerSampledImageFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                              <name>pNext</name></member>
+            <member><type>VkBool32</type>                           <name>cornerSampledImage</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceComputeShaderDerivativesFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>
+            <member><type>VkBool32</type>                         <name>computeDerivativeGroupQuads</name></member>
+            <member><type>VkBool32</type>                         <name>computeDerivativeGroupLinear</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>
+            <member><type>VkBool32</type>                         <name>fragmentShaderBarycentric</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceShaderImageFootprintFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                              <name>pNext</name></member>
+            <member><type>VkBool32</type>                           <name>imageFootprint</name></member>
+        </type>
+        <type category="struct" name="VkShadingRatePaletteNV">
+            <member><type>uint32_t</type>                                                               <name>shadingRatePaletteEntryCount</name></member>
+            <member len="shadingRatePaletteEntryCount">const <type>VkShadingRatePaletteEntryNV</type>*  <name>pShadingRatePaletteEntries</name></member>
+        </type>
+        <type category="struct" name="VkPipelineViewportShadingRateImageStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                                            <name>pNext</name></member>
+            <member><type>VkBool32</type>                                                               <name>shadingRateImageEnable</name></member>
+            <member optional="true"><type>uint32_t</type>                                                               <name>viewportCount</name></member>
+            <member len="viewportCount" optional="true">const <type>VkShadingRatePaletteNV</type>*      <name>pShadingRatePalettes</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceShadingRateImageFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                               <name>pNext</name></member>
+            <member><type>VkBool32</type>                            <name>shadingRateImage</name></member>
+            <member><type>VkBool32</type>                            <name>shadingRateCoarseSampleOrder</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceShadingRateImagePropertiesNV" structextends="VkPhysicalDeviceProperties" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                               <name>pNext</name></member>
+            <member><type>VkExtent2D</type>                          <name>shadingRateTexelSize</name></member>
+            <member><type>uint32_t</type>                            <name>shadingRatePaletteSize</name></member>
+            <member><type>uint32_t</type>                            <name>shadingRateMaxCoarseSamples</name></member>
+        </type>
+        <type category="struct" name="VkCoarseSampleLocationNV">
+            <member><type>uint32_t</type>                            <name>pixelX</name></member>
+            <member><type>uint32_t</type>                            <name>pixelY</name></member>
+            <member><type>uint32_t</type>                            <name>sample</name></member>
+        </type>
+        <type category="struct" name="VkCoarseSampleOrderCustomNV">
+            <member><type>VkShadingRatePaletteEntryNV</type>         <name>shadingRate</name></member>
+            <member><type>uint32_t</type>                            <name>sampleCount</name></member>
+            <member><type>uint32_t</type>                            <name>sampleLocationCount</name></member>
+            <member len="sampleLocationCount">const <type>VkCoarseSampleLocationNV</type>* <name>pSampleLocations</name></member>
+        </type>
+        <type category="struct" name="VkPipelineViewportCoarseSampleOrderStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                                            <name>pNext</name></member>
+            <member><type>VkCoarseSampleOrderTypeNV</type>                                              <name>sampleOrderType</name></member>
+            <member optional="true"><type>uint32_t</type>                                               <name>customSampleOrderCount</name></member>
+            <member len="customSampleOrderCount">const <type>VkCoarseSampleOrderCustomNV</type>*        <name>pCustomSampleOrders</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceMeshShaderFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                               <name>pNext</name></member>
+            <member><type>VkBool32</type>                            <name>taskShader</name></member>
+            <member><type>VkBool32</type>                            <name>meshShader</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceMeshShaderPropertiesNV" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                               <name>pNext</name></member>
+            <member><type>uint32_t</type>                            <name>maxDrawMeshTasksCount</name></member>
+            <member><type>uint32_t</type>                            <name>maxTaskWorkGroupInvocations</name></member>
+            <member><type>uint32_t</type>                            <name>maxTaskWorkGroupSize</name>[3]</member>
+            <member><type>uint32_t</type>                            <name>maxTaskTotalMemorySize</name></member>
+            <member><type>uint32_t</type>                            <name>maxTaskOutputCount</name></member>
+            <member><type>uint32_t</type>                            <name>maxMeshWorkGroupInvocations</name></member>
+            <member><type>uint32_t</type>                            <name>maxMeshWorkGroupSize</name>[3]</member>
+            <member><type>uint32_t</type>                            <name>maxMeshTotalMemorySize</name></member>
+            <member><type>uint32_t</type>                            <name>maxMeshOutputVertices</name></member>
+            <member><type>uint32_t</type>                            <name>maxMeshOutputPrimitives</name></member>
+            <member><type>uint32_t</type>                            <name>maxMeshMultiviewViewCount</name></member>
+            <member><type>uint32_t</type>                            <name>meshOutputPerVertexGranularity</name></member>
+            <member><type>uint32_t</type>                            <name>meshOutputPerPrimitiveGranularity</name></member>
+        </type>
+        <type category="struct" name="VkDrawMeshTasksIndirectCommandNV">
+            <member><type>uint32_t</type>               <name>taskCount</name></member>
+            <member><type>uint32_t</type>               <name>firstTask</name></member>
+        </type>
+        <type category="struct" name="VkRaytracingPipelineCreateInfoNVX">
+            <member values="VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*            <name>pNext</name></member>
+            <member optional="true"><type>VkPipelineCreateFlags</type>  <name>flags</name><comment>Pipeline creation flags</comment></member>
+            <member><type>uint32_t</type>               <name>stageCount</name></member>
+            <member len="stageCount">const <type>VkPipelineShaderStageCreateInfo</type>* <name>pStages</name><comment>One entry for each active shader stage</comment></member>
+            <member len="stageCount">const <type>uint32_t</type>* <name>pGroupNumbers</name><comment>One entry for each stage used as the query index and for grouping</comment></member>
+            <member><type>uint32_t</type>               <name>maxRecursionDepth</name></member>
+            <member><type>VkPipelineLayout</type>       <name>layout</name><comment>Interface layout of the pipeline</comment></member>
+            <member noautovalidity="true" optional="true"><type>VkPipeline</type>      <name>basePipelineHandle</name><comment>If 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</comment></member>
+            <member><type>int32_t</type>                <name>basePipelineIndex</name><comment>If 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</comment></member>
+        </type>
+        <type category="struct" name="VkGeometryTrianglesNVX">
+            <member values="VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                <name>pNext</name></member>
+            <member optional="true"><type>VkBuffer</type>   <name>vertexData</name></member>
+            <member><type>VkDeviceSize</type>               <name>vertexOffset</name></member>
+            <member><type>uint32_t</type>                   <name>vertexCount</name></member>
+            <member><type>VkDeviceSize</type>               <name>vertexStride</name></member>
+            <member><type>VkFormat</type>   <name>vertexFormat</name><comment>VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R16G16B16_SFLOAT, or VK_FORMAT_R16G16B16A16_SFLOAT</comment></member>
+            <member optional="true"><type>VkBuffer</type>   <name>indexData</name></member>
+            <member><type>VkDeviceSize</type>               <name>indexOffset</name></member>
+            <member><type>uint32_t</type>                   <name>indexCount</name></member>
+            <member><type>VkIndexType</type> <name>indexType</name></member>
+            <member optional="true"><type>VkBuffer</type>   <name>transformData</name><comment>Optional reference to array of floats representing a 3x4 row major affine transformation matrix.</comment></member>
+            <member><type>VkDeviceSize</type>               <name>transformOffset</name></member>
+        </type>
+        <type category="struct" name="VkGeometryAABBNVX">
+            <member values="VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                <name>pNext</name></member>
+            <member optional="true"><type>VkBuffer</type>   <name>aabbData</name></member>
+            <member><type>uint32_t</type>                   <name>numAABBs</name></member>
+            <member><type>uint32_t</type>                   <name>stride</name><comment>Stride in bytes between AABBs</comment></member>
+            <member><type>VkDeviceSize</type>               <name>offset</name><comment>Offset in bytes of the first AABB in aabbData</comment></member>
+        </type>
+        <type category="struct" name="VkGeometryDataNVX">
+            <member><type>VkGeometryTrianglesNVX</type>                  <name>triangles</name></member>
+            <member><type>VkGeometryAABBNVX</type>                       <name>aabbs</name></member>
+        </type>
+        <type category="struct" name="VkGeometryNVX">
+            <member values="VK_STRUCTURE_TYPE_GEOMETRY_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                        <name>pNext</name></member>
+            <member><type>VkGeometryTypeNVX</type>                  <name>geometryType</name></member>
+            <member><type>VkGeometryDataNVX</type>                  <name>geometry</name></member>
+            <member optional="true"><type>VkGeometryFlagsNVX</type> <name>flags</name></member>
+        </type>
+        <type category="struct" name="VkAccelerationStructureCreateInfoNVX">
+            <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                            <name>pNext</name></member>
+            <member><type>VkAccelerationStructureTypeNVX</type>         <name>type</name></member>
+            <member optional="true"><type>VkBuildAccelerationStructureFlagsNVX</type><name>flags</name></member>
+            <member><type>VkDeviceSize</type>                           <name>compactedSize</name></member>
+            <member optional="true"><type>uint32_t</type>               <name>instanceCount</name></member>
+            <member optional="true"><type>uint32_t</type>               <name>geometryCount</name></member>
+            <member len="geometryCount">const <type>VkGeometryNVX</type>* <name>pGeometries</name></member>
+        </type>
+        <type category="struct" name="VkBindAccelerationStructureMemoryInfoNVX">
+            <member values="VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>
+            <member><type>VkAccelerationStructureNVX</type>        <name>accelerationStructure</name></member>
+            <member><type>VkDeviceMemory</type>                   <name>memory</name></member>
+            <member><type>VkDeviceSize</type>                     <name>memoryOffset</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>deviceIndexCount</name></member>
+            <member len="deviceIndexCount">const <type>uint32_t</type>*  <name>pDeviceIndices</name></member>
+        </type>
+        <type category="struct" name="VkDescriptorAccelerationStructureInfoNVX" structextends="VkWriteDescriptorSet">
+            <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>
+            <member><type>uint32_t</type>                         <name>accelerationStructureCount</name></member>
+            <member len="accelerationStructureCount">const <type>VkAccelerationStructureNVX</type>* <name>pAccelerationStructures</name></member>
+        </type>
+        <type category="struct" name="VkAccelerationStructureMemoryRequirementsInfoNVX">
+            <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                                          <name>pNext</name></member>
+            <member><type>VkAccelerationStructureNVX</type>                                            <name>accelerationStructure</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceRaytracingPropertiesNVX" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>
+            <member><type>uint32_t</type>                         <name>shaderHeaderSize</name></member>
+            <member><type>uint32_t</type>                         <name>maxRecursionDepth</name></member>
+            <member><type>uint32_t</type>                         <name>maxGeometryCount</name></member>
+        </type>
     </types>
 
     <comment>Vulkan enumerant (token) definitions</comment>
@@ -4346,6 +4552,55 @@ server.
     <enums name="VkConditionalRenderingFlagBitsEXT" type="bitmask">
         <enum bitpos="0"    name="VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT"/>
     </enums>
+    <enums name="VkShadingRatePaletteEntryNV" type="enum">
+        <enum value="0" name="VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV"/>
+        <enum value="1" name="VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV"/>
+        <enum value="2" name="VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV"/>
+        <enum value="3" name="VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV"/>
+        <enum value="4" name="VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV"/>
+        <enum value="5" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV"/>
+        <enum value="6" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV"/>
+        <enum value="7" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV"/>
+        <enum value="8" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV"/>
+        <enum value="9" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV"/>
+        <enum value="10" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV"/>
+        <enum value="11" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV"/>
+    </enums>
+    <enums name="VkCoarseSampleOrderTypeNV" type="enum">
+        <enum value="0" name="VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV"/>
+        <enum value="1" name="VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV"/>
+        <enum value="2" name="VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV"/>
+        <enum value="3" name="VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV"/>
+    </enums>
+    <enums name="VkGeometryInstanceFlagBitsNVX" type="bitmask">
+        <enum bitpos="0" name="VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NVX"/>
+        <enum bitpos="1" name="VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_FLIP_WINDING_BIT_NVX"/>
+        <enum bitpos="2" name="VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NVX"/>
+        <enum bitpos="3" name="VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NVX"/>
+    </enums>
+    <enums name="VkGeometryFlagBitsNVX" type="bitmask">
+        <enum bitpos="0" name="VK_GEOMETRY_OPAQUE_BIT_NVX"/>
+        <enum bitpos="1" name="VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX"/>
+    </enums>
+    <enums name="VkBuildAccelerationStructureFlagBitsNVX" type="bitmask">
+        <enum bitpos="0" name="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NVX"/>
+        <enum bitpos="1" name="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NVX"/>
+        <enum bitpos="2" name="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NVX"/>
+        <enum bitpos="3" name="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NVX"/>
+        <enum bitpos="4" name="VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NVX"/>
+    </enums>
+    <enums name="VkCopyAccelerationStructureModeNVX" type="enum">
+        <enum value="0" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX"/>
+        <enum value="1" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX"/>
+    </enums>
+    <enums name="VkAccelerationStructureTypeNVX" type="enum">
+        <enum value="0" name="VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX"/>
+        <enum value="1" name="VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX"/>
+    </enums>
+    <enums name="VkGeometryTypeNVX" type="enum">
+        <enum value="0" name="VK_GEOMETRY_TYPE_TRIANGLES_NVX"/>
+        <enum value="1" name="VK_GEOMETRY_TYPE_AABBS_NVX"/>
+    </enums>
 
     <commands comment="Vulkan command definitions">
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_LAYER_NOT_PRESENT,VK_ERROR_EXTENSION_NOT_PRESENT,VK_ERROR_INCOMPATIBLE_DRIVER">
@@ -6313,6 +6568,164 @@ server.
             <param optional="false,true"><type>uint32_t</type>* <name>pCheckpointDataCount</name></param>
             <param optional="true" len="pCheckpointDataCount"><type>VkCheckpointDataNV</type>* <name>pCheckpointData</name></param>
         </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetExclusiveScissorNV</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>firstExclusiveScissor</name></param>
+            <param><type>uint32_t</type> <name>exclusiveScissorCount</name></param>
+            <param len="exclusiveScissorCount">const <type>VkRect2D</type>* <name>pExclusiveScissors</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdBindShadingRateImageNV</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkImageView</type> <name>imageView</name></param>
+            <param><type>VkImageLayout</type> <name>imageLayout</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetViewportShadingRatePaletteNV</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>firstViewport</name></param>
+            <param><type>uint32_t</type> <name>viewportCount</name></param>
+            <param len="viewportCount">const <type>VkShadingRatePaletteNV</type>* <name>pShadingRatePalettes</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetCoarseSampleOrderNV</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkCoarseSampleOrderTypeNV</type> <name>sampleOrderType</name></param>
+            <param optional="true"><type>uint32_t</type> <name>customSampleOrderCount</name></param>
+            <param len="customSampleOrderCount">const <type>VkCoarseSampleOrderCustomNV</type>* <name>pCustomSampleOrders</name></param>
+        </command>
+        <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary" pipeline="graphics">
+            <proto><type>void</type> <name>vkCmdDrawMeshTasksNV</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>taskCount</name></param>
+            <param><type>uint32_t</type> <name>firstTask</name></param>
+        </command>
+        <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary" pipeline="graphics">
+            <proto><type>void</type> <name>vkCmdDrawMeshTasksIndirectNV</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkBuffer</type> <name>buffer</name></param>
+            <param><type>VkDeviceSize</type> <name>offset</name></param>
+            <param><type>uint32_t</type> <name>drawCount</name></param>
+            <param><type>uint32_t</type> <name>stride</name></param>
+        </command>
+        <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary" pipeline="graphics">
+            <proto><type>void</type> <name>vkCmdDrawMeshTasksIndirectCountNV</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkBuffer</type> <name>buffer</name></param>
+            <param><type>VkDeviceSize</type> <name>offset</name></param>
+            <param><type>VkBuffer</type> <name>countBuffer</name></param>
+            <param><type>VkDeviceSize</type> <name>countBufferOffset</name></param>
+            <param><type>uint32_t</type> <name>maxDrawCount</name></param>
+            <param><type>uint32_t</type> <name>stride</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkCompileDeferredNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkPipeline</type> <name>pipeline</name></param>
+            <param><type>uint32_t</type> <name>shader</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
+            <proto><type>VkResult</type> <name>vkCreateAccelerationStructureNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkAccelerationStructureCreateInfoNVX</type>* <name>pCreateInfo</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+            <param><type>VkAccelerationStructureNVX</type>* <name>pAccelerationStructure</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkDestroyAccelerationStructureNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkAccelerationStructureNVX</type> <name>accelerationStructure</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkGetAccelerationStructureMemoryRequirementsNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkAccelerationStructureMemoryRequirementsInfoNVX</type>* <name>pInfo</name></param>
+            <param><type>VkMemoryRequirements2KHR</type>* <name>pMemoryRequirements</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkGetAccelerationStructureScratchMemoryRequirementsNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkAccelerationStructureMemoryRequirementsInfoNVX</type>* <name>pInfo</name></param>
+            <param><type>VkMemoryRequirements2KHR</type>* <name>pMemoryRequirements</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkBindAccelerationStructureMemoryNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>uint32_t</type> <name>bindInfoCount</name></param>
+            <param len="bindInfoCount">const <type>VkBindAccelerationStructureMemoryInfoNVX</type>* <name>pBindInfos</name></param>
+        </command>
+        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdCopyAccelerationStructureNVX</name></proto>
+            <param><type>VkCommandBuffer</type> <name>cmdBuf</name></param>
+            <param><type>VkAccelerationStructureNVX</type> <name>dst</name></param>
+            <param><type>VkAccelerationStructureNVX</type> <name>src</name></param>
+            <param><type>VkCopyAccelerationStructureModeNVX</type> <name>mode</name></param>
+        </command>
+        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdWriteAccelerationStructurePropertiesNVX</name></proto>
+            <param><type>VkCommandBuffer</type> <name>cmdBuf</name></param>
+            <param><type>VkAccelerationStructureNVX</type> <name>accelerationStructure</name></param>
+            <param><type>VkQueryType</type> <name>queryType</name></param>
+            <param><type>VkQueryPool</type> <name>queryPool</name></param>
+            <param><type>uint32_t</type> <name>query</name></param>
+        </command>
+        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdBuildAccelerationStructureNVX</name></proto>
+            <param><type>VkCommandBuffer</type> <name>cmdBuf</name></param>
+            <param><type>VkAccelerationStructureTypeNVX</type> <name>type</name></param>
+            <param optional="true"><type>uint32_t</type> <name>instanceCount</name></param>
+            <param optional="true"><type>VkBuffer</type> <name>instanceData</name></param>
+            <param><type>VkDeviceSize</type> <name>instanceOffset</name></param>
+            <param optional="true"><type>uint32_t</type> <name>geometryCount</name></param>
+            <param len="geometryCount">const <type>VkGeometryNVX</type>* <name>pGeometries</name></param>
+            <param optional="true"><type>VkBuildAccelerationStructureFlagsNVX</type> <name>flags</name></param>
+            <param><type>VkBool32</type> <name>update</name></param>
+            <param><type>VkAccelerationStructureNVX</type> <name>dst</name></param>
+            <param optional="true"><type>VkAccelerationStructureNVX</type> <name>src</name></param>
+            <param><type>VkBuffer</type> <name>scratch</name></param>
+            <param><type>VkDeviceSize</type> <name>scratchOffset</name></param>
+        </command>
+        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdTraceRaysNVX</name></proto>
+            <param><type>VkCommandBuffer</type> <name>cmdBuf</name></param>
+            <param><type>VkBuffer</type> <name>raygenShaderBindingTableBuffer</name></param>
+            <param><type>VkDeviceSize</type> <name>raygenShaderBindingOffset</name></param>
+            <param><type>VkBuffer</type> <name>missShaderBindingTableBuffer</name></param>
+            <param><type>VkDeviceSize</type> <name>missShaderBindingOffset</name></param>
+            <param><type>VkDeviceSize</type> <name>missShaderBindingStride</name></param>
+            <param><type>VkBuffer</type> <name>hitShaderBindingTableBuffer</name></param>
+            <param><type>VkDeviceSize</type> <name>hitShaderBindingOffset</name></param>
+            <param><type>VkDeviceSize</type> <name>hitShaderBindingStride</name></param>
+            <param><type>uint32_t</type> <name>width</name></param>
+            <param><type>uint32_t</type> <name>height</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetRaytracingShaderHandlesNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkPipeline</type> <name>pipeline</name></param>
+            <param><type>uint32_t</type> <name>firstGroup</name></param>
+            <param><type>uint32_t</type> <name>groupCount</name></param>
+            <param><type>size_t</type> <name>dataSize</name></param>
+            <param len="dataSize"><type>void</type>* <name>pData</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetAccelerationStructureHandleNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkAccelerationStructureNVX</type> <name>accelerationStructure</name></param>
+            <param><type>size_t</type> <name>dataSize</name></param>
+            <param len="dataSize"><type>void</type>* <name>pData</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_SHADER_NV">
+            <proto><type>VkResult</type> <name>vkCreateRaytracingPipelinesNVX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param optional="true"><type>VkPipelineCache</type> <name>pipelineCache</name></param>
+            <param><type>uint32_t</type> <name>createInfoCount</name></param>
+            <param len="createInfoCount">const <type>VkRaytracingPipelineCreateInfoNVX</type>* <name>pCreateInfos</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+            <param len="createInfoCount"><type>VkPipeline</type>* <name>pPipelines</name></param>
+        </command>
     </commands>
 
     <feature api="vulkan" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@@ -6625,6 +7038,7 @@ server.
             <type name="VkBufferMemoryRequirementsInfo2"/>
             <type name="VkImageMemoryRequirementsInfo2"/>
             <type name="VkImageSparseMemoryRequirementsInfo2"/>
+            <type name="VkMemoryRequirements2KHR"/>
             <type name="VkMemoryRequirements2"/>
             <type name="VkSparseImageMemoryRequirements2"/>
             <command name="vkGetImageMemoryRequirements2"/>
@@ -7320,11 +7734,13 @@ server.
                 <enum value="&quot;VK_GOOGLE_extension_50&quot;"                name="VK_GOOGLE_EXTENSION_50_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NVX_extension_51" number="51" author="NVX" contact="James Jones @cubanismo" supported="disabled">
+        <extension name="VK_NV_corner_sampled_image" number="51" author="NV" type="device" requires="VK_KHR_get_physical_device_properties2" contact="Daniel Koch @dgkoch" supported="vulkan">
             <require>
-                <enum value="0"                                                 name="VK_NVX_EXTENSION_51_SPEC_VERSION"/>
-                <enum value="&quot;VK_NVX_extension_51&quot;"                   name="VK_NVX_EXTENSION_51_EXTENSION_NAME"/>
-                <enum bitpos="13" extends="VkImageCreateFlagBits"               name="VK_IMAGE_CREATE_RESERVED_13_BIT_NV"/>
+                <enum value="2"                                                 name="VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_corner_sampled_image&quot;"            name="VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME"/>
+                <enum bitpos="13" extends="VkImageCreateFlagBits"               name="VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"/>
+                <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"/>
+                <type name="VkPhysicalDeviceCornerSampledImageFeaturesNV"/>
             </require>
         </extension>
         <extension name="VK_NVX_extension_52" number="52" author="NVX" contact="James Jones @cubanismo" supported="disabled">
@@ -8760,36 +9176,108 @@ server.
                 <enum value="&quot;VK_NV_extension_164&quot;"               name="VK_EXT_EXTENSION_164_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_165" number="165" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
-            <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_165_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_165&quot;"               name="VK_EXT_EXTENSION_165_EXTENSION_NAME"/>
-                <enum bitpos="23" extends="VkAccessFlagBits"                name="VK_ACCESS_RESERVED_23_BIT_NV"/>
-                <enum bitpos="8"  extends="VkImageUsageFlagBits"            name="VK_IMAGE_USAGE_RESERVED_8_BIT_NV"/>
-                <enum bitpos="22" extends="VkPipelineStageFlagBits"         name="VK_PIPELINE_STAGE_RESERVED_22_BIT_NV"/>
-            </require>
-        </extension>
-        <extension name="VK_NV_extension_166" number="166" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
-            <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_166_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_166&quot;"               name="VK_EXT_EXTENSION_166_EXTENSION_NAME"/>
-                <enum bitpos="8" extends="VkShaderStageFlagBits"            name="VK_SHADER_STAGE_RESERVED_8_BIT_NV"/>
-                <enum bitpos="9" extends="VkShaderStageFlagBits"            name="VK_SHADER_STAGE_RESERVED_9_BIT_NV"/>
-                <enum bitpos="10" extends="VkShaderStageFlagBits"           name="VK_SHADER_STAGE_RESERVED_10_BIT_NV"/>
-                <enum bitpos="11" extends="VkShaderStageFlagBits"           name="VK_SHADER_STAGE_RESERVED_11_BIT_NV"/>
-                <enum bitpos="12" extends="VkShaderStageFlagBits"           name="VK_SHADER_STAGE_RESERVED_12_BIT_NV"/>
-                <enum bitpos="13" extends="VkShaderStageFlagBits"           name="VK_SHADER_STAGE_RESERVED_13_BIT_NV"/>
-                <enum bitpos="21" extends="VkPipelineStageFlagBits"         name="VK_PIPELINE_STAGE_RESERVED_21_BIT_NV"/>
-                <enum bitpos="10" extends="VkBufferUsageFlagBits"           name="VK_BUFFER_USAGE_RESERVED_10_BIT_NV"/>
-                <enum bitpos="21" extends="VkAccessFlagBits"                name="VK_ACCESS_RESERVED_21_BIT_NV"/>
-                <enum bitpos="22" extends="VkAccessFlagBits"                name="VK_ACCESS_RESERVED_22_BIT_NV"/>
-                <enum bitpos="5" extends="VkPipelineCreateFlagBits"         name="VK_PIPELINE_CREATE_RESERVED_5_BIT_NV"/>
-            </require>
-        </extension>
-        <extension name="VK_NV_extension_167" number="167" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
-            <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_167_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_167&quot;"               name="VK_EXT_EXTENSION_167_EXTENSION_NAME"/>
+        <extension name="VK_NV_shading_rate_image" number="165" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
+            <require>
+                <enum value="3"                                             name="VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_shading_rate_image&quot;"          name="VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"/>
+                <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"/>
+                <enum offset="2" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"/>
+                <enum offset="3" extends="VkImageLayout"                    name="VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV"/>
+                <enum offset="4" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV"/>
+                <enum bitpos="23" extends="VkAccessFlagBits"                name="VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV"/>
+                <enum bitpos="8" extends="VkImageUsageFlagBits"             name="VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV"/>
+                <enum bitpos="22" extends="VkPipelineStageFlagBits"         name="VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV"/>
+                <enum offset="5" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"/>
+                <enum offset="6" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV"/>
+                <type name="VkShadingRatePaletteEntryNV"/>
+                <type name="VkShadingRatePaletteNV"/>
+                <type name="VkPipelineViewportShadingRateImageStateCreateInfoNV"/>
+                <type name="VkPhysicalDeviceShadingRateImageFeaturesNV"/>
+                <type name="VkPhysicalDeviceShadingRateImagePropertiesNV"/>
+                <type name="VkCoarseSampleLocationNV"/>
+                <type name="VkCoarseSampleOrderCustomNV"/>
+                <type name="VkPipelineViewportCoarseSampleOrderStateCreateInfoNV"/>
+                <type name="VkCoarseSampleOrderTypeNV"/>
+                <command name="vkCmdBindShadingRateImageNV"/>
+                <command name="vkCmdSetViewportShadingRatePaletteNV"/>
+                <command name="vkCmdSetCoarseSampleOrderNV"/>
+            </require>
+        </extension>
+        <extension name="VK_NVX_raytracing" number="166" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_get_memory_requirements2" author="NVX" contact="Eric Werness @ewerness" supported="vulkan">
+            <require>
+                <enum value="1"                                          name="VK_NVX_RAYTRACING_SPEC_VERSION"/>
+                <enum value="&quot;VK_NVX_raytracing&quot;"               name="VK_NVX_RAYTRACING_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX"/>
+                <enum offset="1" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX"/>
+                <enum offset="2" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX"/>
+                <enum offset="3" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_GEOMETRY_NVX"/>
+                <enum offset="4" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX"/>
+                <enum offset="5" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX"/>
+                <enum offset="6" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX"/>
+                <enum offset="7" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX"/>
+                <enum offset="8" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX"/>
+                <enum offset="9" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX"/>
+                <enum offset="10" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX"/>
+                <enum bitpos="8" extends="VkShaderStageFlagBits"         name="VK_SHADER_STAGE_RAYGEN_BIT_NVX"/>
+                <enum bitpos="9" extends="VkShaderStageFlagBits"         name="VK_SHADER_STAGE_ANY_HIT_BIT_NVX"/>
+                <enum bitpos="10" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_CLOSEST_HIT_BIT_NVX"/>
+                <enum bitpos="11" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_MISS_BIT_NVX"/>
+                <enum bitpos="12" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_INTERSECTION_BIT_NVX"/>
+                <enum bitpos="13" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_CALLABLE_BIT_NVX"/>
+                <enum bitpos="21" extends="VkPipelineStageFlagBits"      name="VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX"/>
+                <enum bitpos="10" extends="VkBufferUsageFlagBits"        name="VK_BUFFER_USAGE_RAYTRACING_BIT_NVX"/>
+                <enum offset="0" extends="VkPipelineBindPoint"           name="VK_PIPELINE_BIND_POINT_RAYTRACING_NVX"/>
+                <enum offset="0" extends="VkDescriptorType"              name="VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX"/>
+                <enum bitpos="21" extends="VkAccessFlagBits"             name="VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NVX"/>
+                <enum bitpos="22" extends="VkAccessFlagBits"             name="VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NVX"/>
+                <enum offset="0" extends="VkQueryType"                   name="VK_QUERY_TYPE_COMPACTED_SIZE_NVX"/>
+                <enum bitpos="5" extends="VkPipelineCreateFlagBits"      name="VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX"/>
+                <enum offset="0" extends="VkObjectType"                  name="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX"/>
+                <enum offset="0" extends="VkDebugReportObjectTypeEXT"    name="VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT"/>
+                <type name="VkRaytracingPipelineCreateInfoNVX"/>
+                <type name="VkGeometryTrianglesNVX"/>
+                <type name="VkGeometryAABBNVX"/>
+                <type name="VkGeometryDataNVX"/>
+                <type name="VkGeometryNVX"/>
+                <type name="VkGeometryFlagsNVX"/>
+                <type name="VkGeometryInstanceFlagsNVX"/>
+                <type name="VkGeometryFlagBitsNVX"/>
+                <type name="VkGeometryInstanceFlagBitsNVX"/>
+                <type name="VkAccelerationStructureCreateInfoNVX"/>
+                <type name="VkAccelerationStructureNVX"/>
+                <type name="VkBuildAccelerationStructureFlagBitsNVX"/>
+                <type name="VkBuildAccelerationStructureFlagsNVX"/>
+                <type name="VkCopyAccelerationStructureModeNVX"/>
+                <type name="VkGeometryTypeNVX"/>
+                <type name="VkBindAccelerationStructureMemoryInfoNVX"/>
+                <type name="VkDescriptorAccelerationStructureInfoNVX"/>
+                <type name="VkAccelerationStructureMemoryRequirementsInfoNVX"/>
+                <type name="VkPhysicalDeviceRaytracingPropertiesNVX"/>
+                <type name="VkMemoryRequirements2KHR"/>
+                <command name="vkCreateAccelerationStructureNVX"/>
+                <command name="vkDestroyAccelerationStructureNVX"/>
+                <command name="vkGetAccelerationStructureMemoryRequirementsNVX"/>
+                <command name="vkGetAccelerationStructureScratchMemoryRequirementsNVX"/>
+                <command name="vkBindAccelerationStructureMemoryNVX"/>
+                <command name="vkCmdBuildAccelerationStructureNVX"/>
+                <command name="vkCmdCopyAccelerationStructureNVX"/>
+                <command name="vkCmdTraceRaysNVX"/>
+                <command name="vkCreateRaytracingPipelinesNVX"/>
+                <command name="vkGetRaytracingShaderHandlesNVX"/>
+                <command name="vkGetAccelerationStructureHandleNVX"/>
+                <command name="vkCmdWriteAccelerationStructurePropertiesNVX"/>
+                <command name="vkCompileDeferredNVX"/>
+            </require>
+        </extension>
+        <extension name="VK_NV_representative_fragment_test" number="167" type="device" author="NV" contact="Kedarnath Thangudu @kthangudu" supported="vulkan">
+            <require>
+                <enum value="1"                                             name="VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_representative_fragment_test&quot;" name="VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"/>
+                <enum offset="1" extends="VkStructureType"  name="VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"/>
+                <type name="VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV"/>
+                <type name="VkPipelineRepresentativeFragmentTestStateCreateInfoNV"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_168" number="168" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
@@ -9031,38 +9519,58 @@ server.
                 <enum value="&quot;VK_KHR_extension_201&quot;"          name="VK_KHR_EXTENSION_201_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_202" number="202" author="NV" contact="Pat Brown @nvpbrown" supported="disabled">
+        <extension name="VK_NV_compute_shader_derivatives" number="202" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_202_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_202&quot;"           name="VK_NV_EXTENSION_202_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_compute_shader_derivatives&quot;" name="VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"/>
+                <type name="VkPhysicalDeviceComputeShaderDerivativesFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_203" number="203" author="NV" contact="Pat Brown @nvpbrown" supported="disabled">
+        <extension name="VK_NV_mesh_shader" number="203" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_203_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_203&quot;"           name="VK_NV_EXTENSION_203_EXTENSION_NAME"/>
-                <enum bitpos="6" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_RESERVED_6_BIT_NV"/>
-                <enum bitpos="7" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_RESERVED_7_BIT_NV"/>
-                <enum bitpos="19" extends="VkPipelineStageFlagBits"     name="VK_PIPELINE_STAGE_RESERVED_19_BIT_NV"/>
-                <enum bitpos="20" extends="VkPipelineStageFlagBits"     name="VK_PIPELINE_STAGE_RESERVED_20_BIT_NV"/>
+                <enum value="1"                                         name="VK_NV_MESH_SHADER_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_mesh_shader&quot;"             name="VK_NV_MESH_SHADER_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"/>
+                <enum bitpos="6" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_TASK_BIT_NV"/>
+                <enum bitpos="7" extends="VkShaderStageFlagBits"        name="VK_SHADER_STAGE_MESH_BIT_NV"/>
+                <enum bitpos="19" extends="VkPipelineStageFlagBits"     name="VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV"/>
+                <enum bitpos="20" extends="VkPipelineStageFlagBits"     name="VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV"/>
+                <command name="vkCmdDrawMeshTasksNV"/>
+                <command name="vkCmdDrawMeshTasksIndirectNV"/>
+                <command name="vkCmdDrawMeshTasksIndirectCountNV"/>
+                <type name="VkPhysicalDeviceMeshShaderFeaturesNV"/>
+                <type name="VkPhysicalDeviceMeshShaderPropertiesNV"/>
+                <type name="VkDrawMeshTasksIndirectCommandNV"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_204" number="204" author="NV" contact="Pat Brown @nvpbrown" supported="disabled">
+        <extension name="VK_NV_fragment_shader_barycentric" number="204" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_204_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_204&quot;"           name="VK_NV_EXTENSION_204_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_fragment_shader_barycentric&quot;" name="VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"/>
+                <type name="VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_205" number="205" author="NV" contact="Pat Brown @nvpbrown" supported="disabled">
+        <extension name="VK_NV_shader_image_footprint" number="205" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_205_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_205&quot;"           name="VK_NV_EXTENSION_205_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_shader_image_footprint&quot;"  name="VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"/>
+                <type name="VkPhysicalDeviceShaderImageFootprintFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_206" number="206" author="NV" contact="Pat Brown @nvpbrown" supported="disabled">
+        <extension name="VK_NV_scissor_exclusive" number="206" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_206_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_206&quot;"           name="VK_NV_EXTENSION_206_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_scissor_exclusive&quot;"       name="VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"/>
+                <enum offset="1" extends="VkDynamicState" name="VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV"/>
+                <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"/>
+                <type name="VkPipelineViewportExclusiveScissorStateCreateInfoNV"/>
+                <type name="VkPhysicalDeviceExclusiveScissorFeaturesNV"/>
+                <command name="vkCmdSetExclusiveScissorNV"/>
             </require>
         </extension>
         <extension name="VK_NV_device_diagnostic_checkpoints" type="device" number="207" requires="VK_KHR_get_physical_device_properties2" author="NVIDIA" contact="Nuno Subtil @nsubtil" supported="vulkan">