yuzu/Vulkan-Headers
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers synced 2024-11-21 14:29:07 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Update for Vulkan-Docs 1.3.252

Browse source
This commit is contained in:
Jon Leech 2023-06-02 06:19:12 -07:00 committed by Jon Leech
parent 3df77fb3e4
commit 605dc6d3e7
16 changed files with 2007 additions and 429 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
include/vulkan/vulkan.hpp
View file

@ -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>

14
include/vulkan/vulkan_core.h
View file

@ -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"

1
include/vulkan/vulkan_enums.hpp
View file

@ -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,

9
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -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_shader_module_identifier" ) || ( 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_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
( 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" ) ||

3
include/vulkan/vulkan_handles.hpp
View file

@ -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;

13
include/vulkan/vulkan_hash.hpp
View file

@ -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>
{

9
include/vulkan/vulkan_static_assertions.hpp
View file

@ -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 ) ==

98
include/vulkan/vulkan_structs.hpp
View file

@ -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;

1
include/vulkan/vulkan_to_string.hpp
View file

@ -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";

12
registry/apiconventions.py
View file

@ -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

244
registry/genvk.py
View file

@ -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()

11
registry/parse_dependency.py
View file

@ -65,7 +65,16 @@ def nameMarkup(name):
major = match.group(1)
minor = match.group(2)
version = major + '.' + minor
return f'<<versions-{major}.{minor}, Version {version}>>'
# 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

26
registry/reg.py
View file

@ -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()

1916
registry/validusage.json
View file

File diff suppressed because it is too large Load diff

24
registry/vk.xml
View file

@ -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="&quot;VK_GOOGLE_extension_454&quot;" name="VK_GOOGLE_EXTENSION_454_EXTENSION_NAME"/>
<enum value="1" name="VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION"/>
<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">

19
registry/vkconventions.py Normal file → Executable file
View file

@ -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'