TheCloud/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2025-09-08 11:27:25 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add support for vulkan_video.cppm module (#2162)

Browse Source 
* Add support for vulkan_video.cppm module

Fix #2151

* Add a module version for the Video test

Currently this add vulkan_video.cppm to the VulkanHppModule target,
which might not be what we want (maybe guard this by an option(), or add
another target like VulkanVideoHppModule, etc.).

* Add a separate target for `vulkan_video.cppm`

* Extract common logic to `vulkan_hpp__setup_module`

* Fix several CMakeLists.txt issues

- Add `vulkan_video.cppm` to `VK_GENERATED_VULKAN_HEADERS`.
- Remove unnecessary ${ARGN} quotes.
- Move version checks out of `vulkan_hpp__setup_module`.
- Separate `FILE_SET_NAME` from `FILE_SET`.
This commit is contained in:
btmxh 2025-05-15 23:11:27 +07:00 committed by GitHub
parent 54cc539ab5
commit d5b553d969
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 379 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
CMakeLists.txt
View File

@ -283,31 +283,65 @@ endif()
# Build Vulkan-Hpp as a module
if( VULKAN_HPP_ENABLE_CPP20_MODULES )
if( VULKAN_HPP_ENABLE_STD_MODULE AND CMAKE_VERSION VERSION_LESS "3.30" )
if ( VULKAN_HPP_ENABLE_STD_MODULE AND CMAKE_VERSION VERSION_LESS "3.30" )
message( FATAL_ERROR "Vulkan-Hpp: C++20 modules with import std require CMake 3.30 or later" )
elseif ( CMAKE_VERSION VERSION_LESS "3.28" )
message( FATAL_ERROR "Vulkan-Hpp: C++20 modules require CMake 3.28 or later" )
endif()
# create a target to provide VulkanHpp as C++20 module
add_library( VulkanHppModule )
add_library( Vulkan::HppModule ALIAS VulkanHppModule )
# Clang 16's module support can be broken with extensions enabled
if ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "16.0" )
set_target_properties( VulkanHppModule PROPERTIES CXX_EXTENSIONS OFF )
endif()
if( VULKAN_HPP_ENABLE_STD_MODULE )
target_compile_features( VulkanHppModule PUBLIC cxx_std_23 )
set_target_properties( VulkanHppModule PROPERTIES CXX_MODULE_STD ON )
else()
target_compile_features( VulkanHppModule PUBLIC cxx_std_20 )
endif()
target_sources( VulkanHppModule PUBLIC
FILE_SET vulkan_module_file
BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}
TYPE CXX_MODULES
FILES vulkan/vulkan.cppm )
target_link_libraries( VulkanHppModule PUBLIC Vulkan::Hpp )
function ( vulkan_hpp__setup_module )
set( options )
set( oneValueArgs NAME FILE_SET_NAME )
set( multiValueArgs FILE_SET ALIAS )
cmake_parse_arguments( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
if ( NOT TARGET_NAME )
message( FATAL_ERROR "NAME must be defined in vulkan_hpp__setup_module" )
endif()
add_library( ${TARGET_NAME} )
foreach( TARGET_ALIAS_NAME IN LISTS TARGET_ALIAS )
add_library(${TARGET_ALIAS_NAME} ALIAS ${TARGET_NAME})
endforeach()
# Clang 16's module support can be broken with extensions enabled
if ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "16.0" )
set_target_properties( ${TARGET_NAME} PROPERTIES CXX_EXTENSIONS OFF )
endif()
if ( VULKAN_HPP_ENABLE_STD_MODULE )
target_compile_features( ${TARGET_NAME} PUBLIC cxx_std_23 )
set_target_properties( ${TARGET_NAME} PROPERTIES CXX_MODULE_STD ON )
else()
target_compile_features( ${TARGET_NAME} PUBLIC cxx_std_20 )
endif()
if ( NOT TARGET_FILE_SET )
message( FATAL_ERROR "FILE_SET must be defined in vulkan_hpp__setup_module" )
endif()
list(LENGTH TARGET_FILE_SET TARGET_FILE_SET_LENGTH)
if ( TARGET_FILE_SET_LENGTH LESS 1 )
message(FATAL_ERROR "FILE_SET in vulkan_hpp__setup_module must at least one source file")
endif()
target_sources( ${TARGET_NAME} PUBLIC
FILE_SET ${TARGET_FILE_SET_NAME}
BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}
TYPE CXX_MODULES
FILES ${TARGET_FILE_SET} )
target_link_libraries( ${TARGET_NAME} PUBLIC Vulkan::Hpp )
endfunction()
# create targets providing VulkanHpp and VulkanVideoHpp as C++20 modules
vulkan_hpp__setup_module( NAME VulkanHppModule
FILE_SET_NAME vulkan_module_file
FILE_SET vulkan/vulkan.cppm
ALIAS Vulkan::HppModule )
vulkan_hpp__setup_module( NAME VulkanVideoHppModule
FILE_SET_NAME vulkan_video_module_file
FILE_SET vulkan/vulkan_video.cppm
ALIAS Vulkan::VideoHppModule )
endif()
function( vulkan_hpp__setup_platform )
@ -569,6 +603,7 @@ if( ${VULKAN_HPP_INSTALL} )
${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_to_string.hpp
${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_video.hpp
${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan.cppm
${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan_video.cppm
${VulkanHeaders_INCLUDE_DIR}/vulkan/vulkan.hpp
)
install( FILES ${VK_GENERATED_VULKAN_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/vulkan )

104
VideoHppGenerator.cpp
View File

@ -81,6 +81,42 @@ ${structs}
writeToFile( str, video_hpp );
}
void VideoHppGenerator::generateCppModuleFile() const
{
std::string const vulkan_video_cppm = std::string( BASE_PATH ) + "/vulkan/vulkan_video.cppm";
messager.message( "VideoHppGenerator: Generating " + vulkan_video_cppm + " ...\n" );
std::string const videoCppmTemplate = R"(${copyrightMessage}
// Note: This module is still in an experimental state.
// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
module;
#include <vulkan/vulkan_hpp_macros.hpp>
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
#define VULKAN_HPP_ENABLE_STD_MODULE
#endif
#include <vulkan/vulkan_video.hpp>
export module vulkan_video_hpp;
export namespace VULKAN_HPP_NAMESPACE
{
namespace VULKAN_HPP_VIDEO_NAMESPACE
{
${usings}
} // namespace VULKAN_HPP_VIDEO_NAMESPACE
} // namespace VULKAN_HPP_NAMESPACE
)";
std::string str = replaceWithMap( videoCppmTemplate, { { "copyrightMessage", m_copyrightMessage }, { "usings", generateCppModuleUsings() } } );
writeToFile( str, vulkan_video_cppm );
}
void VideoHppGenerator::addImplicitlyRequiredTypes()
{
for ( auto & ext : m_extensions )
@ -280,6 +316,37 @@ std::string VideoHppGenerator::generateEnums( RequireData const & requireData, s
return str;
}
std::string VideoHppGenerator::generateCppModuleEnumUsings() const
{
auto const usingTemplate = std::string{
R"( using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::${enumName};
)"
};
const std::string enumsTemplate = R"(
//=============
//=== ENUMs ===
//=============
${enums}
)";
std::string enums;
for ( auto const & extension : m_extensions )
{
for ( auto const & type : extension.requireData.types )
{
auto enumIt = m_enums.find( type );
if ( enumIt != m_enums.end() )
{
enums += replaceWithMap( usingTemplate, { { "enumName", stripPrefix( enumIt->first, "StdVideo" ) } } );
}
}
}
return replaceWithMap( enumsTemplate, { { "enums", enums } } );
}
std::string VideoHppGenerator::generateStruct( std::pair<std::string, StructureData> const & structData ) const
{
static const std::string structureTemplate = R"( struct ${structureType}
@ -449,6 +516,42 @@ std::string VideoHppGenerator::generateStructs( RequireData const & requireData,
return str;
}
std::string VideoHppGenerator::generateCppModuleStructUsings() const
{
auto const usingTemplate = std::string{
R"( using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::${structName};
)"
};
const std::string structsTemplate = R"(
//===============
//=== STRUCTS ===
//===============
${structs}
)";
std::string structs;
for ( auto const & extension : m_extensions )
{
for ( auto const & type : extension.requireData.types )
{
auto structIt = m_structs.find( type );
if ( structIt != m_structs.end() )
{
structs += replaceWithMap( usingTemplate, { { "structName", stripPrefix( structIt->first, "StdVideo" ) } } );
}
}
}
return replaceWithMap( structsTemplate, { { "structs", structs } } );
}
std::string VideoHppGenerator::generateCppModuleUsings() const
{
return generateCppModuleEnumUsings() + generateCppModuleStructUsings();
}
bool VideoHppGenerator::isExtension( std::string const & name ) const
{
return std::ranges::any_of( m_extensions, [&name]( ExtensionData const & ed ) { return ed.name == name; } );
@ -1059,6 +1162,7 @@ int main( int argc, char ** argv )
VideoHppGenerator generator( doc );
generator.generateHppFile();
generator.generateCppModuleFile();
#if !defined( CLANG_FORMAT_EXECUTABLE )
std::cout << "VideoHppGenerator: could not find clang-format. The generated files will not be formatted accordingly.\n";

4
VideoHppGenerator.hpp
View File

@ -26,6 +26,7 @@ public:
VideoHppGenerator( tinyxml2::XMLDocument const & document );
void generateHppFile() const;
void generateCppModuleFile() const;
private:
struct ConstantData
@ -108,6 +109,9 @@ private:
std::string generateStructMembers( std::pair<std::string, StructureData> const & structData ) const;
std::string generateStructs() const;
std::string generateStructs( RequireData const & requireData, std::string const & title ) const;
std::string generateCppModuleEnumUsings() const;
std::string generateCppModuleStructUsings() const;
std::string generateCppModuleUsings() const;
bool isExtension( std::string const & name ) const;
std::string readComment( tinyxml2::XMLElement const * element ) const;
void readEnums( tinyxml2::XMLElement const * element );

3
tests/CMakeLists.txt
View File

@ -47,3 +47,6 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
add_subdirectory( UniqueHandleDefaultArguments )
endif()
add_subdirectory( Video )
if( VULKAN_HPP_ENABLE_CPP20_MODULES )
add_subdirectory( VideoCpp20Modules )
endif()

16
tests/VideoCpp20Modules/CMakeLists.txt Normal file
View File

@ -0,0 +1,16 @@
# Copyright(c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
vulkan_hpp__setup_test( NAME VideoCpp20Modules CXX_STANDARD 20 LIBRARIES VulkanVideoHppModule NO_UTILS )
set_target_properties( VideoCpp20Modules PROPERTIES CXX_SCAN_FOR_MODULES ON )

40
tests/VideoCpp20Modules/VideoCpp20Modules.cpp Normal file
View File

@ -0,0 +1,40 @@
// Copyright(c) 2024, NVIDIA CORPORATION. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// VulkanHpp Samples : Video
// Compile test on using vk::video
#if defined( _MSC_VER )
# pragma warning( disable : 4101 ) // 'name': unreference local variable
#elif defined( __clang__ )
# pragma clang diagnostic ignored "-Wunused-variable"
#elif defined( __GNUC__ )
# pragma GCC diagnostic ignored "-Wunused-variable"
#else
// unknown compiler... just ignore the warnings for yourselves ;)
#endif
import vulkan_video_hpp;
int main( int /*argc*/, char ** /*argv*/ )
{
vk::video::H264ChromaFormatIdc x;
vk::video::H264ProfileIdc y;
#if ( 301 < VK_HEADER_VERSION )
vk::video::EncodeAV1DecoderModelInfo z;
#endif
return 0;
}

157
vulkan/vulkan_video.cppm Normal file
View File

@ -0,0 +1,157 @@
// Copyright 2021-2025 The Khronos Group Inc.
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
// This header is generated from the Khronos Vulkan XML API Registry.
// Note: This module is still in an experimental state.
// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
module;
#include <vulkan/vulkan_hpp_macros.hpp>
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
# define VULKAN_HPP_ENABLE_STD_MODULE
#endif
#include <vulkan/vulkan_video.hpp>
export module vulkan_video_hpp;
export namespace VULKAN_HPP_NAMESPACE
{
namespace VULKAN_HPP_VIDEO_NAMESPACE
{
//=============
//=== ENUMs ===
//=============
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType;
//===============
//=== STRUCTS ===
//===============
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags;
} // namespace VULKAN_HPP_VIDEO_NAMESPACE
} // namespace VULKAN_HPP_NAMESPACE