Update for Vulkan-Docs 1.3.252

include/vulkan/vulkan.hpp

@@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 251, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 252, "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@@ -12259,6 +12259,40 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_EXT_external_memory_acquire_unmodified ===
+  template <>
+  struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, BufferMemoryBarrier>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, BufferMemoryBarrier2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, ImageMemoryBarrier>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, ImageMemoryBarrier2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_EXT_extended_dynamic_state3 ===
   template <>
   struct StructExtends<PhysicalDeviceExtendedDynamicState3FeaturesEXT, PhysicalDeviceFeatures2>

include/vulkan/vulkan_core.h

@@ -68,7 +68,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 251
+#define VK_HEADER_VERSION 252
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -980,6 +980,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000,
@@ -15903,6 +15904,17 @@ typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM {
 
 
 
+#define VK_EXT_external_memory_acquire_unmodified 1
+#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME "VK_EXT_external_memory_acquire_unmodified"
+typedef struct VkExternalMemoryAcquireUnmodifiedEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           acquireUnmodifiedMemory;
+} VkExternalMemoryAcquireUnmodifiedEXT;
+
+
+
 #define VK_EXT_extended_dynamic_state3 1
 #define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2
 #define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3"

include/vulkan/vulkan_enums.hpp

@@ -1036,6 +1036,7 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceImageProcessingFeaturesQCOM                   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM,
     ePhysicalDeviceImageProcessingPropertiesQCOM                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM,
     eImageViewSampleWeightCreateInfoQCOM                         = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM,
+    eExternalMemoryAcquireUnmodifiedEXT                          = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT,
     ePhysicalDeviceExtendedDynamicState3FeaturesEXT              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
     ePhysicalDeviceExtendedDynamicState3PropertiesEXT            = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT,
     ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT               = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT,

include/vulkan/vulkan_extension_inspection.hpp

@@ -368,6 +368,7 @@ namespace VULKAN_HPP_NAMESPACE
 "VK_NV_linear_color_attachment", 
 "VK_EXT_image_compression_control_swapchain", 
 "VK_QCOM_image_processing", 
+"VK_EXT_external_memory_acquire_unmodified", 
 "VK_EXT_extended_dynamic_state3", 
 "VK_EXT_subpass_merge_feedback", 
 "VK_EXT_shader_module_identifier", 
@@ -754,6 +755,7 @@ namespace VULKAN_HPP_NAMESPACE
 { "VK_GOOGLE_surfaceless_query", { { "VK_VERSION_1_0", {  { "VK_KHR_surface",  } } } } }, 
 { "VK_EXT_image_compression_control_swapchain", { { "VK_VERSION_1_0", {  { "VK_EXT_image_compression_control",  } } } } }, 
 { "VK_QCOM_image_processing", { { "VK_VERSION_1_0", {  { "VK_KHR_format_feature_flags2",  } } } } }, 
+{ "VK_EXT_external_memory_acquire_unmodified", { { "VK_VERSION_1_0", {  { "VK_KHR_external_memory",  } } } } }, 
 { "VK_EXT_extended_dynamic_state3", { { "VK_VERSION_1_0", {  { "VK_KHR_get_physical_device_properties2",  } } } } }, 
 { "VK_EXT_subpass_merge_feedback", { { "VK_VERSION_1_0", {  { "VK_KHR_get_physical_device_properties2",  } } } } }, 
 { "VK_EXT_shader_module_identifier", { { "VK_VERSION_1_0", {  { "VK_KHR_get_physical_device_properties2", "VK_EXT_pipeline_creation_cache_control",  } } } } }, 
@@ -1470,9 +1472,10 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) ||
            ( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_linear_color_attachment" ) ||
            ( extension == "VK_EXT_image_compression_control_swapchain" ) || ( extension == "VK_QCOM_image_processing" ) ||
-           ( extension == "VK_EXT_extended_dynamic_state3" ) || ( extension == "VK_EXT_subpass_merge_feedback" ) ||
+           ( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
-           ( extension == "VK_EXT_shader_module_identifier" ) || ( extension == "VK_EXT_rasterization_order_attachment_access" ) ||
+           ( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
-           ( extension == "VK_NV_optical_flow" ) || ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) ||
+           ( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) ||
+           ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) ||
            ( extension == "VK_KHR_ray_tracing_position_fetch" ) || ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_QCOM_tile_properties" ) ||
            ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
            ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||

include/vulkan/vulkan_handles.hpp

@@ -1514,6 +1514,9 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceImageProcessingFeaturesQCOM;
   struct PhysicalDeviceImageProcessingPropertiesQCOM;
 
+  //=== VK_EXT_external_memory_acquire_unmodified ===
+  struct ExternalMemoryAcquireUnmodifiedEXT;
+
   //=== VK_EXT_extended_dynamic_state3 ===
   struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
   struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;

include/vulkan/vulkan_hash.hpp

@@ -4436,6 +4436,19 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
   {

include/vulkan/vulkan_static_assertions.hpp

@@ -6138,6 +6138,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM>::value,
                           "PhysicalDeviceImageProcessingPropertiesQCOM is not nothrow_move_constructible!" );
 
+//=== VK_EXT_external_memory_acquire_unmodified ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT ) == sizeof( VkExternalMemoryAcquireUnmodifiedEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT>::value,
+                          "ExternalMemoryAcquireUnmodifiedEXT is not nothrow_move_constructible!" );
+
 //=== VK_EXT_extended_dynamic_state3 ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT ) ==

include/vulkan/vulkan_structs.hpp

@@ -32884,6 +32884,104 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes         = {};
   };
 
+  struct ExternalMemoryAcquireUnmodifiedEXT
+  {
+    using NativeType = VkExternalMemoryAcquireUnmodifiedEXT;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eExternalMemoryAcquireUnmodifiedEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( VULKAN_HPP_NAMESPACE::Bool32 acquireUnmodifiedMemory_ = {},
+                                                             const void *                 pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , acquireUnmodifiedMemory( acquireUnmodifiedMemory_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    ExternalMemoryAcquireUnmodifiedEXT( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : ExternalMemoryAcquireUnmodifiedEXT( *reinterpret_cast<ExternalMemoryAcquireUnmodifiedEXT const *>( &rhs ) )
+    {
+    }
+
+    ExternalMemoryAcquireUnmodifiedEXT & operator=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    ExternalMemoryAcquireUnmodifiedEXT & operator=( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT &
+                            setAcquireUnmodifiedMemory( VULKAN_HPP_NAMESPACE::Bool32 acquireUnmodifiedMemory_ ) VULKAN_HPP_NOEXCEPT
+    {
+      acquireUnmodifiedMemory = acquireUnmodifiedMemory_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkExternalMemoryAcquireUnmodifiedEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT *>( this );
+    }
+
+    operator VkExternalMemoryAcquireUnmodifiedEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkExternalMemoryAcquireUnmodifiedEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, acquireUnmodifiedMemory );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( ExternalMemoryAcquireUnmodifiedEXT const & ) const = default;
+#else
+    bool operator==( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireUnmodifiedMemory == rhs.acquireUnmodifiedMemory );
+#  endif
+    }
+
+    bool operator!=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                   = StructureType::eExternalMemoryAcquireUnmodifiedEXT;
+    const void *                        pNext                   = {};
+    VULKAN_HPP_NAMESPACE::Bool32        acquireUnmodifiedMemory = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eExternalMemoryAcquireUnmodifiedEXT>
+  {
+    using Type = ExternalMemoryAcquireUnmodifiedEXT;
+  };
+
   struct ExternalMemoryBufferCreateInfo
   {
     using NativeType = VkExternalMemoryBufferCreateInfo;

include/vulkan/vulkan_to_string.hpp

@@ -4089,6 +4089,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM: return "PhysicalDeviceImageProcessingFeaturesQCOM";
       case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM: return "PhysicalDeviceImageProcessingPropertiesQCOM";
       case StructureType::eImageViewSampleWeightCreateInfoQCOM: return "ImageViewSampleWeightCreateInfoQCOM";
+      case StructureType::eExternalMemoryAcquireUnmodifiedEXT: return "ExternalMemoryAcquireUnmodifiedEXT";
       case StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT: return "PhysicalDeviceExtendedDynamicState3FeaturesEXT";
       case StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT: return "PhysicalDeviceExtendedDynamicState3PropertiesEXT";
       case StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT: return "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT";

registry/apiconventions.py

@@ -8,4 +8,14 @@
 # This import should be changed at the repository / working group level to
 # specify the correct API's conventions.
 
-from vkconventions import VulkanConventions as APIConventions
+
+import os
+
+defaultAPI = 'vulkan'
+
+VulkanAPI = os.getenv('VULKAN_API', default=defaultAPI)
+
+if VulkanAPI == 'vulkansc':
+    from vkconventions import VulkanSCConventions as APIConventions
+else:
+    from vkconventions import VulkanConventions as APIConventions

registry/genvk.py

@@ -16,6 +16,12 @@ import xml.etree.ElementTree as etree
 sys.path.append(os.path.abspath(os.path.dirname(__file__)))
 
 from cgenerator import CGeneratorOptions, COutputGenerator
+# Vulkan SC modules
+from json_parser import JSONParserGenerator, JSONParserOptions
+from schema_generator import SchemaGeneratorOptions, SchemaOutputGenerator
+from json_generator import JSONGeneratorOptions, JSONOutputGenerator
+from json_h_generator import JSONHeaderOutputGenerator, JSONHeaderGeneratorOptions
+from json_c_generator import JSONCOutputGenerator, JSONCGeneratorOptions
 
 from docgenerator import DocGeneratorOptions, DocOutputGenerator
 from extensionmetadocgenerator import (ExtensionMetaDocGeneratorOptions,
@@ -137,6 +143,8 @@ def makeGenOpts(args):
         ''
     ]
 
+    vulkanLayer = args.vulkanLayer
+
     # Defaults for generating re-inclusion protection wrappers (or not)
     protectFile = protect
 
@@ -151,6 +159,8 @@ def makeGenOpts(args):
     # APIs to merge
     mergeApiNames = args.mergeApiNames
 
+    isCTS = args.isCTS
+
     # API include files for spec and ref pages
     # Overwrites include subdirectories in spec source tree
     # The generated include files do not include the calling convention
@@ -426,6 +436,9 @@ def makeGenOpts(args):
         [ 'vulkan_metal.h',       [ 'VK_EXT_metal_surface',
                                     'VK_EXT_metal_objects'        ], commonSuppressExtensions ],
         [ 'vulkan_screen.h',      [ 'VK_QNX_screen_surface'       ], commonSuppressExtensions ],
+        [ 'vulkan_sci.h',         [ 'VK_NV_external_sci_sync',
+                                    'VK_NV_external_sci_sync2',
+                                    'VK_NV_external_memory_sci_buf'], commonSuppressExtensions ],
         [ 'vulkan_beta.h',        betaRequireExtensions,             betaSuppressExtensions ],
     ]
 
@@ -509,6 +522,233 @@ def makeGenOpts(args):
             misracppstyle     = misracppstyle)
         ]
 
+    # Vulkan versions to include for SC header - SC *removes* features from 1.0/1.1/1.2
+    scVersions = makeREstring(['VK_VERSION_1_0', 'VK_VERSION_1_1', 'VK_VERSION_1_2', 'VKSC_VERSION_1_0'])
+
+    genOpts['vulkan_sc_core.h'] = [
+          COutputGenerator,
+          CGeneratorOptions(
+            conventions       = conventions,
+            filename          = 'vulkan_sc_core.h',
+            directory         = directory,
+            apiname           = 'vulkansc',
+            profile           = None,
+            versions          = scVersions,
+            emitversions      = scVersions,
+            defaultExtensions = 'vulkansc',
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = removeExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48,
+            misracstyle       = misracstyle,
+            misracppstyle     = misracppstyle)
+        ]
+
+    genOpts['vulkan_sc_core.hpp'] = [
+          COutputGenerator,
+          CGeneratorOptions(
+            conventions       = conventions,
+            filename          = 'vulkan_sc_core.hpp',
+            directory         = directory,
+            apiname           = 'vulkansc',
+            profile           = None,
+            versions          = scVersions,
+            emitversions      = scVersions,
+            defaultExtensions = 'vulkansc',
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = removeExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48,
+            misracstyle       = misracstyle,
+            misracppstyle     = misracppstyle)
+        ]
+
+    genOpts['vk.json'] = [
+          SchemaOutputGenerator,
+          SchemaGeneratorOptions(
+            conventions       = conventions,
+            filename          = 'vk.json',
+            directory         = directory,
+            apiname           = 'vulkansc',
+            profile           = None,
+            versions          = scVersions,
+            emitversions      = scVersions,
+            defaultExtensions = 'vulkansc',
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = removeExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48)
+        ]
+
+    if vulkanLayer:
+        genOpts['vulkan_json_data.hpp'] = [
+            JSONOutputGenerator,
+            JSONGeneratorOptions(
+                conventions       = conventions,
+                filename          = 'vulkan_json_data.hpp',
+                directory         = directory,
+                apiname           = 'vulkan',
+                profile           = None,
+                versions          = featuresPat,
+                emitversions      = featuresPat,
+                defaultExtensions = None,
+                addExtensions     = addExtensionsPat,
+                removeExtensions  = None,
+                emitExtensions    = None,
+                vulkanLayer       = vulkanLayer,
+                prefixText        = prefixStrings + vkPrefixStrings,
+                genFuncPointers   = True,
+                protectFile       = protectFile,
+                protectFeature    = False,
+                protectProto      = '#ifndef',
+                protectProtoStr   = 'VK_NO_PROTOTYPES',
+                apicall           = 'VKAPI_ATTR ',
+                apientry          = 'VKAPI_CALL ',
+                apientryp         = 'VKAPI_PTR *',
+                alignFuncParam    = 48)
+            ]
+    else:
+        genOpts['vulkan_json_data.hpp'] = [
+        JSONOutputGenerator,
+        JSONGeneratorOptions(
+            conventions       = conventions,
+            filename          = 'vulkan_json_data.hpp',
+            directory         = directory,
+            apiname           = 'vulkansc',
+            profile           = None,
+            versions          = scVersions,
+            emitversions      = scVersions,
+            defaultExtensions = 'vulkansc',
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = removeExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            vulkanLayer       = vulkanLayer,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            isCTS             = isCTS,
+            alignFuncParam    = 48)
+        ]
+
+    # keep any relevant platform extensions for the following generators
+    # (needed for e.g. the vulkan_sci extensions)
+    explicitRemoveExtensionsPat = makeREstring(
+        removeExtensions, None, strings_are_regex=True)
+
+    # Raw C header file generator.
+    genOpts['vulkan_json_gen.h'] = [
+          JSONHeaderOutputGenerator,
+          JSONHeaderGeneratorOptions(
+            conventions       = conventions,
+            filename          = 'vulkan_json_gen.h',
+            directory         = directory,
+            apiname           = 'vulkansc',
+            profile           = None,
+            versions          = scVersions,
+            emitversions      = scVersions,
+            defaultExtensions = 'vulkansc',
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = explicitRemoveExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48)
+        ]
+
+    # Raw C source file generator.
+    genOpts['vulkan_json_gen.c'] = [
+          JSONCOutputGenerator,
+          JSONCGeneratorOptions(
+            conventions       = conventions,
+            filename          = 'vulkan_json_gen.c',
+            directory         = directory,
+            apiname           = 'vulkansc',
+            profile           = None,
+            versions          = scVersions,
+            emitversions      = scVersions,
+            defaultExtensions = 'vulkansc',
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = explicitRemoveExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48)
+        ]
+
+    genOpts['vulkan_json_parser.hpp'] = [
+          JSONParserGenerator,
+          JSONParserOptions(
+            conventions       = conventions,
+            filename          = 'vulkan_json_parser.hpp',
+            directory         = directory,
+            apiname           = 'vulkansc',
+            profile           = None,
+            versions          = scVersions,
+            emitversions      = scVersions,
+            defaultExtensions = 'vulkansc',
+            addExtensions     = addExtensionsPat,
+            removeExtensions  = explicitRemoveExtensionsPat,
+            emitExtensions    = emitExtensionsPat,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            genFuncPointers   = True,
+            protectFile       = protectFile,
+            protectFeature    = False,
+            protectProto      = '#ifndef',
+            protectProtoStr   = 'VK_NO_PROTOTYPES',
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            isCTS             = isCTS,
+            alignFuncParam    = 48)
+        ]
+
     # Unused - vulkan10.h target.
     # It is possible to generate a header with just the Vulkan 1.0 +
     # extension interfaces defined, but since the promoted KHR extensions
@@ -787,10 +1027,14 @@ if __name__ == '__main__':
                         help='Suppress script output during normal execution.')
     parser.add_argument('-verbose', action='store_false', dest='quiet', default=True,
                         help='Enable script output during normal execution.')
+    parser.add_argument('--vulkanLayer', action='store_true', dest='vulkanLayer',
+                        help='Enable scripts to generate VK specific vulkan_json_data.hpp for json_gen_layer.')
     parser.add_argument('-misracstyle', dest='misracstyle', action='store_true',
                         help='generate MISRA C-friendly headers')
     parser.add_argument('-misracppstyle', dest='misracppstyle', action='store_true',
                         help='generate MISRA C++-friendly headers')
+    parser.add_argument('--iscts', action='store_true', dest='isCTS',
+                        help='Specify if this should generate CTS compatible code')
 
     args = parser.parse_args()
 

registry/parse_dependency.py

@@ -65,6 +65,15 @@ def nameMarkup(name):
         major = match.group(1)
         minor = match.group(2)
         version = major + '.' + minor
+
+        # Vulkan SC has a different anchor pattern for version appendices
+        scMatch = re.search("[A-Z]+SC_VERSION_([0-9]+)_([0-9]+)", name)
+        if scMatch is not None:
+            if version == '1.0':
+                return 'Vulkan SC 1.0'
+            else:
+                return f'<<versions-sc-{major}.{minor}, Version SC {version}>>'
+        else:
             return f'<<versions-{major}.{minor}, Version {version}>>'
     else:
         return 'apiext:' + name

registry/reg.py

@@ -974,6 +974,7 @@ class Registry:
             self.markTypeRequired(typeElem.get('name'), required)
         for enumElem in feature.findall('enum'):
             self.markEnumRequired(enumElem.get('name'), required)
+
         for cmdElem in feature.findall('command'):
             self.markCmdRequired(cmdElem.get('name'), required)
 
@@ -1402,6 +1403,30 @@ class Registry:
                 if stripped:
                     eleminfo.elem.set(attribute, ','.join(apis))
 
+    def stripUnsupportedAPIsFromList(self, dictionary, supportedDictionary):
+        """Strip unsupported APIs from attributes of APIs.
+           dictionary - dictionary of list of structure name strings
+           supportedDictionary - dictionary in which to look for supported
+            API elements in the attribute"""
+
+        for key in dictionary:
+            attribstring = dictionary[key]
+            if attribstring is not None:
+                apis = []
+                stripped = False
+                for api in attribstring:
+                    ##print('Checking API {} referenced by {}'.format(api, key))
+                    if supportedDictionary[api].required:
+                        apis.append(api)
+                    else:
+                        stripped = True
+                        ##print('\t**STRIPPING API {} from {}'.format(api, key))
+
+                # Update the attribute after stripping stuff.
+                # Could sort apis before joining, but it is not a clear win
+                if stripped:
+                    dictionary[key] = apis
+
     def generateFormat(self, format, dictionary):
         if format is None:
             self.gen.logMsg('diag', 'No entry found for format element',
@@ -1603,6 +1628,7 @@ class Registry:
         self.stripUnsupportedAPIs(self.typedict, 'structextends', self.typedict)
         self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict)
         self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict)
+        self.stripUnsupportedAPIsFromList(self.validextensionstructs, self.typedict)
 
         # Construct lists of valid extension structures
         self.tagValidExtensionStructs()

registry/vk.xml

@@ -174,7 +174,7 @@ branch of the member gitlab server.
 #define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
 
         <type api="vulkan" category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 251</type>
+#define <name>VK_HEADER_VERSION</name> 252</type>
         <type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, VK_HEADER_VERSION)</type>
         <type api="vulkansc" category="define">// Version of this file
@@ -2881,7 +2881,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>VkSemaphoreSciSyncPoolNV</type>               <name>semaphorePool</name></member>
             <member>const <type>NvSciSyncFence</type>*                  <name>pFence</name></member>
         </type>
-        <type category="struct" name="VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV" allowduplicate="true" structextends="VkDeviceObjectReservationCreateInfo">
+        <type category="struct" name="VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV" allowduplicate="true" structextends="VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true">const <type>void</type>*            <name>pNext</name></member>
             <member><type>uint32_t</type>                               <name>semaphoreSciSyncPoolRequestCount</name></member>
@@ -5028,7 +5028,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member optional="true">const <type>void</type>*         <name>pNext</name></member>
             <member><type>uint32_t</type>            <name>counterPassIndex</name><comment>Index for which counter pass to submit</comment></member>
         </type>
-        <type category="struct" name="VkPerformanceQueryReservationInfoKHR" allowduplicate="true" structextends="VkDeviceObjectReservationCreateInfo">
+        <type category="struct" name="VkPerformanceQueryReservationInfoKHR" allowduplicate="true" structextends="VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true">const <type>void</type>*         <name>pNext</name></member>
             <member><type>uint32_t</type>            <name>maxPerformanceQueriesPerPool</name><comment>Maximum number of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR queries in a query pool</comment></member>
@@ -5539,7 +5539,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
         </type>
         <type category="struct" name="VkFaultCallbackInfo" structextends="VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member optional="true"><type>void</type>*              <name>pNext</name></member>
+            <member optional="true">const <type>void</type>*        <name>pNext</name></member>
             <member optional="true"><type>uint32_t</type>           <name>faultCount</name></member>
             <member optional="true" len="faultCount"><type>VkFaultData</type>*<name>pFaults</name></member>
             <member><type>PFN_vkFaultCallbackFunction</type>        <name>pfnFaultCallback</name></member>
@@ -7728,6 +7728,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member noautovalidity="true" optional="true"><type>void</type>*        <name>pNext</name></member>
             <member><type>VkBool32</type>                           <name>shaderEarlyAndLateFragmentTests</name></member>
         </type>
+        <type category="struct" name="VkExternalMemoryAcquireUnmodifiedEXT" structextends="VkBufferMemoryBarrier,VkBufferMemoryBarrier2,VkImageMemoryBarrier,VkImageMemoryBarrier2">
+            <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true">const <type>void</type>*    <name>pNext</name></member>
+            <member><type>VkBool32</type>                       <name>acquireUnmodifiedMemory</name></member>
+        </type>
         <type category="struct" name="VkExportMetalObjectCreateInfoEXT" structextends="VkInstanceCreateInfo,VkMemoryAllocateInfo,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferViewCreateInfo,VkSemaphoreCreateInfo,VkEventCreateInfo" allowduplicate="true">
             <member values="VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true">const <type>void</type>*                <name>pNext</name></member>
@@ -10345,6 +10350,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
             <param optional="true" len="pPropertyCount"><type>VkLayerProperties</type>* <name>pProperties</name></param>
         </command>
+
         <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_LAYER_NOT_PRESENT">
             <proto><type>VkResult</type> <name>vkEnumerateDeviceExtensionProperties</name></proto>
             <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
@@ -15486,13 +15492,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <type name="VkShaderModuleCreateFlagBits"/>
             <type name="VkShaderModuleCreateInfo"/>
             <type name="VkCommandPoolTrimFlags"/>
-            <type name="VkCommandPoolTrimFlagsKHR"/>
             <command name="vkCreateShaderModule"/>
             <command name="vkDestroyShaderModule"/>
             <command name="vkMergePipelineCaches"/>
             <command name="vkGetPipelineCacheData"/>
             <command name="vkTrimCommandPool"/>
-            <command name="vkTrimCommandPoolKHR"/>
             <command name="vkDestroyCommandPool"/>
             <command name="vkDestroyDescriptorPool"/>
             <command name="vkDestroyQueryPool"/>
@@ -21391,10 +21395,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum bitpos="50" extends="VkAccessFlagBits2"           name="VK_ACCESS_2_RESERVED_50_BIT_ARM"/>
             </require>
         </extension>
-        <extension name="VK_GOOGLE_extension_454" number="454" author="GOOGLE" contact="Lina Versace @versalinyaa" supported="disabled">
+        <extension name="VK_EXT_external_memory_acquire_unmodified" number="454" type="device" depends="VK_KHR_external_memory" author="EXT" contact="Lina Versace @versalinyaa" supported="vulkan" ratified="vulkan">
             <require>
-                <enum value="0"                                                         name="VK_GOOGLE_EXTENSION_454_SPEC_VERSION"/>
+                <enum value="1"                                                         name="VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION"/>
-                <enum value="&quot;VK_GOOGLE_extension_454&quot;"       name="VK_GOOGLE_EXTENSION_454_EXTENSION_NAME"/>
+                <enum value="&quot;VK_EXT_external_memory_acquire_unmodified&quot;"     name="VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                              name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT"/>
+                <type name="VkExternalMemoryAcquireUnmodifiedEXT"/>
             </require>
         </extension>
         <extension name="VK_GOOGLE_extension_455" number="455" author="GOOGLE" contact="Lina Versace @versalinyaa" supported="disabled">

registry/vkconventions.py

@@ -108,6 +108,7 @@ class VulkanConventions(ConventionsBase):
         subpats = [
             [ r'_H_(26[45])_',              r'_H\1_' ],
             [ r'_VULKAN_([0-9])([0-9])_',   r'_VULKAN_\1_\2_' ],
+            [ r'_VULKAN_SC_([0-9])([0-9])_',r'_VULKAN_SC_\1_\2_' ],
             [ r'_DIRECT_FB_',               r'_DIRECTFB_' ],
             [ r'_VULKAN_SC_10',             r'_VULKAN_SC_1_0' ],
 
@@ -277,3 +278,21 @@ class VulkanConventions(ConventionsBase):
         """Return any extra text (following the title) for generated
            reference pages."""
         return 'include::{generated}/specattribs.adoc[]'
+
+
+class VulkanSCConventions(VulkanConventions):
+
+    def specURL(self, spectype='api'):
+        """Return public registry URL which ref pages should link to for the
+           current all-extensions HTML specification, so xrefs in the
+           asciidoc source that are not to ref pages can link into it
+           instead. N.b. this may need to change on a per-refpage basis if
+           there are multiple documents involved.
+        """
+        return 'https://registry.khronos.org/vulkansc/specs/1.0-extensions/html/vkspec.html'
+
+    @property
+    def xml_api_name(self):
+        """Return the name used in the default API XML registry for the default API"""
+        return 'vulkansc'
+