// check that all array sizes are a known constant
for ( auto const & arraySize : member.arraySizes )
{
- if ( !isNumber( arraySize ) && !extIt->requireData.constants.contains( arraySize ) )
+ if ( arraySize.find_first_not_of( "0123456789" ) != std::string::npos )
{
- checkForError(
- !extIt->depends.empty(), extIt->xmlLine, "struct member <" + member.name + "> uses unknown constant <" + arraySize + "> as array size" );
- auto depIt = std::find_if( m_extensions.begin(), m_extensions.end(), [&extIt]( ExtensionData const & ed ) { return ed.name == extIt->depends; } );
- assert( depIt != m_extensions.end() );
- checkForError( depIt->requireData.constants.contains( arraySize ),
- member.xmlLine,
- "struct member <" + member.name + "> uses unknown constant <" + arraySize + "> as array size" );
+ bool found = extIt->requireData.constants.contains( arraySize );
+ if ( !found )
+ {
+ checkForError(
+ !extIt->depends.empty(), extIt->xmlLine, "struct member <" + member.name + "> uses unknown constant <" + arraySize + "> as array size" );
+ auto depIt = std::find_if( m_extensions.begin(), m_extensions.end(), [&extIt]( ExtensionData const & ed ) { return ed.name == extIt->depends; } );
+ assert( depIt != m_extensions.end() );
+ checkForError( depIt->requireData.constants.contains( arraySize ),
+ member.xmlLine,
+ "struct member <" + member.name + "> uses unknown constant <" + arraySize + "> as array size" );
+ }
}
}
}
if ( !name.ends_with( "_SPEC_VERSION" ) && !name.ends_with( "_EXTENSION_NAME" ) )
{
- checkForError( isNumber( value ) || isHexNumber( value ), line, "enum value uses unknown constant <" + value + ">" );
+ checkForError( value.find_first_not_of( "0123456789" ) == std::string::npos, line, "enum value uses unknown constant <" + value + ">" );
checkForError( constants.insert( { name, { value, line } } ).second, line, "required enum <" + name + "> already specified" );
}
}
-Subproject commit df60f0316899460eeaaefa06d2dd7e4e300c1604
+Subproject commit 9085224a1b45f78deadf94f800b0ec092d1c3568
else
{
// check for non-alias structureTypes only
- checkForWarning( !enumValue.alias.empty() || ( sTypeValues.erase( enumValue.name ) == 1 ),
- enumValue.xmlLine,
- "VkStructureType enum value <" + enumValue.name + "> never used" );
+ checkForError( !enumValue.alias.empty() || ( sTypeValues.erase( enumValue.name ) == 1 ),
+ enumValue.xmlLine,
+ "VkStructureType enum value <" + enumValue.name + "> never used" );
}
}
assert( sTypeValues.empty() );
using Shared${type} = SharedHandle<${type}>;
${aliasHandle})";
- return replaceWithMap(
- sharedHandleTemplate,
- { { "aliasHandle", aliasHandle },
- { "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
- { "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
- { "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
- { "destructor", handleData.second.destructorType.empty() ? "NoDestructor" : stripPrefix( handleData.second.destructorType, "Vk" ) },
- { "type", type } } );
+ return replaceWithMap( sharedHandleTemplate,
+ { { "aliasHandle", aliasHandle },
+ { "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
+ { "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
+ { "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
+ { "destructor", handleData.second.destructorType.empty() ? "NoDestructor" : stripPrefix( handleData.second.destructorType, "Vk" ) },
+ { "type", type } } );
}
return "";
}
auto handleIt = m_handles.find( commandData.params[valueIndex].type.type );
assert( handleIt != m_handles.end() );
- handleIt->second.deleteCommand = commandName;
+ handleIt->second.deleteCommand = commandName;
handleIt->second.destructorType = key;
}
}
return std::none_of( name.begin(), name.end(), []( auto const & c ) { return c != toupper( c ); } );
}
+bool isNumber( std::string const & name )
+{
+ return name.find_first_not_of( "0123456789" ) == std::string::npos;
+}
+
std::string readSnippet( std::string const & snippetFile )
{
std::ifstream ifs( std::string( BASE_PATH ) + "/snippets/" + snippetFile );
std::map<std::string, std::string> getAttributes( tinyxml2::XMLElement const * element );
template <typename ElementContainer>
std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer const * element );
-bool isHexNumber( std::string const & name );
-bool isNumber( std::string const & name );
std::string readComment( tinyxml2::XMLElement const * element );
std::pair<std::vector<std::string>, std::string> readModifiers( tinyxml2::XMLNode const * node );
TypeInfo readTypeInfo( tinyxml2::XMLElement const * element );
return childElements;
}
-bool isHexNumber( std::string const & name )
-{
- return name.starts_with( "0x" ) && ( name.find_first_not_of( "0123456789ABCDEF", 2 ) == std::string::npos );
-}
-
-bool isNumber( std::string const & name )
-{
- return name.find_first_not_of( "0123456789" ) == std::string::npos;
-}
-
inline std::string readComment( tinyxml2::XMLElement const * element )
{
int line = element->GetLineNum();
using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
- //=== VK_EXT_frame_boundary ===
- using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagBitsEXT;
- using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT;
-
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagBitsQNX;
//=== VK_QCOM_filter_cubic_weights ===
using VULKAN_HPP_NAMESPACE::CubicFilterWeightsQCOM;
- //=== VK_MSFT_layered_driver ===
- using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT;
-
//=========================
//=== Index Type Traits ===
//=========================
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT;
- //=== VK_EXT_frame_boundary ===
- using VULKAN_HPP_NAMESPACE::FrameBoundaryEXT;
- using VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT;
-
//=== VK_EXT_multisampled_render_to_single_sampled ===
using VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
using VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- //=== VK_MSFT_layered_driver ===
- using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT;
-
- //=== VK_NV_descriptor_pool_overallocation ===
- using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
-
//===============
//=== HANDLEs ===
//===============
# include <span>
#endif
-static_assert( VK_HEADER_VERSION == 265, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 262, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
};
};
- //=== VK_EXT_frame_boundary ===
- template <>
- struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, PhysicalDeviceFeatures2>
- {
- enum
- {
- value = true
- };
- };
-
- template <>
- struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, DeviceCreateInfo>
- {
- enum
- {
- value = true
- };
- };
-
- template <>
- struct StructExtends<FrameBoundaryEXT, SubmitInfo>
- {
- enum
- {
- value = true
- };
- };
-
- template <>
- struct StructExtends<FrameBoundaryEXT, SubmitInfo2>
- {
- enum
- {
- value = true
- };
- };
-
- template <>
- struct StructExtends<FrameBoundaryEXT, PresentInfoKHR>
- {
- enum
- {
- value = true
- };
- };
-
- template <>
- struct StructExtends<FrameBoundaryEXT, BindSparseInfo>
- {
- enum
- {
- value = true
- };
- };
-
//=== VK_EXT_multisampled_render_to_single_sampled ===
template <>
struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, PhysicalDeviceFeatures2>
};
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- //=== VK_MSFT_layered_driver ===
- template <>
- struct StructExtends<PhysicalDeviceLayeredDriverPropertiesMSFT, PhysicalDeviceProperties2>
- {
- enum
- {
- value = true
- };
- };
-
- //=== VK_NV_descriptor_pool_overallocation ===
- template <>
- struct StructExtends<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, PhysicalDeviceFeatures2>
- {
- enum
- {
- value = true
- };
- };
-
- template <>
- struct StructExtends<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, DeviceCreateInfo>
- {
- enum
- {
- value = true
- };
- };
-
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
# elif defined( __APPLE__ )
m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
# elif defined( _WIN32 )
- m_library = ::LoadLibraryA( "vulkan-1.dll" );
+ m_library = ::LoadLibraryA( "vulkan-1.dll" );
# else
# error unsupported platform
# endif
ePipelinePropertiesIdentifierEXT = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT,
ePhysicalDevicePipelinePropertiesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT,
ePipelineInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT,
- ePhysicalDeviceFrameBoundaryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT,
- eFrameBoundaryEXT = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT,
ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT,
eSubpassResolvePerformanceQueryEXT = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT,
eMultisampledRenderToSingleSampledInfoEXT = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT,
eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX,
eImportScreenBufferInfoQNX = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX,
eExternalFormatQNX = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX,
- ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
+ ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- ePhysicalDeviceLayeredDriverPropertiesMSFT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT,
- ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV
};
enum class PipelineCacheHeaderVersion
enum class DescriptorPoolCreateFlagBits : VkDescriptorPoolCreateFlags
{
- eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
- eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
- eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT,
- eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
- eHostOnlyEXT = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT,
- eAllowOverallocationSetsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV,
- eAllowOverallocationPoolsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV
+ eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+ eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
+ eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT,
+ eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
+ eHostOnlyEXT = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT
};
using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits>;
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolCreateFlags allFlags =
- DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT |
- DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV | DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV;
+ DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT;
};
enum class DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags
{
eError = VK_QUERY_RESULT_STATUS_ERROR_KHR,
eNotReady = VK_QUERY_RESULT_STATUS_NOT_READY_KHR,
- eComplete = VK_QUERY_RESULT_STATUS_COMPLETE_KHR,
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
- eInsufficientBitstreamBufferRange = VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ eComplete = VK_QUERY_RESULT_STATUS_COMPLETE_KHR
};
enum class VideoSessionParametersCreateFlagBitsKHR : VkVideoSessionParametersCreateFlagsKHR
eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT,
eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
- eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
- eSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT,
- eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT
+ eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT
};
using VideoEncodeH264StdFlagsEXT = Flags<VideoEncodeH264StdFlagBitsEXT>;
VideoEncodeH264StdFlagBitsEXT::eDirectSpatialMvPredFlagUnset | VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagUnset |
VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagSet | VideoEncodeH264StdFlagBitsEXT::eDirect8X8InferenceFlagUnset |
VideoEncodeH264StdFlagBitsEXT::eConstrainedIntraPredFlagSet | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled |
- VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial |
- VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta | VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta;
+ VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial;
};
enum class VideoEncodeH264RateControlFlagBitsEXT : VkVideoEncodeH264RateControlFlagsEXT
eEntropyCodingSyncEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT,
eDeblockingFilterOverrideEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT,
eDependentSliceSegmentsEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT,
- eDependentSliceSegmentFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT,
- eSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT,
- eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT
+ eDependentSliceSegmentFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT
};
using VideoEncodeH265StdFlagsEXT = Flags<VideoEncodeH265StdFlagBitsEXT>;
VideoEncodeH265StdFlagBitsEXT::ePpsSliceChromaQpOffsetsPresentFlagSet | VideoEncodeH265StdFlagBitsEXT::eTransquantBypassEnabledFlagSet |
VideoEncodeH265StdFlagBitsEXT::eConstrainedIntraPredFlagSet | VideoEncodeH265StdFlagBitsEXT::eEntropyCodingSyncEnabledFlagSet |
VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet | VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet |
- VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet | VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta |
- VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta;
+ VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet;
};
enum class VideoEncodeH265CtbSizeFlagBitsEXT : VkVideoEncodeH265CtbSizeFlagsEXT
enum class VideoEncodeCapabilityFlagBitsKHR : VkVideoEncodeCapabilityFlagsKHR
{
- ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR,
- eInsufficientstreamBufferRangeDetectionBit = VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR
+ ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR
};
using VideoEncodeCapabilityFlagsKHR = Flags<VideoEncodeCapabilityFlagBitsKHR>;
struct FlagTraits<VideoEncodeCapabilityFlagBitsKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
- static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags =
- VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes | VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags = VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes;
};
enum class VideoEncodeFeedbackFlagBitsKHR : VkVideoEncodeFeedbackFlagsKHR
};
#endif /*VK_USE_PLATFORM_FUCHSIA*/
- //=== VK_EXT_frame_boundary ===
-
- enum class FrameBoundaryFlagBitsEXT : VkFrameBoundaryFlagsEXT
- {
- eFrameEnd = VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT
- };
-
- using FrameBoundaryFlagsEXT = Flags<FrameBoundaryFlagBitsEXT>;
-
- template <>
- struct FlagTraits<FrameBoundaryFlagBitsEXT>
- {
- static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
- static VULKAN_HPP_CONST_OR_CONSTEXPR FrameBoundaryFlagsEXT allFlags = FrameBoundaryFlagBitsEXT::eFrameEnd;
- };
-
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
eMitchellNetravali = VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM
};
- //=== VK_MSFT_layered_driver ===
-
- enum class LayeredDriverUnderlyingApiMSFT
- {
- eNone = VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT,
- eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT
- };
-
//=========================
//=== Index Type Traits ===
//=========================
"VK_HUAWEI_invocation_mask",
"VK_NV_external_memory_rdma",
"VK_EXT_pipeline_properties",
- "VK_EXT_frame_boundary",
"VK_EXT_multisampled_render_to_single_sampled",
"VK_EXT_extended_dynamic_state2",
"VK_EXT_color_write_enable",
"VK_QCOM_filter_cubic_clamp",
"VK_EXT_attachment_feedback_loop_dynamic_state",
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
- "VK_QNX_external_memory_screen_buffer",
+ "VK_QNX_external_memory_screen_buffer"
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- "VK_MSFT_layered_driver",
- "VK_NV_descriptor_pool_overallocation"
};
return deviceExtensions;
}
{ "VK_VERSION_1_1",
{ {
"VK_EXT_queue_family_foreign",
- } } } } },
+ } } } } }
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- { "VK_MSFT_layered_driver",
- { { "VK_VERSION_1_0",
- { {
- "VK_KHR_get_physical_device_properties2",
- } } } } },
- { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }
};
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
|| ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" )
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|| ( extension == "VK_HUAWEI_subpass_shading" ) || ( extension == "VK_HUAWEI_invocation_mask" ) || ( extension == "VK_NV_external_memory_rdma" ) ||
- ( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_frame_boundary" ) ||
- ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
- ( extension == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_primitives_generated_query" ) ||
- ( extension == "VK_KHR_ray_tracing_maintenance1" ) || ( extension == "VK_EXT_global_priority_query" ) ||
- ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) || ( extension == "VK_EXT_image_2d_view_of_3d" ) ||
- ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" )
+ ( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) ||
+ ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_color_write_enable" ) ||
+ ( extension == "VK_EXT_primitives_generated_query" ) || ( extension == "VK_KHR_ray_tracing_maintenance1" ) ||
+ ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) ||
+ ( extension == "VK_EXT_image_2d_view_of_3d" ) || ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_displacement_micromap" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|| ( extension == "VK_QNX_external_memory_screen_buffer" )
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_NV_descriptor_pool_overallocation" );
+ ;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
struct PipelinePropertiesIdentifierEXT;
struct PhysicalDevicePipelinePropertiesFeaturesEXT;
- //=== VK_EXT_frame_boundary ===
- struct PhysicalDeviceFrameBoundaryFeaturesEXT;
- struct FrameBoundaryEXT;
-
//=== VK_EXT_multisampled_render_to_single_sampled ===
struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
struct SubpassResolvePerformanceQueryEXT;
struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- //=== VK_MSFT_layered_driver ===
- struct PhysicalDeviceLayeredDriverPropertiesMSFT;
-
- //=== VK_NV_descriptor_pool_overallocation ===
- struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
-
//===================================
//=== HANDLE forward declarations ===
//===================================
};
template <>
- struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>
- {
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize );
- VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag );
- return seed;
- }
- };
-
- template <>
struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT
};
template <>
- struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>
- {
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const &
- physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation );
- return seed;
- }
- };
-
- template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>
{
std::size_t
};
template <>
- struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>
- {
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary );
- return seed;
- }
- };
-
- template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const & physicalDeviceGlobalPriorityQueryFeaturesKHR ) const
};
template <>
- struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
- {
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
- VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
- return seed;
- }
- };
-
- template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
{
std::size_t
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT>::value,
"PhysicalDevicePipelinePropertiesFeaturesEXT is not nothrow_move_constructible!" );
-//=== VK_EXT_frame_boundary ===
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT ) == sizeof( VkPhysicalDeviceFrameBoundaryFeaturesEXT ),
- "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>::value,
- "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>::value,
- "PhysicalDeviceFrameBoundaryFeaturesEXT is not nothrow_move_constructible!" );
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT ) == sizeof( VkFrameBoundaryEXT ), "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>::value, "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>::value,
- "FrameBoundaryEXT is not nothrow_move_constructible!" );
-
//=== VK_EXT_multisampled_render_to_single_sampled ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) ==
"PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX is not nothrow_move_constructible!" );
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-//=== VK_MSFT_layered_driver ===
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT ) == sizeof( VkPhysicalDeviceLayeredDriverPropertiesMSFT ),
- "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
- "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
- "PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" );
-
-//=== VK_NV_descriptor_pool_overallocation ===
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV ) ==
- sizeof( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV ),
- "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
- "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
- "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" );
-
#endif
using Type = FragmentShadingRateAttachmentInfoKHR;
};
- struct FrameBoundaryEXT
- {
- using NativeType = VkFrameBoundaryEXT;
-
- static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFrameBoundaryEXT;
-
-#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags_ = {},
- uint64_t frameID_ = {},
- uint32_t imageCount_ = {},
- const VULKAN_HPP_NAMESPACE::Image * pImages_ = {},
- uint32_t bufferCount_ = {},
- const VULKAN_HPP_NAMESPACE::Buffer * pBuffers_ = {},
- uint64_t tagName_ = {},
- size_t tagSize_ = {},
- const void * pTag_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
- : pNext( pNext_ )
- , flags( flags_ )
- , frameID( frameID_ )
- , imageCount( imageCount_ )
- , pImages( pImages_ )
- , bufferCount( bufferCount_ )
- , pBuffers( pBuffers_ )
- , tagName( tagName_ )
- , tagSize( tagSize_ )
- , pTag( pTag_ )
- {
- }
-
- VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- FrameBoundaryEXT( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT : FrameBoundaryEXT( *reinterpret_cast<FrameBoundaryEXT const *>( &rhs ) ) {}
-
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- FrameBoundaryEXT( VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags_,
- uint64_t frameID_,
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Image> const & images_,
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers_ = {},
- uint64_t tagName_ = {},
- size_t tagSize_ = {},
- const void * pTag_ = {},
- const void * pNext_ = nullptr )
- : pNext( pNext_ )
- , flags( flags_ )
- , frameID( frameID_ )
- , imageCount( static_cast<uint32_t>( images_.size() ) )
- , pImages( images_.data() )
- , bufferCount( static_cast<uint32_t>( buffers_.size() ) )
- , pBuffers( buffers_.data() )
- , tagName( tagName_ )
- , tagSize( tagSize_ )
- , pTag( pTag_ )
- {
- }
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
- FrameBoundaryEXT & operator=( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
-
- FrameBoundaryEXT & operator=( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const *>( &rhs );
- return *this;
- }
-
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
- {
- pNext = pNext_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFlags( VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
- {
- flags = flags_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFrameID( uint64_t frameID_ ) VULKAN_HPP_NOEXCEPT
- {
- frameID = frameID_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setImageCount( uint32_t imageCount_ ) VULKAN_HPP_NOEXCEPT
- {
- imageCount = imageCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPImages( const VULKAN_HPP_NAMESPACE::Image * pImages_ ) VULKAN_HPP_NOEXCEPT
- {
- pImages = pImages_;
- return *this;
- }
-
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- FrameBoundaryEXT & setImages( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Image> const & images_ ) VULKAN_HPP_NOEXCEPT
- {
- imageCount = static_cast<uint32_t>( images_.size() );
- pImages = images_.data();
- return *this;
- }
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setBufferCount( uint32_t bufferCount_ ) VULKAN_HPP_NOEXCEPT
- {
- bufferCount = bufferCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPBuffers( const VULKAN_HPP_NAMESPACE::Buffer * pBuffers_ ) VULKAN_HPP_NOEXCEPT
- {
- pBuffers = pBuffers_;
- return *this;
- }
-
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- FrameBoundaryEXT & setBuffers( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers_ ) VULKAN_HPP_NOEXCEPT
- {
- bufferCount = static_cast<uint32_t>( buffers_.size() );
- pBuffers = buffers_.data();
- return *this;
- }
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagName( uint64_t tagName_ ) VULKAN_HPP_NOEXCEPT
- {
- tagName = tagName_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagSize( size_t tagSize_ ) VULKAN_HPP_NOEXCEPT
- {
- tagSize = tagSize_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPTag( const void * pTag_ ) VULKAN_HPP_NOEXCEPT
- {
- pTag = pTag_;
- return *this;
- }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
- operator VkFrameBoundaryEXT const &() const VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<const VkFrameBoundaryEXT *>( this );
- }
-
- operator VkFrameBoundaryEXT &() VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<VkFrameBoundaryEXT *>( 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::FrameBoundaryFlagsEXT const &,
- uint64_t const &,
- uint32_t const &,
- const VULKAN_HPP_NAMESPACE::Image * const &,
- uint32_t const &,
- const VULKAN_HPP_NAMESPACE::Buffer * const &,
- uint64_t const &,
- size_t const &,
- const void * const &>
-# endif
- reflect() const VULKAN_HPP_NOEXCEPT
- {
- return std::tie( sType, pNext, flags, frameID, imageCount, pImages, bufferCount, pBuffers, tagName, tagSize, pTag );
- }
-#endif
-
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( FrameBoundaryEXT const & ) const = default;
-#else
- bool operator==( FrameBoundaryEXT 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 ) && ( flags == rhs.flags ) && ( frameID == rhs.frameID ) && ( imageCount == rhs.imageCount ) &&
- ( pImages == rhs.pImages ) && ( bufferCount == rhs.bufferCount ) && ( pBuffers == rhs.pBuffers ) && ( tagName == rhs.tagName ) &&
- ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag );
-# endif
- }
-
- bool operator!=( FrameBoundaryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return !operator==( rhs );
- }
-#endif
-
- public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFrameBoundaryEXT;
- const void * pNext = {};
- VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT flags = {};
- uint64_t frameID = {};
- uint32_t imageCount = {};
- const VULKAN_HPP_NAMESPACE::Image * pImages = {};
- uint32_t bufferCount = {};
- const VULKAN_HPP_NAMESPACE::Buffer * pBuffers = {};
- uint64_t tagName = {};
- size_t tagSize = {};
- const void * pTag = {};
- };
-
- template <>
- struct CppType<StructureType, StructureType::eFrameBoundaryEXT>
- {
- using Type = FrameBoundaryEXT;
- };
-
struct FramebufferAttachmentImageInfo
{
using NativeType = VkFramebufferAttachmentImageInfo;
using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
- struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV
- {
- using NativeType = VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
-
- static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
-
-#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 descriptorPoolOverallocation_ = {},
- void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
- : pNext( pNext_ )
- , descriptorPoolOverallocation( descriptorPoolOverallocation_ )
- {
- }
-
- VULKAN_HPP_CONSTEXPR
- PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- : PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( *reinterpret_cast<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const *>( &rhs ) )
- {
- }
-
- PhysicalDeviceDescriptorPoolOverallocationFeaturesNV &
- operator=( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
-
- PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & operator=( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const *>( &rhs );
- return *this;
- }
-
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
- {
- pNext = pNext_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV &
- setDescriptorPoolOverallocation( VULKAN_HPP_NAMESPACE::Bool32 descriptorPoolOverallocation_ ) VULKAN_HPP_NOEXCEPT
- {
- descriptorPoolOverallocation = descriptorPoolOverallocation_;
- return *this;
- }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
- operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>( this );
- }
-
- operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV &() VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>( this );
- }
-
-#if defined( VULKAN_HPP_USE_REFLECT )
-# if 14 <= VULKAN_HPP_CPP_VERSION
- auto
-# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-# endif
- reflect() const VULKAN_HPP_NOEXCEPT
- {
- return std::tie( sType, pNext, descriptorPoolOverallocation );
- }
-#endif
-
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & ) const = default;
-#else
- bool operator==( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV 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 ) && ( descriptorPoolOverallocation == rhs.descriptorPoolOverallocation );
-# endif
- }
-
- bool operator!=( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return !operator==( rhs );
- }
-#endif
-
- public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
- void * pNext = {};
- VULKAN_HPP_NAMESPACE::Bool32 descriptorPoolOverallocation = {};
- };
-
- template <>
- struct CppType<StructureType, StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV>
- {
- using Type = PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
- };
-
struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE
{
using NativeType = VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR;
};
- struct PhysicalDeviceFrameBoundaryFeaturesEXT
- {
- using NativeType = VkPhysicalDeviceFrameBoundaryFeaturesEXT;
-
- static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT;
-
-#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 frameBoundary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
- : pNext( pNext_ )
- , frameBoundary( frameBoundary_ )
- {
- }
-
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- PhysicalDeviceFrameBoundaryFeaturesEXT( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : PhysicalDeviceFrameBoundaryFeaturesEXT( *reinterpret_cast<PhysicalDeviceFrameBoundaryFeaturesEXT const *>( &rhs ) )
- {
- }
-
- PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
-
- PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const *>( &rhs );
- return *this;
- }
-
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
- {
- pNext = pNext_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setFrameBoundary( VULKAN_HPP_NAMESPACE::Bool32 frameBoundary_ ) VULKAN_HPP_NOEXCEPT
- {
- frameBoundary = frameBoundary_;
- return *this;
- }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
- operator VkPhysicalDeviceFrameBoundaryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT *>( this );
- }
-
- operator VkPhysicalDeviceFrameBoundaryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT *>( this );
- }
-
-#if defined( VULKAN_HPP_USE_REFLECT )
-# if 14 <= VULKAN_HPP_CPP_VERSION
- auto
-# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-# endif
- reflect() const VULKAN_HPP_NOEXCEPT
- {
- return std::tie( sType, pNext, frameBoundary );
- }
-#endif
-
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( PhysicalDeviceFrameBoundaryFeaturesEXT const & ) const = default;
-#else
- bool operator==( PhysicalDeviceFrameBoundaryFeaturesEXT 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 ) && ( frameBoundary == rhs.frameBoundary );
-# endif
- }
-
- bool operator!=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return !operator==( rhs );
- }
-#endif
-
- public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT;
- void * pNext = {};
- VULKAN_HPP_NAMESPACE::Bool32 frameBoundary = {};
- };
-
- template <>
- struct CppType<StructureType, StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT>
- {
- using Type = PhysicalDeviceFrameBoundaryFeaturesEXT;
- };
-
struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR
{
using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR;
using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
};
- struct PhysicalDeviceLayeredDriverPropertiesMSFT
- {
- using NativeType = VkPhysicalDeviceLayeredDriverPropertiesMSFT;
-
- static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT;
-
-#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT(
- VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT underlyingAPI_ = VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT::eNone,
- void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
- : pNext( pNext_ )
- , underlyingAPI( underlyingAPI_ )
- {
- }
-
- VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- PhysicalDeviceLayeredDriverPropertiesMSFT( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT
- : PhysicalDeviceLayeredDriverPropertiesMSFT( *reinterpret_cast<PhysicalDeviceLayeredDriverPropertiesMSFT const *>( &rhs ) )
- {
- }
-
- PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
-
- PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const *>( &rhs );
- return *this;
- }
-
- operator VkPhysicalDeviceLayeredDriverPropertiesMSFT const &() const VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT *>( this );
- }
-
- operator VkPhysicalDeviceLayeredDriverPropertiesMSFT &() VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<VkPhysicalDeviceLayeredDriverPropertiesMSFT *>( this );
- }
-
-#if defined( VULKAN_HPP_USE_REFLECT )
-# if 14 <= VULKAN_HPP_CPP_VERSION
- auto
-# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT const &>
-# endif
- reflect() const VULKAN_HPP_NOEXCEPT
- {
- return std::tie( sType, pNext, underlyingAPI );
- }
-#endif
-
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( PhysicalDeviceLayeredDriverPropertiesMSFT const & ) const = default;
-#else
- bool operator==( PhysicalDeviceLayeredDriverPropertiesMSFT 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 ) && ( underlyingAPI == rhs.underlyingAPI );
-# endif
- }
-
- bool operator!=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return !operator==( rhs );
- }
-#endif
-
- public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT;
- void * pNext = {};
- VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT underlyingAPI = VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT::eNone;
- };
-
- template <>
- struct CppType<StructureType, StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT>
- {
- using Type = PhysicalDeviceLayeredDriverPropertiesMSFT;
- };
-
struct PhysicalDeviceLegacyDitheringFeaturesEXT
{
using NativeType = VkPhysicalDeviceLegacyDitheringFeaturesEXT;
result += "UpdateAfterBind | ";
if ( value & DescriptorPoolCreateFlagBits::eHostOnlyEXT )
result += "HostOnlyEXT | ";
- if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV )
- result += "AllowOverallocationSetsNV | ";
- if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV )
- result += "AllowOverallocationPoolsNV | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
result += "DeblockingFilterEnabled | ";
if ( value & VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial )
result += "DeblockingFilterPartial | ";
- if ( value & VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta )
- result += "SliceQpDelta | ";
- if ( value & VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta )
- result += "DifferentSliceQpDelta | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
result += "DependentSliceSegmentsEnabledFlagSet | ";
if ( value & VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet )
result += "DependentSliceSegmentFlagSet | ";
- if ( value & VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta )
- result += "SliceQpDelta | ";
- if ( value & VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta )
- result += "DifferentSliceQpDelta | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
std::string result;
if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes )
result += "PrecedingExternallyEncodedBytes | ";
- if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit )
- result += "InsufficientstreamBufferRangeDetectionBit | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
}
#endif /*VK_USE_PLATFORM_FUCHSIA*/
- //=== VK_EXT_frame_boundary ===
-
- VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagsEXT value )
- {
- if ( !value )
- return "{}";
-
- std::string result;
- if ( value & FrameBoundaryFlagBitsEXT::eFrameEnd )
- result += "FrameEnd | ";
-
- return "{ " + result.substr( 0, result.size() - 3 ) + " }";
- }
-
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
case StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV: return "PhysicalDeviceExternalMemoryRdmaFeaturesNV";
case StructureType::ePipelinePropertiesIdentifierEXT: return "PipelinePropertiesIdentifierEXT";
case StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT: return "PhysicalDevicePipelinePropertiesFeaturesEXT";
- case StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT: return "PhysicalDeviceFrameBoundaryFeaturesEXT";
- case StructureType::eFrameBoundaryEXT: return "FrameBoundaryEXT";
case StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT: return "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT";
case StructureType::eSubpassResolvePerformanceQueryEXT: return "SubpassResolvePerformanceQueryEXT";
case StructureType::eMultisampledRenderToSingleSampledInfoEXT: return "MultisampledRenderToSingleSampledInfoEXT";
case StructureType::eExternalFormatQNX: return "ExternalFormatQNX";
case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
- case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT";
- case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet";
case DescriptorPoolCreateFlagBits::eUpdateAfterBind: return "UpdateAfterBind";
case DescriptorPoolCreateFlagBits::eHostOnlyEXT: return "HostOnlyEXT";
- case DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV: return "AllowOverallocationSetsNV";
- case DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV: return "AllowOverallocationPoolsNV";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
case QueryResultStatusKHR::eError: return "Error";
case QueryResultStatusKHR::eNotReady: return "NotReady";
case QueryResultStatusKHR::eComplete: return "Complete";
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
- case QueryResultStatusKHR::eInsufficientBitstreamBufferRange: return "InsufficientBitstreamBufferRange";
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled: return "DeblockingFilterDisabled";
case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled";
case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial";
- case VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta: return "SliceQpDelta";
- case VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta: return "DifferentSliceQpDelta";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
case VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet: return "DeblockingFilterOverrideEnabledFlagSet";
case VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet: return "DependentSliceSegmentsEnabledFlagSet";
case VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet: return "DependentSliceSegmentFlagSet";
- case VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta: return "SliceQpDelta";
- case VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta: return "DifferentSliceQpDelta";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
switch ( value )
{
case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes: return "PrecedingExternallyEncodedBytes";
- case VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit: return "InsufficientstreamBufferRangeDetectionBit";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
}
#endif /*VK_USE_PLATFORM_FUCHSIA*/
- //=== VK_EXT_frame_boundary ===
-
- VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagBitsEXT value )
- {
- switch ( value )
- {
- case FrameBoundaryFlagBitsEXT::eFrameEnd: return "FrameEnd";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
}
}
- //=== VK_MSFT_layered_driver ===
-
- VULKAN_HPP_INLINE std::string to_string( LayeredDriverUnderlyingApiMSFT value )
- {
- switch ( value )
- {
- case LayeredDriverUnderlyingApiMSFT::eNone: return "None";
- case LayeredDriverUnderlyingApiMSFT::eD3D12: return "D3D12";
- default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
- }
- }
-
} // namespace VULKAN_HPP_NAMESPACE
#endif
bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( memory_management_control_operation == rhs.memory_management_control_operation ) &&
- ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) &&
- ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 );
+ return ( operation == rhs.operation ) && ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) &&
+ ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) &&
+ ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 );
}
bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
}
public:
- VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp memory_management_control_operation =
+ VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp operation =
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd;
uint16_t difference_of_pic_nums_minus1 = {};
uint16_t long_term_pic_num = {};
{
return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) &&
( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) &&
- ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) &&
+ ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) &&
( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable );
}
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP;
int8_t slice_alpha_c0_offset_div2 = {};
int8_t slice_beta_offset_div2 = {};
- int8_t slice_qp_delta = {};
- uint8_t reserved1 = {};
+ uint16_t reserved1 = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc =
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc =
( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) &&
( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) &&
( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) &&
- ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) &&
- ( pWeightTable == rhs.pWeightTable );
+ ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( reserved1 == rhs.reserved1 ) && ( pWeightTable == rhs.pWeightTable );
}
bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
int8_t slice_act_y_qp_offset = {};
int8_t slice_act_cb_qp_offset = {};
int8_t slice_act_cr_qp_offset = {};
- int8_t slice_qp_delta = {};
- uint16_t reserved1 = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {};
};
uint32_t reserved : 23;
};
- struct EncodeH265LongTermRefPics
+ struct EncodeH265SliceSegmentLongTermRefPics
{
- using NativeType = StdVideoEncodeH265LongTermRefPics;
+ using NativeType = StdVideoEncodeH265SliceSegmentLongTermRefPics;
- operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT
+ operator StdVideoEncodeH265SliceSegmentLongTermRefPics const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this );
+ return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentLongTermRefPics *>( this );
}
- operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT
+ operator StdVideoEncodeH265SliceSegmentLongTermRefPics &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this );
+ return *reinterpret_cast<StdVideoEncodeH265SliceSegmentLongTermRefPics *>( this );
}
- bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( EncodeH265SliceSegmentLongTermRefPics 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 ) &&
( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) &&
( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt );
}
- bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( EncodeH265SliceSegmentLongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP;
- uint8_t sps_video_parameter_set_id = {};
- uint8_t pps_seq_parameter_set_id = {};
- uint8_t pps_pic_parameter_set_id = {};
- uint8_t short_term_ref_pic_set_idx = {};
- int32_t PicOrderCntVal = {};
- uint8_t TemporalId = {};
- VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {};
- const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {};
- const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {};
- const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {};
+ uint8_t sps_video_parameter_set_id = {};
+ uint8_t pps_seq_parameter_set_id = {};
+ uint8_t pps_pic_parameter_set_id = {};
+ uint8_t short_term_ref_pic_set_idx = {};
+ int32_t PicOrderCntVal = {};
+ uint8_t TemporalId = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {};
+ const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {};
+ const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {};
+ const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentLongTermRefPics * pLongTermRefPics = {};
};
struct EncodeH265ReferenceInfoFlags
# elif defined( __APPLE__ )
m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
# elif defined( _WIN32 )
- m_library = ::LoadLibraryA( "vulkan-1.dll" );
+ m_library = ::LoadLibraryA( "vulkan-1.dll" );
# else
# error unsupported platform
# endif
eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR,
eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR,
eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR,
- ePrivateVendorInfoPlaceholderOffset0NV = VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_PLACEHOLDER_OFFSET_0_NV,
+ ePrivateVendorInfoReservedOffset0NV = VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_RESERVED_OFFSET_0_NV,
ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT,
eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR";
case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR";
case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR";
- case StructureType::ePrivateVendorInfoPlaceholderOffset0NV: return "PrivateVendorInfoPlaceholderOffset0NV";
+ case StructureType::ePrivateVendorInfoReservedOffset0NV: return "PrivateVendorInfoReservedOffset0NV";
case StructureType::eImageViewAstcDecodeModeEXT: return "ImageViewAstcDecodeModeEXT";
case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT: return "PhysicalDeviceAstcDecodeFeaturesEXT";
case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR";
projects / platform / upstream / Vulkan-Hpp.git / commitdiff