From 8f9db1bad6cb804ebed18b5a19d52a952a3d1e77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= <asuessenbach@nvidia.com>
Date: Mon, 24 Feb 2025 18:02:40 +0100
Subject: [PATCH] Minor cleanup work (#2090)

---
 .clang-format_16                              |   3 +-
 .clang-format_17                              |   3 +-
 .clang-format_18                              |   3 +-
 .../05_InitSwapchain/05_InitSwapchain.cpp     |   2 +-
 RAII_Samples/CopyBlitImage/CopyBlitImage.cpp  |  13 +-
 .../DebugUtilsObjectName.cpp                  |   3 +-
 .../PhysicalDeviceGroups.cpp                  |  13 +-
 RAII_Samples/RayTracing/RayTracing.cpp        |  22 +-
 .../SecondaryCommandBuffer.cpp                |  13 +-
 .../SurfaceCapabilities.cpp                   |  11 +-
 RAII_Samples/utils/utils.hpp                  |   2 +-
 VideoHppGenerator.cpp                         |  10 +
 VulkanHppGenerator.cpp                        | 152 +--
 VulkanHppGenerator.hpp                        |   2 +
 samples/05_InitSwapchain/05_InitSwapchain.cpp |   2 +-
 samples/RayTracing/RayTracing.cpp             |   8 +-
 samples/SharedHandles/SharedHandles.cpp       |   2 +-
 samples/utils/utils.cpp                       |   2 +-
 tests/Hash/Hash.cpp                           |   2 +-
 vulkan/vulkan_structs.hpp                     |  20 +
 vulkan/vulkan_video.hpp                       | 880 ++++++++++++++++++
 21 files changed, 1034 insertions(+), 134 deletions(-)

diff --git a/.clang-format_16 b/.clang-format_16
index 23ed4e2..fd8215a 100644
--- a/.clang-format_16
+++ b/.clang-format_16
@@ -75,8 +75,7 @@ InsertNewlineAtEOF : true
 IntegerLiteralSeparator :
     Binary : 4
     Decimal : 0
-    Hex : 2
-    HexMinDigits : 6
+    Hex : 0
 KeepEmptyLinesAtTheStartOfBlocks : false
 LambdaBodyIndentation : Signature
 MaxEmptyLinesToKeep : 1
diff --git a/.clang-format_17 b/.clang-format_17
index 2b8175f..308a4a0 100644
--- a/.clang-format_17
+++ b/.clang-format_17
@@ -81,8 +81,7 @@ InsertNewlineAtEOF : true
 IntegerLiteralSeparator :
     Binary : 4
     Decimal : 0
-    Hex : 2
-    HexMinDigits : 6
+    Hex : 0
 KeepEmptyLinesAtTheStartOfBlocks : false
 LambdaBodyIndentation : Signature
 MaxEmptyLinesToKeep : 1
diff --git a/.clang-format_18 b/.clang-format_18
index 2976ed0..bfed90d 100644
--- a/.clang-format_18
+++ b/.clang-format_18
@@ -84,8 +84,7 @@ InsertNewlineAtEOF : true
 IntegerLiteralSeparator :
     Binary : 4
     Decimal : 0
-    Hex : 2
-    HexMinDigits : 6
+    Hex : 0
 KeepEmptyLinesAtTheStartOfBlocks : false
 LambdaBodyIndentation : Signature
 MaxEmptyLinesToKeep : 1
diff --git a/RAII_Samples/05_InitSwapchain/05_InitSwapchain.cpp b/RAII_Samples/05_InitSwapchain/05_InitSwapchain.cpp
index 15a0bb7..9408dda 100644
--- a/RAII_Samples/05_InitSwapchain/05_InitSwapchain.cpp
+++ b/RAII_Samples/05_InitSwapchain/05_InitSwapchain.cpp
@@ -42,7 +42,7 @@ int main( int /*argc*/, char ** /*argv*/ )
     uint32_t           height = 64;
     vk::su::WindowData window = vk::su::createWindow( AppName, { width, height } );
     VkSurfaceKHR       _surface;
-    glfwCreateWindowSurface( static_cast<VkInstance>( *instance ), window.handle, nullptr, &_surface );
+    glfwCreateWindowSurface( *instance, window.handle, nullptr, &_surface );
     vk::raii::SurfaceKHR surface( instance, _surface );
 
     // determine a queueFamilyIndex that suports present
diff --git a/RAII_Samples/CopyBlitImage/CopyBlitImage.cpp b/RAII_Samples/CopyBlitImage/CopyBlitImage.cpp
index 2816e71..8c2b7e1 100644
--- a/RAII_Samples/CopyBlitImage/CopyBlitImage.cpp
+++ b/RAII_Samples/CopyBlitImage/CopyBlitImage.cpp
@@ -78,11 +78,8 @@ int main( int /*argc*/, char ** /*argv*/ )
     assert( imageIndex < swapChainData.images.size() );
 
     commandBuffer.begin( vk::CommandBufferBeginInfo() );
-    vk::raii::su::setImageLayout( commandBuffer,
-                                  static_cast<vk::Image>( swapChainData.images[imageIndex] ),
-                                  swapChainData.colorFormat,
-                                  vk::ImageLayout::eUndefined,
-                                  vk::ImageLayout::eTransferDstOptimal );
+    vk::raii::su::setImageLayout(
+      commandBuffer, swapChainData.images[imageIndex], swapChainData.colorFormat, vk::ImageLayout::eUndefined, vk::ImageLayout::eTransferDstOptimal );
 
     // in order to get a clean desctruction sequence, instantiate the DeviceMemory for the image first
     vk::raii::DeviceMemory deviceMemory( nullptr );
@@ -150,7 +147,7 @@ int main( int /*argc*/, char ** /*argv*/ )
     // Intend to blit from this image, set the layout accordingly
     vk::raii::su::setImageLayout( commandBuffer, blitSourceImage, swapChainData.colorFormat, vk::ImageLayout::eGeneral, vk::ImageLayout::eTransferSrcOptimal );
 
-    vk::Image blitDestinationImage = static_cast<vk::Image>( swapChainData.images[imageIndex] );
+    vk::Image blitDestinationImage = swapChainData.images[imageIndex];
 
     // Do a 32x32 blit to all of the dst image - should get big squares
     vk::ImageSubresourceLayers imageSubresourceLayers( vk::ImageAspectFlagBits::eColor, 0, 0, 1 );
@@ -203,9 +200,9 @@ int main( int /*argc*/, char ** /*argv*/ )
     result = presentQueue.presentKHR( presentInfoKHR );
     switch ( result )
     {
-      case vk::Result::eSuccess: break;
+      case vk::Result::eSuccess      : break;
       case vk::Result::eSuboptimalKHR: std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n"; break;
-      default: assert( false );  // an unexpected result is returned !
+      default                        : assert( false );  // an unexpected result is returned !
     }
     std::this_thread::sleep_for( std::chrono::milliseconds( 1000 ) );
 
diff --git a/RAII_Samples/DebugUtilsObjectName/DebugUtilsObjectName.cpp b/RAII_Samples/DebugUtilsObjectName/DebugUtilsObjectName.cpp
index 76c9d69..23a9516 100644
--- a/RAII_Samples/DebugUtilsObjectName/DebugUtilsObjectName.cpp
+++ b/RAII_Samples/DebugUtilsObjectName/DebugUtilsObjectName.cpp
@@ -47,8 +47,7 @@ int main( int /*argc*/, char ** /*argv*/ )
 
     /* VULKAN_KEY_START */
 
-    vk::DebugUtilsObjectNameInfoEXT debugUtilsObjectNameInfo(
-      vk::ObjectType::eImage, NON_DISPATCHABLE_HANDLE_TO_UINT64_CAST( VkImage, static_cast<vk ::Image>( image ) ), "Image name" );
+    vk::DebugUtilsObjectNameInfoEXT debugUtilsObjectNameInfo( vk::ObjectType::eImage, NON_DISPATCHABLE_HANDLE_TO_UINT64_CAST( VkImage, *image ), "Image name" );
     device.setDebugUtilsObjectNameEXT( debugUtilsObjectNameInfo );
 
     /* VULKAN_KEY_END */
diff --git a/RAII_Samples/PhysicalDeviceGroups/PhysicalDeviceGroups.cpp b/RAII_Samples/PhysicalDeviceGroups/PhysicalDeviceGroups.cpp
index f56e0e3..62e2818 100644
--- a/RAII_Samples/PhysicalDeviceGroups/PhysicalDeviceGroups.cpp
+++ b/RAII_Samples/PhysicalDeviceGroups/PhysicalDeviceGroups.cpp
@@ -40,22 +40,19 @@ int main( int /*argc*/, char ** /*argv*/ )
     for ( size_t i = 0; i < groupProperties.size(); i++ )
     {
       std::cout << "Group Properties " << i << " :\n";
-      std::cout << "\t"
-                << "physicalDeviceCount = " << groupProperties[i].physicalDeviceCount << "\n";
-      std::cout << "\t"
-                << "physicalDevices:\n";
+      std::cout << "\t" << "physicalDeviceCount = " << groupProperties[i].physicalDeviceCount << "\n";
+      std::cout << "\t" << "physicalDevices:\n";
       for ( size_t j = 0; j < groupProperties[i].physicalDeviceCount; j++ )
       {
-        vk::raii::PhysicalDevice physicalDevice( instance, static_cast<VkPhysicalDevice>( groupProperties[i].physicalDevices[j] ) );
+        vk::raii::PhysicalDevice physicalDevice( instance, groupProperties[i].physicalDevices[j] );
         std::cout << "\t\t" << j << " : " << physicalDevice.getProperties().deviceName << "\n";
       }
-      std::cout << "\t"
-                << "subsetAllocation    = " << !!groupProperties[i].subsetAllocation << "\n";
+      std::cout << "\t" << "subsetAllocation    = " << !!groupProperties[i].subsetAllocation << "\n";
       std::cout << "\n";
 
       if ( 1 < groupProperties[i].physicalDeviceCount )
       {
-        vk::raii::PhysicalDevice physicalDevice( instance, static_cast<VkPhysicalDevice>( groupProperties[i].physicalDevices[0] ) );
+        vk::raii::PhysicalDevice physicalDevice( instance, groupProperties[i].physicalDevices[0] );
 
         // get the QueueFamilyProperties of the first PhysicalDevice
         std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevice.getQueueFamilyProperties();
diff --git a/RAII_Samples/RayTracing/RayTracing.cpp b/RAII_Samples/RayTracing/RayTracing.cpp
index f488476..59e8182 100644
--- a/RAII_Samples/RayTracing/RayTracing.cpp
+++ b/RAII_Samples/RayTracing/RayTracing.cpp
@@ -581,7 +581,7 @@ static void keyCallback( GLFWwindow * window, int key, int /*scancode*/, int act
     switch ( key )
     {
       case GLFW_KEY_ESCAPE:
-      case 'Q': glfwSetWindowShouldClose( window, 1 ); break;
+      case 'Q'            : glfwSetWindowShouldClose( window, 1 ); break;
       case 'R':
         {
           AppInfo * appInfo        = reinterpret_cast<AppInfo *>( glfwGetWindowUserPointer( window ) );
@@ -725,7 +725,7 @@ int main( int /*argc*/, char ** /*argv*/ )
 
     // Create Window Surface (using glfw)
     VkSurfaceKHR glfwSurface;
-    VkResult     err = glfwCreateWindowSurface( static_cast<VkInstance>( *instance ), window, nullptr, &glfwSurface );
+    VkResult     err = glfwCreateWindowSurface( *instance, window, nullptr, &glfwSurface );
     check_vk_result( err );
     vk::raii::SurfaceKHR surface( instance, glfwSurface );
 
@@ -1188,11 +1188,8 @@ int main( int /*argc*/, char ** /*argv*/ )
         vk::WriteDescriptorSet  writeDescriptorSet( *rayTracingDescriptorSets[backBufferIndex], 1, 0, bindings[1].descriptorType, imageInfo );
         device.updateDescriptorSets( writeDescriptorSet, nullptr );
 
-        vk::raii::su::setImageLayout( commandBuffer,
-                                      static_cast<vk::Image>( swapChainData.images[backBufferIndex] ),
-                                      surfaceFormat.format,
-                                      vk::ImageLayout::eUndefined,
-                                      vk::ImageLayout::eGeneral );
+        vk::raii::su::setImageLayout(
+          commandBuffer, swapChainData.images[backBufferIndex], surfaceFormat.format, vk::ImageLayout::eUndefined, vk::ImageLayout::eGeneral );
 
         commandBuffer.bindPipeline( vk::PipelineBindPoint::eRayTracingNV, *rayTracingPipeline );
 
@@ -1214,11 +1211,8 @@ int main( int /*argc*/, char ** /*argv*/ )
                                    windowExtent.height,
                                    1 );
 
-        vk::raii::su::setImageLayout( commandBuffer,
-                                      static_cast<vk::Image>( swapChainData.images[backBufferIndex] ),
-                                      surfaceFormat.format,
-                                      vk::ImageLayout::eGeneral,
-                                      vk::ImageLayout::ePresentSrcKHR );
+        vk::raii::su::setImageLayout(
+          commandBuffer, swapChainData.images[backBufferIndex], surfaceFormat.format, vk::ImageLayout::eGeneral, vk::ImageLayout::ePresentSrcKHR );
       }
 
       // frame end
@@ -1236,9 +1230,9 @@ int main( int /*argc*/, char ** /*argv*/ )
       result = presentQueue.presentKHR( presentInfoKHR );
       switch ( result )
       {
-        case vk::Result::eSuccess: break;
+        case vk::Result::eSuccess      : break;
         case vk::Result::eSuboptimalKHR: std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n"; break;
-        default: assert( false );  // an unexpected result is returned !
+        default                        : assert( false );  // an unexpected result is returned !
       }
       frameIndex = ( frameIndex + 1 ) % IMGUI_VK_QUEUED_FRAMES;
 
diff --git a/RAII_Samples/SecondaryCommandBuffer/SecondaryCommandBuffer.cpp b/RAII_Samples/SecondaryCommandBuffer/SecondaryCommandBuffer.cpp
index 1f2c6d5..5664ff0 100644
--- a/RAII_Samples/SecondaryCommandBuffer/SecondaryCommandBuffer.cpp
+++ b/RAII_Samples/SecondaryCommandBuffer/SecondaryCommandBuffer.cpp
@@ -147,11 +147,8 @@ int main( int /*argc*/, char ** /*argv*/ )
     assert( result == vk::Result::eSuccess );
     assert( imageIndex < swapChainData.images.size() );
 
-    vk::raii::su::setImageLayout( commandBuffer,
-                                  static_cast<vk::Image>( swapChainData.images[imageIndex] ),
-                                  swapChainData.colorFormat,
-                                  vk::ImageLayout::eUndefined,
-                                  vk::ImageLayout::eColorAttachmentOptimal );
+    vk::raii::su::setImageLayout(
+      commandBuffer, swapChainData.images[imageIndex], swapChainData.colorFormat, vk::ImageLayout::eUndefined, vk::ImageLayout::eColorAttachmentOptimal );
 
     const vk::DeviceSize offset = 0;
     vk::Viewport         viewport( 0.0f, 0.0f, 200.0f, 200.0f, 0.0f, 1.0f );
@@ -198,7 +195,7 @@ int main( int /*argc*/, char ** /*argv*/ )
                                               vk::ImageLayout::ePresentSrcKHR,
                                               VK_QUEUE_FAMILY_IGNORED,
                                               VK_QUEUE_FAMILY_IGNORED,
-                                              static_cast<vk::Image>( swapChainData.images[imageIndex] ),
+                                              swapChainData.images[imageIndex],
                                               imageSubresourceRange );
     commandBuffer.pipelineBarrier(
       vk::PipelineStageFlagBits::eColorAttachmentOutput, vk::PipelineStageFlagBits::eBottomOfPipe, vk::DependencyFlags(), nullptr, nullptr, prePresentBarrier );
@@ -216,9 +213,9 @@ int main( int /*argc*/, char ** /*argv*/ )
     result = presentQueue.presentKHR( vk::PresentInfoKHR( {}, *swapChainData.swapChain, imageIndex, {} ) );
     switch ( result )
     {
-      case vk::Result::eSuccess: break;
+      case vk::Result::eSuccess      : break;
       case vk::Result::eSuboptimalKHR: std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n"; break;
-      default: assert( false );  // an unexpected result is returned !
+      default                        : assert( false );  // an unexpected result is returned !
     }
     std::this_thread::sleep_for( std::chrono::milliseconds( 1000 ) );
 
diff --git a/RAII_Samples/SurfaceCapabilities/SurfaceCapabilities.cpp b/RAII_Samples/SurfaceCapabilities/SurfaceCapabilities.cpp
index 86fa85b..b05abaf 100644
--- a/RAII_Samples/SurfaceCapabilities/SurfaceCapabilities.cpp
+++ b/RAII_Samples/SurfaceCapabilities/SurfaceCapabilities.cpp
@@ -84,12 +84,11 @@ int main( int /*argc*/, char ** /*argv*/ )
       std::cout << "PhysicalDevice " << i << "\n";
       if ( supportsGetSurfaceCapabilities2 )
       {
-        auto surfaceCapabilities2 =
-          physicalDevices[i]
-            .getSurfaceCapabilities2KHR<vk::SurfaceCapabilities2KHR,
-                                        vk::DisplayNativeHdrSurfaceCapabilitiesAMD,
-                                        vk::SharedPresentSurfaceCapabilitiesKHR,
-                                        vk::SurfaceProtectedCapabilitiesKHR>( { static_cast<vk::SurfaceKHR>( surfaceData.surface ) } );
+        auto surfaceCapabilities2 = physicalDevices[i]
+                                      .getSurfaceCapabilities2KHR<vk::SurfaceCapabilities2KHR,
+                                                                  vk::DisplayNativeHdrSurfaceCapabilitiesAMD,
+                                                                  vk::SharedPresentSurfaceCapabilitiesKHR,
+                                                                  vk::SurfaceProtectedCapabilitiesKHR>( { *surfaceData.surface } );
 
         vk::SurfaceCapabilitiesKHR const & surfaceCapabilities = surfaceCapabilities2.get<vk::SurfaceCapabilities2KHR>().surfaceCapabilities;
         cout( surfaceCapabilities );
diff --git a/RAII_Samples/utils/utils.hpp b/RAII_Samples/utils/utils.hpp
index 0d8bbc3..06943c9 100644
--- a/RAII_Samples/utils/utils.hpp
+++ b/RAII_Samples/utils/utils.hpp
@@ -315,7 +315,7 @@ namespace vk
           : extent( extent_ ), window( vk::su::createWindow( windowName, extent ) )
         {
           VkSurfaceKHR _surface;
-          VkResult     err = glfwCreateWindowSurface( static_cast<VkInstance>( *instance ), window.handle, nullptr, &_surface );
+          VkResult     err = glfwCreateWindowSurface( *instance, window.handle, nullptr, &_surface );
           if ( err != VK_SUCCESS )
             throw std::runtime_error( "Failed to create window!" );
           surface = vk::raii::SurfaceKHR( instance, _surface );
diff --git a/VideoHppGenerator.cpp b/VideoHppGenerator.cpp
index b27786f..9d3399b 100644
--- a/VideoHppGenerator.cpp
+++ b/VideoHppGenerator.cpp
@@ -269,6 +269,16 @@ std::string VideoHppGenerator::generateStruct( std::pair<std::string, StructureD
     {
       return *reinterpret_cast<StdVideo${structureType}*>( this );
     }
+
+    operator StdVideo${structureType} const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const StdVideo${structureType}*>( this );
+    }
+
+    operator StdVideo${structureType} *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<StdVideo${structureType}*>( this );
+    }
 ${compareOperators}
     public:
 ${members}
diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 7043590..d44b33c 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -1083,80 +1083,88 @@ void VulkanHppGenerator::checkRequireCorrectness( std::vector<RequireData> const
 {
   for ( auto const & require : requireData )
   {
-    std::vector<std::string> dependencies = tokenize( require.depends, "," );
-    for ( auto const & depends : dependencies )
-    {
-      size_t separatorPos = depends.find( "::" );
-      if ( separatorPos == std::string::npos )
-      {
-        checkForError( isFeature( depends ) || isExtension( depends ),
-                       require.xmlLine,
-                       section + " <" + name + "> depends on unknown extension or feature <" + depends + ">" );
-      }
-      else
-      {
-        std::string structure = depends.substr( 0, separatorPos );
-        std::string member    = depends.substr( separatorPos + 2 );
-        auto        structIt  = m_structs.find( structure );
-        checkForError( structIt != m_structs.end(), require.xmlLine, section + " <" + name + "> requires member of an unknown struct <" + structure + ">" );
-        checkForError( std::ranges::find_if( structIt->second.members, [&member]( auto const & md ) { return md.name == member; } ) !=
-                         structIt->second.members.end(),
-                       require.xmlLine,
-                       section + " <" + name + "> requires unknown member <" + member + "> as part of the struct <" + structure + ">" );
-      }
-    }
+    checkRequireDependenciesCorrectness( require, section, name );
+    checkRequireTypesCorrectness( require );
+  }
+}
 
-    for ( auto const & type : require.types )
+void VulkanHppGenerator::checkRequireDependenciesCorrectness( RequireData const & require, std::string const & section, std::string const & name ) const
+{
+  std::vector<std::string> dependencies = tokenize( require.depends, "," );
+  for ( auto const & depends : dependencies )
+  {
+    size_t separatorPos = depends.find( "::" );
+    if ( separatorPos == std::string::npos )
     {
-      auto typeIt = m_types.find( type.name );
-      assert( typeIt != m_types.end() );
-      // every required type should be listed in the corresponding map
-      switch ( typeIt->second.category )
-      {
-        case TypeCategory::Bitmask:
-          checkForError( findByNameOrAlias( m_bitmasks, type.name ) != m_bitmasks.end(),
-                         typeIt->second.xmlLine,
-                         "required bitmask type <" + type.name + "> is not listed as bitmask" );
-          break;
-        case TypeCategory::BaseType:
-          checkForError( m_baseTypes.contains( type.name ), typeIt->second.xmlLine, "required base type <" + type.name + "> is not listed as a base type" );
-          break;
-        case TypeCategory::Constant:
-          checkForError( m_constants.contains( type.name ), typeIt->second.xmlLine, "required constant <" + type.name + "> is not listed as a constant" );
-          break;
-        case TypeCategory::Define:
-          checkForError( m_defines.contains( type.name ), typeIt->second.xmlLine, "required define <" + type.name + "> is not listed as a define" );
-          break;
-        case TypeCategory::Enum:
-          checkForError( findByNameOrAlias( m_enums, type.name ) != m_enums.end(),
-                         typeIt->second.xmlLine,
-                         "required enum type <" + type.name + "> is not listed as an enum" );
-          break;
-        case TypeCategory::ExternalType:
-          checkForError(
-            m_externalTypes.contains( type.name ), typeIt->second.xmlLine, "required external type <" + type.name + "> is not listed as an external type" );
-          break;
-        case TypeCategory::FuncPointer:
-          checkForError(
-            m_funcPointers.contains( type.name ), typeIt->second.xmlLine, "required funcpointer <" + type.name + "> is not listed as a funcpointer" );
-          break;
-        case TypeCategory::Handle:
-          checkForError( findByNameOrAlias( m_handles, type.name ) != m_handles.end(),
-                         typeIt->second.xmlLine,
-                         "required handle type <" + type.name + "> is not listed as a handle" );
-          break;
-        case TypeCategory::Include:
-          checkForError( m_includes.contains( type.name ), typeIt->second.xmlLine, "required include <" + type.name + "> is not listed as an include" );
-          break;
-        case TypeCategory::Struct:
-        case TypeCategory::Union:
-          checkForError( findByNameOrAlias( m_structs, type.name ) != m_structs.end(),
-                         typeIt->second.xmlLine,
-                         "required struct type <" + type.name + "> is not listed as a struct" );
-          break;
-        case TypeCategory::Unknown: break;
-        default                   : assert( false ); break;
-      }
+      checkForError( isFeature( depends ) || isExtension( depends ),
+                     require.xmlLine,
+                     section + " <" + name + "> depends on unknown extension or feature <" + depends + ">" );
+    }
+    else
+    {
+      std::string structure = depends.substr( 0, separatorPos );
+      std::string member    = depends.substr( separatorPos + 2 );
+      auto        structIt  = m_structs.find( structure );
+      checkForError( structIt != m_structs.end(), require.xmlLine, section + " <" + name + "> requires member of an unknown struct <" + structure + ">" );
+      checkForError( std::ranges::find_if( structIt->second.members, [&member]( auto const & md ) { return md.name == member; } ) !=
+                       structIt->second.members.end(),
+                     require.xmlLine,
+                     section + " <" + name + "> requires unknown member <" + member + "> as part of the struct <" + structure + ">" );
+    }
+  }
+}
+
+void VulkanHppGenerator::checkRequireTypesCorrectness( RequireData const & require ) const
+{
+  for ( auto const & type : require.types )
+  {
+    auto typeIt = m_types.find( type.name );
+    assert( typeIt != m_types.end() );
+    // every required type should be listed in the corresponding map
+    switch ( typeIt->second.category )
+    {
+      case TypeCategory::Bitmask:
+        checkForError( findByNameOrAlias( m_bitmasks, type.name ) != m_bitmasks.end(),
+                       typeIt->second.xmlLine,
+                       "required bitmask type <" + type.name + "> is not listed as bitmask" );
+        break;
+      case TypeCategory::BaseType:
+        checkForError( m_baseTypes.contains( type.name ), typeIt->second.xmlLine, "required base type <" + type.name + "> is not listed as a base type" );
+        break;
+      case TypeCategory::Constant:
+        checkForError( m_constants.contains( type.name ), typeIt->second.xmlLine, "required constant <" + type.name + "> is not listed as a constant" );
+        break;
+      case TypeCategory::Define:
+        checkForError( m_defines.contains( type.name ), typeIt->second.xmlLine, "required define <" + type.name + "> is not listed as a define" );
+        break;
+      case TypeCategory::Enum:
+        checkForError(
+          findByNameOrAlias( m_enums, type.name ) != m_enums.end(), typeIt->second.xmlLine, "required enum type <" + type.name + "> is not listed as an enum" );
+        break;
+      case TypeCategory::ExternalType:
+        checkForError(
+          m_externalTypes.contains( type.name ), typeIt->second.xmlLine, "required external type <" + type.name + "> is not listed as an external type" );
+        break;
+      case TypeCategory::FuncPointer:
+        checkForError(
+          m_funcPointers.contains( type.name ), typeIt->second.xmlLine, "required funcpointer <" + type.name + "> is not listed as a funcpointer" );
+        break;
+      case TypeCategory::Handle:
+        checkForError( findByNameOrAlias( m_handles, type.name ) != m_handles.end(),
+                       typeIt->second.xmlLine,
+                       "required handle type <" + type.name + "> is not listed as a handle" );
+        break;
+      case TypeCategory::Include:
+        checkForError( m_includes.contains( type.name ), typeIt->second.xmlLine, "required include <" + type.name + "> is not listed as an include" );
+        break;
+      case TypeCategory::Struct:
+      case TypeCategory::Union:
+        checkForError( findByNameOrAlias( m_structs, type.name ) != m_structs.end(),
+                       typeIt->second.xmlLine,
+                       "required struct type <" + type.name + "> is not listed as a struct" );
+        break;
+      case TypeCategory::Unknown: break;
+      default                   : assert( false ); break;
     }
   }
 }
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index cffe338..7a63ede 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -529,6 +529,8 @@ private:
   void        checkHandleCorrectness() const;
   void        checkRequireCorrectness() const;
   void        checkRequireCorrectness( std::vector<RequireData> const & requireData, std::string const & section, std::string const & name ) const;
+  void        checkRequireDependenciesCorrectness( RequireData const & require, std::string const & section, std::string const & name ) const;
+  void        checkRequireTypesCorrectness( RequireData const & require ) const;
   void        checkSpirVCapabilityCorrectness() const;
   void        checkStructCorrectness() const;
   void checkStructMemberCorrectness( std::string const & structureName, std::vector<MemberData> const & members, std::set<std::string> & sTypeValues ) const;
diff --git a/samples/05_InitSwapchain/05_InitSwapchain.cpp b/samples/05_InitSwapchain/05_InitSwapchain.cpp
index e763941..66ffb6d 100644
--- a/samples/05_InitSwapchain/05_InitSwapchain.cpp
+++ b/samples/05_InitSwapchain/05_InitSwapchain.cpp
@@ -44,7 +44,7 @@ int main( int /*argc*/, char ** /*argv*/ )
     vk::SurfaceKHR     surface;
     {
       VkSurfaceKHR _surface;
-      glfwCreateWindowSurface( static_cast<VkInstance>( instance ), window.handle, nullptr, &_surface );
+      glfwCreateWindowSurface( instance, window.handle, nullptr, &_surface );
       surface = vk::SurfaceKHR( _surface );
     }
 
diff --git a/samples/RayTracing/RayTracing.cpp b/samples/RayTracing/RayTracing.cpp
index 52c6bd8..7dd761b 100644
--- a/samples/RayTracing/RayTracing.cpp
+++ b/samples/RayTracing/RayTracing.cpp
@@ -595,7 +595,7 @@ static void keyCallback( GLFWwindow * window, int key, int /*scancode*/, int act
     switch ( key )
     {
       case GLFW_KEY_ESCAPE:
-      case 'Q': glfwSetWindowShouldClose( window, 1 ); break;
+      case 'Q'            : glfwSetWindowShouldClose( window, 1 ); break;
       case 'R':
         {
           AppInfo * appInfo        = reinterpret_cast<AppInfo *>( glfwGetWindowUserPointer( window ) );
@@ -725,7 +725,7 @@ int main( int /*argc*/, char ** /*argv*/ )
 
     // Create Window Surface (using glfw)
     vk::SurfaceKHR surface;
-    VkResult       err = glfwCreateWindowSurface( static_cast<VkInstance>( instance ), window, nullptr, reinterpret_cast<VkSurfaceKHR *>( &surface ) );
+    VkResult       err = glfwCreateWindowSurface( instance, window, nullptr, reinterpret_cast<VkSurfaceKHR *>( &surface ) );
     check_vk_result( err );
 
     std::pair<uint32_t, uint32_t> graphicsAndPresentQueueFamilyIndex = vk::su::findGraphicsAndPresentQueueFamilyIndex( physicalDevice, surface );
@@ -1225,9 +1225,9 @@ int main( int /*argc*/, char ** /*argv*/ )
         presentQueue.presentKHR( vk::PresentInfoKHR( perFrameData[frameIndex].renderCompleteSemaphore, swapChainData.swapChain, backBufferIndex ) );
       switch ( result )
       {
-        case vk::Result::eSuccess: break;
+        case vk::Result::eSuccess      : break;
         case vk::Result::eSuboptimalKHR: std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n"; break;
-        default: assert( false );  // an unexpected result is returned !
+        default                        : assert( false );  // an unexpected result is returned !
       }
       frameIndex = ( frameIndex + 1 ) % IMGUI_VK_QUEUED_FRAMES;
 
diff --git a/samples/SharedHandles/SharedHandles.cpp b/samples/SharedHandles/SharedHandles.cpp
index 6f777bc..aec2102 100644
--- a/samples/SharedHandles/SharedHandles.cpp
+++ b/samples/SharedHandles/SharedHandles.cpp
@@ -84,7 +84,7 @@ public:
   void createDeviceAndSwapChain( const vk::su::WindowData & window )
   {
     VkSurfaceKHR surface;
-    VkResult     err = glfwCreateWindowSurface( static_cast<VkInstance>( instance.get() ), window.handle, nullptr, &surface );
+    VkResult     err = glfwCreateWindowSurface( instance.get(), window.handle, nullptr, &surface );
     if ( err != VK_SUCCESS )
       throw std::runtime_error( "Failed to create window!" );
     vk::SharedSurfaceKHR sharedSurface{ surface, instance };
diff --git a/samples/utils/utils.cpp b/samples/utils/utils.cpp
index 681f192..4a6f4ca 100644
--- a/samples/utils/utils.cpp
+++ b/samples/utils/utils.cpp
@@ -780,7 +780,7 @@ namespace vk
       : extent( extent_ ), window( vk::su::createWindow( windowName, extent ) )
     {
       VkSurfaceKHR _surface;
-      VkResult     err = glfwCreateWindowSurface( static_cast<VkInstance>( instance ), window.handle, nullptr, &_surface );
+      VkResult     err = glfwCreateWindowSurface( instance, window.handle, nullptr, &_surface );
       if ( err != VK_SUCCESS )
         throw std::runtime_error( "Failed to create window!" );
       surface = vk::SurfaceKHR( _surface );
diff --git a/tests/Hash/Hash.cpp b/tests/Hash/Hash.cpp
index f3d058e..cd38528 100644
--- a/tests/Hash/Hash.cpp
+++ b/tests/Hash/Hash.cpp
@@ -41,7 +41,7 @@ int main( int /*argc*/, char ** /*argv*/ )
       vk::UniqueInstance  instance = vk::createInstanceUnique( vk::InstanceCreateInfo( {}, &appInfo ) );
 
       auto h1 = std::hash<vk::Instance>{}( *instance );
-      auto h2 = std::hash<VkInstance>{}( static_cast<VkInstance>( *instance ) );
+      auto h2 = std::hash<VkInstance>{}( *instance );
       assert( h1 == h2 );
 
       std::unordered_set<vk::Instance> uset;
diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp
index 4660b68..130f275 100644
--- a/vulkan/vulkan_structs.hpp
+++ b/vulkan/vulkan_structs.hpp
@@ -96195,6 +96195,16 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePresentMeteringFeaturesNV *>( this );
     }
 
+    operator VkPhysicalDevicePresentMeteringFeaturesNV const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>( this );
+    }
+
+    operator VkPhysicalDevicePresentMeteringFeaturesNV *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDevicePresentMeteringFeaturesNV *>( this );
+    }
+
 #  if defined( VULKAN_HPP_USE_REFLECT )
 #    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
@@ -133180,6 +133190,16 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSetPresentConfigNV *>( this );
     }
 
+    operator VkSetPresentConfigNV const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkSetPresentConfigNV *>( this );
+    }
+
+    operator VkSetPresentConfigNV *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkSetPresentConfigNV *>( this );
+    }
+
 #  if defined( VULKAN_HPP_USE_REFLECT )
 #    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
diff --git a/vulkan/vulkan_video.hpp b/vulkan/vulkan_video.hpp
index d9f87d5..28f1edd 100644
--- a/vulkan/vulkan_video.hpp
+++ b/vulkan/vulkan_video.hpp
@@ -454,6 +454,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264SpsVuiFlags *>( this );
       }
 
+      operator StdVideoH264SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264SpsVuiFlags *>( this );
+      }
+
+      operator StdVideoH264SpsVuiFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264SpsVuiFlags *>( this );
+      }
+
       bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) &&
@@ -499,6 +509,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264HrdParameters *>( this );
       }
 
+      operator StdVideoH264HrdParameters const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264HrdParameters *>( this );
+      }
+
+      operator StdVideoH264HrdParameters *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264HrdParameters *>( this );
+      }
+
       bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) &&
@@ -542,6 +562,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this );
       }
 
+      operator StdVideoH264SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264SequenceParameterSetVui *>( this );
+      }
+
+      operator StdVideoH264SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this );
+      }
+
       bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) &&
@@ -592,6 +622,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264SpsFlags *>( this );
       }
 
+      operator StdVideoH264SpsFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264SpsFlags *>( this );
+      }
+
+      operator StdVideoH264SpsFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264SpsFlags *>( this );
+      }
+
       bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) &&
@@ -643,6 +683,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264ScalingLists *>( this );
       }
 
+      operator StdVideoH264ScalingLists const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264ScalingLists *>( this );
+      }
+
+      operator StdVideoH264ScalingLists *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264ScalingLists *>( this );
+      }
+
       bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) &&
@@ -677,6 +727,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264SequenceParameterSet *>( this );
       }
 
+      operator StdVideoH264SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264SequenceParameterSet *>( this );
+      }
+
+      operator StdVideoH264SequenceParameterSet *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264SequenceParameterSet *>( this );
+      }
+
       bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) &&
@@ -743,6 +803,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264PpsFlags *>( this );
       }
 
+      operator StdVideoH264PpsFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264PpsFlags *>( this );
+      }
+
+      operator StdVideoH264PpsFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264PpsFlags *>( this );
+      }
+
       bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) &&
@@ -782,6 +852,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH264PictureParameterSet *>( this );
       }
 
+      operator StdVideoH264PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH264PictureParameterSet *>( this );
+      }
+
+      operator StdVideoH264PictureParameterSet *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH264PictureParameterSet *>( this );
+      }
+
       bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) &&
@@ -828,6 +908,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this );
       }
 
+      operator StdVideoDecodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH264PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this );
+      }
+
       bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) &&
@@ -863,6 +953,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this );
       }
 
+      operator StdVideoDecodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH264PictureInfo *>( this );
+      }
+
+      operator StdVideoDecodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this );
+      }
+
       bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) &&
@@ -900,6 +1000,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this );
       }
 
+      operator StdVideoDecodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH264ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this );
+      }
+
       bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) &&
@@ -932,6 +1042,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this );
       }
 
+      operator StdVideoDecodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH264ReferenceInfo *>( this );
+      }
+
+      operator StdVideoDecodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this );
+      }
+
       bool operator==( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( FrameNum == rhs.FrameNum ) && ( reserved == rhs.reserved ) && ( PicOrderCnt == rhs.PicOrderCnt );
@@ -965,6 +1085,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this );
       }
 
+      operator StdVideoEncodeH264WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264WeightTableFlags *>( this );
+      }
+
+      operator StdVideoEncodeH264WeightTableFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this );
+      }
+
       bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) &&
@@ -997,6 +1127,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264WeightTable *>( this );
       }
 
+      operator StdVideoEncodeH264WeightTable const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264WeightTable *>( this );
+      }
+
+      operator StdVideoEncodeH264WeightTable *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264WeightTable *>( this );
+      }
+
       bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) &&
@@ -1039,6 +1179,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this );
       }
 
+      operator StdVideoEncodeH264SliceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264SliceHeaderFlags *>( this );
+      }
+
+      operator StdVideoEncodeH264SliceHeaderFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this );
+      }
+
       bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) &&
@@ -1070,6 +1220,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this );
+      }
+
       bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) &&
@@ -1105,6 +1265,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this );
+      }
+
       bool operator==( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( reserved == rhs.reserved );
@@ -1134,6 +1304,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeH264ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeH264ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
+      }
+
       bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) &&
@@ -1165,6 +1345,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this );
       }
 
+      operator StdVideoEncodeH264RefListModEntry const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264RefListModEntry *>( this );
+      }
+
+      operator StdVideoEncodeH264RefListModEntry *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this );
+      }
+
       bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) &&
@@ -1197,6 +1387,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this );
       }
 
+      operator StdVideoEncodeH264RefPicMarkingEntry const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264RefPicMarkingEntry *>( this );
+      }
+
+      operator StdVideoEncodeH264RefPicMarkingEntry *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this );
+      }
+
       bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( memory_management_control_operation == rhs.memory_management_control_operation ) &&
@@ -1232,6 +1432,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this );
       }
 
+      operator StdVideoEncodeH264ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfo *>( this );
+      }
+
+      operator StdVideoEncodeH264ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this );
+      }
+
       bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) &&
@@ -1276,6 +1486,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this );
       }
 
+      operator StdVideoEncodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264PictureInfo *>( this );
+      }
+
+      operator StdVideoEncodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this );
+      }
+
       bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) &&
@@ -1316,6 +1536,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this );
       }
 
+      operator StdVideoEncodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264ReferenceInfo *>( this );
+      }
+
+      operator StdVideoEncodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this );
+      }
+
       bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) &&
@@ -1352,6 +1582,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this );
       }
 
+      operator StdVideoEncodeH264SliceHeader const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH264SliceHeader *>( this );
+      }
+
+      operator StdVideoEncodeH264SliceHeader *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this );
+      }
+
       bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) &&
@@ -1396,6 +1636,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265DecPicBufMgr *>( this );
       }
 
+      operator StdVideoH265DecPicBufMgr const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265DecPicBufMgr *>( this );
+      }
+
+      operator StdVideoH265DecPicBufMgr *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265DecPicBufMgr *>( this );
+      }
+
       bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) &&
@@ -1427,6 +1677,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this );
       }
 
+      operator StdVideoH265SubLayerHrdParameters const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265SubLayerHrdParameters *>( this );
+      }
+
+      operator StdVideoH265SubLayerHrdParameters *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this );
+      }
+
       bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) &&
@@ -1461,6 +1721,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265HrdFlags *>( this );
       }
 
+      operator StdVideoH265HrdFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265HrdFlags *>( this );
+      }
+
+      operator StdVideoH265HrdFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265HrdFlags *>( this );
+      }
+
       bool operator==( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) &&
@@ -1500,6 +1770,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265HrdParameters *>( this );
       }
 
+      operator StdVideoH265HrdParameters const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265HrdParameters *>( this );
+      }
+
+      operator StdVideoH265HrdParameters *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265HrdParameters *>( this );
+      }
+
       bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) &&
@@ -1550,6 +1830,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265VpsFlags *>( this );
       }
 
+      operator StdVideoH265VpsFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265VpsFlags *>( this );
+      }
+
+      operator StdVideoH265VpsFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265VpsFlags *>( this );
+      }
+
       bool operator==( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( vps_temporal_id_nesting_flag == rhs.vps_temporal_id_nesting_flag ) &&
@@ -1584,6 +1874,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this );
       }
 
+      operator StdVideoH265ProfileTierLevelFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265ProfileTierLevelFlags *>( this );
+      }
+
+      operator StdVideoH265ProfileTierLevelFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this );
+      }
+
       bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) &&
@@ -1619,6 +1919,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265ProfileTierLevel *>( this );
       }
 
+      operator StdVideoH265ProfileTierLevel const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265ProfileTierLevel *>( this );
+      }
+
+      operator StdVideoH265ProfileTierLevel *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265ProfileTierLevel *>( this );
+      }
+
       bool operator==( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( general_profile_idc == rhs.general_profile_idc ) && ( general_level_idc == rhs.general_level_idc );
@@ -1650,6 +1960,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265VideoParameterSet *>( this );
       }
 
+      operator StdVideoH265VideoParameterSet const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265VideoParameterSet *>( this );
+      }
+
+      operator StdVideoH265VideoParameterSet *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265VideoParameterSet *>( this );
+      }
+
       bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) &&
@@ -1693,6 +2013,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265ScalingLists *>( this );
       }
 
+      operator StdVideoH265ScalingLists const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265ScalingLists *>( this );
+      }
+
+      operator StdVideoH265ScalingLists *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265ScalingLists *>( this );
+      }
+
       bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) &&
@@ -1732,6 +2062,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265SpsVuiFlags *>( this );
       }
 
+      operator StdVideoH265SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265SpsVuiFlags *>( this );
+      }
+
+      operator StdVideoH265SpsVuiFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265SpsVuiFlags *>( this );
+      }
+
       bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) &&
@@ -1788,6 +2128,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this );
       }
 
+      operator StdVideoH265SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265SequenceParameterSetVui *>( this );
+      }
+
+      operator StdVideoH265SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this );
+      }
+
       bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) &&
@@ -1854,6 +2204,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this );
       }
 
+      operator StdVideoH265PredictorPaletteEntries const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265PredictorPaletteEntries *>( this );
+      }
+
+      operator StdVideoH265PredictorPaletteEntries *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this );
+      }
+
       bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries );
@@ -1884,6 +2244,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265SpsFlags *>( this );
       }
 
+      operator StdVideoH265SpsFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265SpsFlags *>( this );
+      }
+
+      operator StdVideoH265SpsFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265SpsFlags *>( this );
+      }
+
       bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) &&
@@ -1963,6 +2333,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this );
       }
 
+      operator StdVideoH265ShortTermRefPicSetFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265ShortTermRefPicSetFlags *>( this );
+      }
+
+      operator StdVideoH265ShortTermRefPicSetFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this );
+      }
+
       bool operator==( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( inter_ref_pic_set_prediction_flag == rhs.inter_ref_pic_set_prediction_flag ) && ( delta_rps_sign == rhs.delta_rps_sign );
@@ -1992,6 +2372,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this );
       }
 
+      operator StdVideoH265ShortTermRefPicSet const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265ShortTermRefPicSet *>( this );
+      }
+
+      operator StdVideoH265ShortTermRefPicSet *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this );
+      }
+
       bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) &&
@@ -2038,6 +2428,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this );
       }
 
+      operator StdVideoH265LongTermRefPicsSps const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265LongTermRefPicsSps *>( this );
+      }
+
+      operator StdVideoH265LongTermRefPicsSps *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this );
+      }
+
       bool operator==( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( used_by_curr_pic_lt_sps_flag == rhs.used_by_curr_pic_lt_sps_flag ) && ( lt_ref_pic_poc_lsb_sps == rhs.lt_ref_pic_poc_lsb_sps );
@@ -2067,6 +2467,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265SequenceParameterSet *>( this );
       }
 
+      operator StdVideoH265SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265SequenceParameterSet *>( this );
+      }
+
+      operator StdVideoH265SequenceParameterSet *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265SequenceParameterSet *>( this );
+      }
+
       bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) &&
@@ -2158,6 +2568,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265PpsFlags *>( this );
       }
 
+      operator StdVideoH265PpsFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265PpsFlags *>( this );
+      }
+
+      operator StdVideoH265PpsFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265PpsFlags *>( this );
+      }
+
       bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) &&
@@ -2239,6 +2659,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoH265PictureParameterSet *>( this );
       }
 
+      operator StdVideoH265PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoH265PictureParameterSet *>( this );
+      }
+
+      operator StdVideoH265PictureParameterSet *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoH265PictureParameterSet *>( this );
+      }
+
       bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) &&
@@ -2323,6 +2753,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this );
       }
 
+      operator StdVideoDecodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH265PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this );
+      }
+
       bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) &&
@@ -2355,6 +2795,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this );
       }
 
+      operator StdVideoDecodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH265PictureInfo *>( this );
+      }
+
+      operator StdVideoDecodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this );
+      }
+
       bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) &&
@@ -2398,6 +2848,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this );
       }
 
+      operator StdVideoDecodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH265ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this );
+      }
+
       bool operator==( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference );
@@ -2427,6 +2887,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this );
       }
 
+      operator StdVideoDecodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeH265ReferenceInfo *>( this );
+      }
+
+      operator StdVideoDecodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this );
+      }
+
       bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal );
@@ -2458,6 +2928,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this );
       }
 
+      operator StdVideoEncodeH265WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265WeightTableFlags *>( this );
+      }
+
+      operator StdVideoEncodeH265WeightTableFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this );
+      }
+
       bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) &&
@@ -2490,6 +2970,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265WeightTable *>( this );
       }
 
+      operator StdVideoEncodeH265WeightTable const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265WeightTable *>( this );
+      }
+
+      operator StdVideoEncodeH265WeightTable *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265WeightTable *>( this );
+      }
+
       bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) &&
@@ -2533,6 +3023,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
       }
 
+      operator StdVideoEncodeH265SliceSegmentHeaderFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
+      }
+
+      operator StdVideoEncodeH265SliceSegmentHeaderFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
+      }
+
       bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) &&
@@ -2581,6 +3081,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this );
       }
 
+      operator StdVideoEncodeH265SliceSegmentHeader const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeader *>( this );
+      }
+
+      operator StdVideoEncodeH265SliceSegmentHeader *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this );
+      }
+
       bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) &&
@@ -2629,6 +3139,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeH265ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeH265ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
+      }
+
       bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) &&
@@ -2660,6 +3180,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this );
       }
 
+      operator StdVideoEncodeH265ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfo *>( this );
+      }
+
+      operator StdVideoEncodeH265ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this );
+      }
+
       bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) &&
@@ -2696,6 +3226,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this );
+      }
+
       bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) &&
@@ -2738,6 +3278,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this );
       }
 
+      operator StdVideoEncodeH265LongTermRefPics const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this );
+      }
+
+      operator StdVideoEncodeH265LongTermRefPics *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this );
+      }
+
       bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( num_long_term_sps == rhs.num_long_term_sps ) && ( num_long_term_pics == rhs.num_long_term_pics ) && ( lt_idx_sps == rhs.lt_idx_sps ) &&
@@ -2774,6 +3324,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this );
       }
 
+      operator StdVideoEncodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265PictureInfo *>( this );
+      }
+
+      operator StdVideoEncodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this );
+      }
+
       bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) &&
@@ -2817,6 +3377,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this );
+      }
+
       bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) &&
@@ -2848,6 +3418,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this );
       }
 
+      operator StdVideoEncodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeH265ReferenceInfo *>( this );
+      }
+
+      operator StdVideoEncodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this );
+      }
+
       bool operator==( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && ( TemporalId == rhs.TemporalId );
@@ -2881,6 +3461,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1ColorConfigFlags *>( this );
       }
 
+      operator StdVideoAV1ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1ColorConfigFlags *>( this );
+      }
+
+      operator StdVideoAV1ColorConfigFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1ColorConfigFlags *>( this );
+      }
+
       bool operator==( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( mono_chrome == rhs.mono_chrome ) && ( color_range == rhs.color_range ) && ( separate_uv_delta_q == rhs.separate_uv_delta_q ) &&
@@ -2914,6 +3504,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1ColorConfig *>( this );
       }
 
+      operator StdVideoAV1ColorConfig const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1ColorConfig *>( this );
+      }
+
+      operator StdVideoAV1ColorConfig *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1ColorConfig *>( this );
+      }
+
       bool operator==( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) &&
@@ -2956,6 +3556,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1TimingInfoFlags *>( this );
       }
 
+      operator StdVideoAV1TimingInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1TimingInfoFlags *>( this );
+      }
+
+      operator StdVideoAV1TimingInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1TimingInfoFlags *>( this );
+      }
+
       bool operator==( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( equal_picture_interval == rhs.equal_picture_interval ) && ( reserved == rhs.reserved );
@@ -2985,6 +3595,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1TimingInfo *>( this );
       }
 
+      operator StdVideoAV1TimingInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1TimingInfo *>( this );
+      }
+
+      operator StdVideoAV1TimingInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1TimingInfo *>( this );
+      }
+
       bool operator==( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && ( time_scale == rhs.time_scale ) &&
@@ -3017,6 +3637,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1LoopFilterFlags *>( this );
       }
 
+      operator StdVideoAV1LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1LoopFilterFlags *>( this );
+      }
+
+      operator StdVideoAV1LoopFilterFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1LoopFilterFlags *>( this );
+      }
+
       bool operator==( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) &&
@@ -3048,6 +3678,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1LoopFilter *>( this );
       }
 
+      operator StdVideoAV1LoopFilter const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1LoopFilter *>( this );
+      }
+
+      operator StdVideoAV1LoopFilter *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1LoopFilter *>( this );
+      }
+
       bool operator==( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) &&
@@ -3084,6 +3724,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1QuantizationFlags *>( this );
       }
 
+      operator StdVideoAV1QuantizationFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1QuantizationFlags *>( this );
+      }
+
+      operator StdVideoAV1QuantizationFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1QuantizationFlags *>( this );
+      }
+
       bool operator==( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( using_qmatrix == rhs.using_qmatrix ) && ( diff_uv_delta == rhs.diff_uv_delta ) && ( reserved == rhs.reserved );
@@ -3114,6 +3764,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1Quantization *>( this );
       }
 
+      operator StdVideoAV1Quantization const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1Quantization *>( this );
+      }
+
+      operator StdVideoAV1Quantization *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1Quantization *>( this );
+      }
+
       bool operator==( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( base_q_idx == rhs.base_q_idx ) && ( DeltaQYDc == rhs.DeltaQYDc ) && ( DeltaQUDc == rhs.DeltaQUDc ) &&
@@ -3153,6 +3813,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1Segmentation *>( this );
       }
 
+      operator StdVideoAV1Segmentation const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1Segmentation *>( this );
+      }
+
+      operator StdVideoAV1Segmentation *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1Segmentation *>( this );
+      }
+
       bool operator==( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData );
@@ -3182,6 +3852,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1TileInfoFlags *>( this );
       }
 
+      operator StdVideoAV1TileInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1TileInfoFlags *>( this );
+      }
+
+      operator StdVideoAV1TileInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1TileInfoFlags *>( this );
+      }
+
       bool operator==( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( uniform_tile_spacing_flag == rhs.uniform_tile_spacing_flag ) && ( reserved == rhs.reserved );
@@ -3211,6 +3891,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1TileInfo *>( this );
       }
 
+      operator StdVideoAV1TileInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1TileInfo *>( this );
+      }
+
+      operator StdVideoAV1TileInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1TileInfo *>( this );
+      }
+
       bool operator==( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( TileCols == rhs.TileCols ) && ( TileRows == rhs.TileRows ) &&
@@ -3251,6 +3941,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1CDEF *>( this );
       }
 
+      operator StdVideoAV1CDEF const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1CDEF *>( this );
+      }
+
+      operator StdVideoAV1CDEF *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1CDEF *>( this );
+      }
+
       bool operator==( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && ( cdef_bits == rhs.cdef_bits ) && ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) &&
@@ -3286,6 +3986,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1LoopRestoration *>( this );
       }
 
+      operator StdVideoAV1LoopRestoration const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1LoopRestoration *>( this );
+      }
+
+      operator StdVideoAV1LoopRestoration *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1LoopRestoration *>( this );
+      }
+
       bool operator==( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( FrameRestorationType == rhs.FrameRestorationType ) && ( LoopRestorationSize == rhs.LoopRestorationSize );
@@ -3315,6 +4025,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1GlobalMotion *>( this );
       }
 
+      operator StdVideoAV1GlobalMotion const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1GlobalMotion *>( this );
+      }
+
+      operator StdVideoAV1GlobalMotion *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1GlobalMotion *>( this );
+      }
+
       bool operator==( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( GmType == rhs.GmType ) && ( gm_params == rhs.gm_params );
@@ -3344,6 +4064,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1FilmGrainFlags *>( this );
       }
 
+      operator StdVideoAV1FilmGrainFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1FilmGrainFlags *>( this );
+      }
+
+      operator StdVideoAV1FilmGrainFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1FilmGrainFlags *>( this );
+      }
+
       bool operator==( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && ( overlap_flag == rhs.overlap_flag ) &&
@@ -3377,6 +4107,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1FilmGrain *>( this );
       }
 
+      operator StdVideoAV1FilmGrain const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1FilmGrain *>( this );
+      }
+
+      operator StdVideoAV1FilmGrain *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1FilmGrain *>( this );
+      }
+
       bool operator==( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && ( ar_coeff_lag == rhs.ar_coeff_lag ) &&
@@ -3437,6 +4177,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1SequenceHeaderFlags *>( this );
       }
 
+      operator StdVideoAV1SequenceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1SequenceHeaderFlags *>( this );
+      }
+
+      operator StdVideoAV1SequenceHeaderFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1SequenceHeaderFlags *>( this );
+      }
+
       bool operator==( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( still_picture == rhs.still_picture ) && ( reduced_still_picture_header == rhs.reduced_still_picture_header ) &&
@@ -3493,6 +4243,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoAV1SequenceHeader *>( this );
       }
 
+      operator StdVideoAV1SequenceHeader const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoAV1SequenceHeader *>( this );
+      }
+
+      operator StdVideoAV1SequenceHeader *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoAV1SequenceHeader *>( this );
+      }
+
       bool operator==( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( seq_profile == rhs.seq_profile ) && ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) &&
@@ -3541,6 +4301,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeAV1PictureInfoFlags *>( this );
       }
 
+      operator StdVideoDecodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeAV1PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeAV1PictureInfoFlags *>( this );
+      }
+
       bool operator==( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) &&
@@ -3610,6 +4380,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeAV1PictureInfo *>( this );
       }
 
+      operator StdVideoDecodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeAV1PictureInfo *>( this );
+      }
+
+      operator StdVideoDecodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeAV1PictureInfo *>( this );
+      }
+
       bool operator==( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( current_frame_id == rhs.current_frame_id ) && ( OrderHint == rhs.OrderHint ) &&
@@ -3669,6 +4449,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeAV1ReferenceInfoFlags *>( this );
       }
 
+      operator StdVideoDecodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeAV1ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeAV1ReferenceInfoFlags *>( this );
+      }
+
       bool operator==( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
@@ -3700,6 +4490,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoDecodeAV1ReferenceInfo *>( this );
       }
 
+      operator StdVideoDecodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeAV1ReferenceInfo *>( this );
+      }
+
+      operator StdVideoDecodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeAV1ReferenceInfo *>( this );
+      }
+
       bool operator==( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( RefFrameSignBias == rhs.RefFrameSignBias ) && ( OrderHint == rhs.OrderHint ) &&
@@ -3735,6 +4535,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1DecoderModelInfo *>( this );
       }
 
+      operator StdVideoEncodeAV1DecoderModelInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1DecoderModelInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1DecoderModelInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1DecoderModelInfo *>( this );
+      }
+
       bool operator==( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) &&
@@ -3770,6 +4580,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1ExtensionHeader *>( this );
       }
 
+      operator StdVideoEncodeAV1ExtensionHeader const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1ExtensionHeader *>( this );
+      }
+
+      operator StdVideoEncodeAV1ExtensionHeader *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1ExtensionHeader *>( this );
+      }
+
       bool operator==( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( temporal_id == rhs.temporal_id ) && ( spatial_id == rhs.spatial_id );
@@ -3799,6 +4619,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeAV1OperatingPointInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1OperatingPointInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
+      }
+
       bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) &&
@@ -3831,6 +4661,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfo *>( this );
       }
 
+      operator StdVideoEncodeAV1OperatingPointInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1OperatingPointInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1OperatingPointInfo *>( this );
+      }
+
       bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) &&
@@ -3867,6 +4707,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1PictureInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1PictureInfoFlags *>( this );
+      }
+
       bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) &&
@@ -3937,6 +4787,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1PictureInfo *>( this );
       }
 
+      operator StdVideoEncodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1PictureInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1PictureInfo *>( this );
+      }
+
       bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) &&
@@ -4001,6 +4861,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfoFlags *>( this );
       }
 
+      operator StdVideoEncodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1ReferenceInfoFlags *>( this );
+      }
+
       bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
@@ -4032,6 +4902,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfo *>( this );
       }
 
+      operator StdVideoEncodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoEncodeAV1ReferenceInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoEncodeAV1ReferenceInfo *>( this );
+      }
+
       bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
       {
         return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) &&