2020-03-20 04:12:25 +08:00
# Copyright(c) 2015-2018, NVIDIA CORPORATION. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of NVIDIA CORPORATION nor the names of its
# contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2025-01-21 15:21:10 +08:00
cmake_minimum_required ( VERSION 3.12 )
project ( VulkanHppGenerator LANGUAGES CXX )
if ( CMAKE_VERSION VERSION_LESS "3.21" )
# https://cmake.org/cmake/help/latest/variable/PROJECT_IS_TOP_LEVEL.html
string ( COMPARE EQUAL ${ CMAKE_CURRENT_SOURCE_DIR } ${ CMAKE_SOURCE_DIR } PROJECT_IS_TOP_LEVEL )
endif ( )
if ( PROJECT_IS_TOP_LEVEL )
2023-12-14 04:56:00 +08:00
set ( CMAKE_CXX_STANDARD 11 )
endif ( )
2023-10-18 14:07:18 +08:00
# all the options for this project
option ( VULKAN_HPP_PRECOMPILE "Precompile vulkan.hpp and vulkan_raii.hpp for sample builds" ON )
option ( VULKAN_HPP_RUN_GENERATOR "Run the HPP generator" OFF )
2025-01-21 15:21:10 +08:00
option ( VULKAN_HPP_GENERATOR_BUILD "Build the HPP generator" ${ PROJECT_IS_TOP_LEVEL } )
2023-10-18 14:07:18 +08:00
option ( VULKAN_HPP_SAMPLES_BUILD "Build samples" OFF )
option ( VULKAN_HPP_TESTS_BUILD "Build tests" OFF )
option ( VULKAN_HPP_SAMPLES_BUILD_ONLY_DYNAMIC "Build only dynamic. Required in case the Vulkan SDK is not available" OFF )
option ( VULKAN_HPP_TESTS_BUILD_ONLY_DYNAMIC "Build only dynamic" OFF )
option ( VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP "Build with local Vulkan headers" ON )
option ( VULKAN_HPP_ENABLE_CPP20_MODULES "Build Vulkan-Hpp as C++20 module; requires minimum CMake version 3.28" OFF )
2024-09-05 14:48:19 +08:00
option ( VULKAN_HPP_ENABLE_STD_MODULE "Build Vulkan-Hpp with import std; requires minimum CMake version 3.30" OFF )
2025-02-13 14:56:23 +08:00
# options for vulkan hpp compile definitions (see https://github.com/KhronosGroup/Vulkan-Hpp/tree/main?tab=readme-ov-file#configuration-options for details)
option ( VULKAN_HPP_DISABLE_ENHANCED_MODE "Disable all enhanced functionality apart from scoped enums, bitmasks, default initialization and vk::StructureChain" OFF )
option ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC "Select the dynamic (ON) or static (OFF) dispatch loader (defaults to VK_NO_PROTOTYPES)" ${ VK_NO_PROTOTYPES } )
option ( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC "Change the m_mask access modifier in vk::Flags to public" OFF )
option ( VULKAN_HPP_HANDLES_MOVE_EXCHANGE "Enable 'm_handle = exchange( rhs.m_handle, {} )' in move constructors" OFF )
option ( VULKAN_HPP_NO_CONSTRUCTORS "Remove constructors from structs and unions to enable C++20 designated initializers" OFF )
option ( VULKAN_HPP_NO_EXCEPTIONS "Do not throw exceptions when vulkan functions return an error code" OFF )
option ( VULKAN_HPP_NO_NODISCARD_WARNINGS "Remove C++17 [[nodiscard]] from function signatures that return something" OFF )
option ( VULKAN_HPP_NO_SETTERS "Remove setters for structs and unions" OFF )
option ( VULKAN_HPP_NO_SMART_HANDLE "Remove the vk::UniqueHandle helper class" OFF )
option ( VULKAN_HPP_NO_SPACESHIP_OPERATOR "Remove the C++20 <=> (spaceship) operator" OFF )
option ( VULKAN_HPP_NO_TO_STRING "Remove inclusion of vulkan_to_string.hpp from vulkan.hpp" OFF )
option ( VULKAN_HPP_NO_WIN32_PROTOTYPES "Remove HINSTANCE, LoadLibraryA and other symbols, which are declared if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL is enabled on Win32" OFF )
option ( VULKAN_HPP_RAII_NO_EXCEPTIONS "Do not throw exceptions when vulkan functions from vk::raii return an error code." OFF )
option ( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST "Enable implicit casts from vk::UniqueHandle and vk::SharedHandle to their matching vk::Handle" OFF )
option ( VULKAN_HPP_TYPESAFE_CONVERSION "Enable copy constructors for non-dispatchable handles" ON )
option ( VULKAN_HPP_USE_REFLECT "Adds reflect function to structures, which returns an iterable tuple" OFF )
# manually set VK_NO_PROTOTYPES if undefined
if ( NOT DEFINED VK_NO_PROTOTYPES )
set ( VK_NO_PROTOTYPES ${ VULKAN_HPP_DISPATCH_LOADER_DYNAMIC } )
endif ( )
2023-10-18 14:07:18 +08:00
2025-01-23 20:52:14 +08:00
function ( vulkan_hpp__setup_warning_level )
set ( options )
set ( oneValueArgs NAME )
set ( multiValueArgs )
cmake_parse_arguments ( TARGET "{options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
if ( MSVC )
target_compile_options ( ${ TARGET_NAME } PRIVATE /W4 /WX )
if ( MSVC_VER GREATER_EQUAL 1910 )
target_compile_options ( ${ TARGET_NAME } PRIVATE /permissive- )
endif ( )
else ( )
target_compile_options ( ${ TARGET_NAME } PRIVATE -Wall -Wextra -pedantic -Werror )
endif ( )
endfunction ( )
# Build Vulkan-Hpp and Video-Hpp generators
if ( VULKAN_HPP_GENERATOR_BUILD )
set_property ( GLOBAL PROPERTY USE_FOLDERS ON )
2025-04-03 19:25:12 +08:00
# look for the file vk.xml, the ultimate source of truth for vulkan, to generate the headers from
if ( NOT DEFINED VulkanRegistry_DIR )
if ( DEFINED VULKAN_HPP_VULKAN_HEADERS_SRC_DIR )
set ( VulkanRegistry_DIR "${VULKAN_HPP_VULKAN_HEADERS_SRC_DIR}/registry" )
else ( )
set ( VulkanRegistry_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Vulkan-Headers/registry" )
endif ( )
endif ( )
file ( TO_NATIVE_PATH ${ VulkanRegistry_DIR } /vk.xml vk_spec )
string ( REPLACE "\\" "\\\\" vk_spec ${ vk_spec } )
# gather the tinyxml2 sources, to be used directly in the generator project
if ( NOT DEFINED VULKAN_HPP_TINYXML2_SRC_DIR )
set ( VULKAN_HPP_TINYXML2_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tinyxml2" )
endif ( )
set ( TINYXML2_SOURCES ${ VULKAN_HPP_TINYXML2_SRC_DIR } /tinyxml2.cpp )
set ( TINYXML2_HEADERS ${ VULKAN_HPP_TINYXML2_SRC_DIR } /tinyxml2.h )
source_group ( TinyXML2 FILES ${ TINYXML2_HEADERS } ${ TINYXML2_SOURCES } )
# The generator executable
add_executable ( VulkanHppGenerator VulkanHppGenerator.cpp VulkanHppGenerator.hpp XMLHelper.hpp ${ TINYXML2_SOURCES } ${ TINYXML2_HEADERS } )
vulkan_hpp__setup_warning_level ( NAME VulkanHppGenerator )
target_compile_definitions ( VulkanHppGenerator PUBLIC BASE_PATH= "${CMAKE_CURRENT_SOURCE_DIR}" VK_SPEC= "${vk_spec}" )
target_include_directories ( VulkanHppGenerator PRIVATE ${ VULKAN_HPP_TINYXML2_SRC_DIR } )
set_target_properties ( VulkanHppGenerator PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON )
if ( UNIX )
target_link_libraries ( VulkanHppGenerator PUBLIC pthread )
endif ( )
# The video generator executable
add_executable ( VideoHppGenerator VideoHppGenerator.cpp VideoHppGenerator.hpp XMLHelper.hpp ${ TINYXML2_SOURCES } ${ TINYXML2_HEADERS } )
vulkan_hpp__setup_warning_level ( NAME VideoHppGenerator )
file ( TO_NATIVE_PATH ${ VulkanRegistry_DIR } /video.xml video_spec )
string ( REPLACE "\\" "\\\\" video_spec ${ video_spec } )
target_compile_definitions ( VideoHppGenerator PUBLIC BASE_PATH= "${CMAKE_CURRENT_SOURCE_DIR}" VIDEO_SPEC= "${video_spec}" )
target_include_directories ( VideoHppGenerator PRIVATE ${ VULKAN_HPP_TINYXML2_SRC_DIR } )
set_target_properties ( VideoHppGenerator PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON )
2025-01-23 20:52:14 +08:00
# find a clang-format version to format the generated header files
find_program ( CLANG_FORMAT_EXECUTABLE NAMES clang-format )
if ( CLANG_FORMAT_EXECUTABLE )
# get the clang-format version string
execute_process ( COMMAND ${ CLANG_FORMAT_EXECUTABLE } "--version" OUTPUT_VARIABLE clangFormatVersion )
# filter out the actual version
string ( REGEX MATCH [0123456789.]+ clangFormatVersion "${clangFormatVersion}" )
# we need at least version 7.0.0 !
if ( clangFormatVersion VERSION_LESS 7.0.0 )
message ( WARNING " Found too old clang-format version <" ${ clangFormatVersion } ">, we need version 7 and up to nicely format vulkan.hpp and vulkan_raii.hpp" )
else ( )
message ( STATUS " Found clang-format version <" ${ clangFormatVersion } ">." )
if ( clangFormatVersion VERSION_LESS 11.0.0 )
message ( STATUS " Using .clang-format version 7." )
file ( READ ".clang-format_7" clangFormat )
elseif ( clangFormatVersion VERSION_LESS 12.0.0 )
message ( STATUS " Using .clang-format version 11." )
file ( READ ".clang-format_11" clangFormat )
elseif ( clangFormatVersion VERSION_LESS 13.0.0 )
message ( STATUS " Using .clang-format version 12." )
file ( READ ".clang-format_12" clangFormat )
elseif ( clangFormatVersion VERSION_LESS 14.0.0 )
message ( STATUS " Using .clang-format version 13." )
file ( READ ".clang-format_13" clangFormat )
elseif ( clangFormatVersion VERSION_LESS 15.0.0 )
message ( STATUS " Using .clang-format version 14." )
file ( READ ".clang-format_14" clangFormat )
2025-02-05 20:44:36 +08:00
elseif ( clangFormatVersion VERSION_LESS 16.0.0 )
message ( STATUS " Using .clang-format version 15." )
2025-01-23 20:52:14 +08:00
file ( READ ".clang-format_15" clangFormat )
2025-02-06 20:20:09 +08:00
elseif ( clangFormatVersion VERSION_LESS 17.0.0 )
message ( STATUS " Using .clang-format version 16." )
2025-02-05 20:44:36 +08:00
file ( READ ".clang-format_16" clangFormat )
2025-02-07 00:14:29 +08:00
elseif ( clangFormatVersion VERSION_LESS 18.0.0 )
message ( STATUS " Using .clang-format version 17." )
2025-02-06 20:20:09 +08:00
file ( READ ".clang-format_17" clangFormat )
2025-02-07 00:14:29 +08:00
else ( )
message ( STATUS " Using .clang-format version 18." )
file ( READ ".clang-format_18" clangFormat )
2025-01-23 20:52:14 +08:00
endif ( )
file ( WRITE ".clang-format" ${ clangFormat } )
2025-04-03 19:25:12 +08:00
target_compile_definitions ( VulkanHppGenerator PUBLIC CLANG_FORMAT_EXECUTABLE= "${CLANG_FORMAT_EXECUTABLE}" )
target_compile_definitions ( VideoHppGenerator PUBLIC CLANG_FORMAT_EXECUTABLE= "${CLANG_FORMAT_EXECUTABLE}" )
2025-01-23 20:52:14 +08:00
endif ( )
else ( )
message ( WARNING " Could not find clang-format. Generated vulkan.hpp and vulkan_raii.hpp will not be nicely formatted." )
endif ( )
endif ( )
# if the generators are to be run, add a custom commands and targets
if ( VULKAN_HPP_RUN_GENERATOR )
if ( NOT DEFINED VulkanHeaders_INCLUDE_DIR )
if ( DEFINED VULKAN_HPP_PATH )
set ( VulkanHeaders_INCLUDE_DIR ${ VULKAN_HPP_PATH } )
else ( )
set ( VulkanHeaders_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" )
endif ( )
endif ( )
file ( TO_NATIVE_PATH ${ VulkanHeaders_INCLUDE_DIR } /vulkan/vulkan.hpp vulkan_hpp )
string ( REPLACE "\\" "\\\\" vulkan_hpp ${ vulkan_hpp } )
add_custom_command (
C O M M A N D V u l k a n H p p G e n e r a t o r
O U T P U T " $ { v u l k a n _ h p p } "
W O R K I N G _ D I R E C T O R Y " $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } "
C O M M E N T " r u n V u l k a n H p p G e n e r a t o r "
D E P E N D S V u l k a n H p p G e n e r a t o r " $ { v k _ s p e c } " )
add_custom_target ( build_vulkan_hpp ALL DEPENDS "${vulkan_hpp}" "${vk_spec}" )
file ( TO_NATIVE_PATH ${ VulkanHeaders_INCLUDE_DIR } /vulkan/vulkan_video.hpp vulkan_video_hpp )
string ( REPLACE "\\" "\\\\" vulkan_video_hpp ${ vulkan_video_hpp } )
add_custom_command (
C O M M A N D V i d e o H p p G e n e r a t o r
O U T P U T " $ { v u l k a n _ v i d e o _ h p p } "
W O R K I N G _ D I R E C T O R Y " $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } "
C O M M E N T " r u n V i d e o H p p G e n e r a t o r "
D E P E N D S V i d e o H p p G e n e r a t o r " $ { v i d e o _ s p e c } " )
add_custom_target ( build_video_hpp ALL DEPENDS "${vulkan_video_hpp}" "${video_spec}" )
endif ( )
# Create Vulkan-Hpp interface target
add_library ( VulkanHpp INTERFACE )
add_library ( Vulkan::Hpp ALIAS VulkanHpp )
target_include_directories ( VulkanHpp INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}" )
if ( VULKAN_HPP_RUN_GENERATOR )
add_dependencies ( VulkanHpp build_vulkan_hpp build_video_hpp )
endif ( )
2025-02-13 14:56:23 +08:00
# set up compile definitions
if ( VULKAN_HPP_DISABLE_ENHANCED_MODE )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_DISABLE_ENHANCED_MODE" )
endif ( )
if ( VK_NO_PROTOTYPES )
target_compile_definitions ( VulkanHpp INTERFACE "VK_NO_PROTOTYPES" )
endif ( )
if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_DISPATCH_LOADER_DYNAMIC" )
2025-03-18 15:52:47 +08:00
if ( UNIX )
2025-03-19 15:25:41 +08:00
target_link_libraries ( VulkanHpp INTERFACE ${ CMAKE_DL_LIBS } )
2025-03-18 15:52:47 +08:00
endif ( )
2025-02-13 14:56:23 +08:00
else ( )
find_package ( Vulkan )
if ( Vulkan_FOUND )
target_link_libraries ( VulkanHpp INTERFACE ${ Vulkan_LIBRARIES } )
else ( )
message ( WARNING "Could not link to vulkan-1 libraries, consider using VULKAN_HPP_DISPATCH_LOADER_DYNAMIC" )
endif ( )
endif ( )
if ( VULKAN_HPP_USE_REFLECT )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_USE_REFLECT" )
endif ( )
if ( NOT VULKAN_HPP_TYPESAFE_CONVERSION )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_TYPESAFE_CONVERSION=0" )
endif ( )
if ( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_HANDLES_MOVE_EXCHANGE" )
endif ( )
if ( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC" )
endif ( )
if ( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST" )
endif ( )
if ( VULKAN_HPP_NO_SETTERS )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_SETTERS" )
endif ( )
if ( VULKAN_HPP_NO_TO_STRING )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_TO_STRING" )
endif ( )
if ( VULKAN_HPP_NO_EXCEPTIONS )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_EXCEPTIONS" )
endif ( )
if ( VULKAN_HPP_NO_CONSTRUCTORS )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_CONSTRUCTORS" )
endif ( )
if ( VULKAN_HPP_NO_SMART_HANDLE )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_SMART_HANDLE" )
endif ( )
if ( VULKAN_HPP_RAII_NO_EXCEPTIONS )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_RAII_NO_EXCEPTIONS" )
endif ( )
if ( VULKAN_HPP_NO_WIN32_PROTOTYPES )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_WIN32_PROTOTYPES" )
endif ( )
if ( VULKAN_HPP_NO_NODISCARD_WARNINGS )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_NODISCARD_WARNINGS" )
endif ( )
if ( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
target_compile_definitions ( VulkanHpp INTERFACE "VULKAN_HPP_NO_SPACESHIP_OPERATOR" )
endif ( )
2025-01-23 20:52:14 +08:00
# Build Vulkan-Hpp as a module
2025-01-21 15:21:10 +08:00
if ( VULKAN_HPP_ENABLE_CPP20_MODULES )
2025-05-16 00:11:27 +08:00
if ( VULKAN_HPP_ENABLE_STD_MODULE AND CMAKE_VERSION VERSION_LESS "3.30" )
2025-01-21 15:21:10 +08:00
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 ( )
2025-01-23 20:52:14 +08:00
2025-05-16 00:11:27 +08:00
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
F I L E _ S E T $ { T A R G E T _ F I L E _ S E T _ N A M E }
B A S E _ D I R S $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R }
T Y P E C X X _ M O D U L E S
F I L E S $ { T A R G E T _ F I L E _ S E T } )
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
F I L E _ S E T _ N A M E v u l k a n _ m o d u l e _ f i l e
F I L E _ S E T v u l k a n / v u l k a n . c p p m
A L I A S V u l k a n : : H p p M o d u l e )
vulkan_hpp__setup_module ( NAME VulkanVideoHppModule
F I L E _ S E T _ N A M E v u l k a n _ v i d e o _ m o d u l e _ f i l e
F I L E _ S E T v u l k a n / v u l k a n _ v i d e o . c p p m
A L I A S V u l k a n : : V i d e o H p p M o d u l e )
2023-06-28 20:10:51 +08:00
endif ( )
2020-03-20 04:12:25 +08:00
2023-04-20 22:50:26 +08:00
function ( vulkan_hpp__setup_platform )
set ( options )
set ( oneValueArgs NAME )
set ( multiValueArgs )
cmake_parse_arguments ( TARGET "{options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2023-06-28 20:10:51 +08:00
2023-04-20 22:50:26 +08:00
if ( WIN32 )
2024-06-17 20:51:12 +08:00
target_compile_definitions ( ${ TARGET_NAME } PUBLIC VK_USE_PLATFORM_WIN32_KHR )
2023-04-20 22:50:26 +08:00
elseif ( APPLE )
2024-06-19 15:04:07 +08:00
target_compile_definitions ( ${ TARGET_NAME } PUBLIC VK_USE_PLATFORM_METAL_EXT )
2023-04-20 22:50:26 +08:00
elseif ( UNIX )
target_compile_definitions ( ${ TARGET_NAME } PUBLIC VK_USE_PLATFORM_XCB_KHR )
else ( )
message ( FATAL_ERROR, "Vulkan-Hpp: unhandled platform!" )
endif ( )
2024-10-31 15:24:05 +08:00
if ( !MSVC )
target_compile_options ( ${ TARGET_NAME } PRIVATE -fno-strict-aliasing )
endif ( )
2023-04-20 22:50:26 +08:00
endfunction ( )
2020-03-20 04:12:25 +08:00
2023-05-08 17:54:57 +08:00
function ( vulkan_hpp__setup_vulkan_include )
set ( options )
set ( oneValueArgs NAME )
set ( multiValueArgs )
cmake_parse_arguments ( TARGET "{options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2023-06-20 20:43:35 +08:00
if ( VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP )
2025-02-24 16:13:43 +08:00
# Vulkan C++ headers
2025-01-23 20:52:14 +08:00
target_link_libraries ( ${ TARGET_NAME } PUBLIC Vulkan::Hpp )
2025-02-24 16:13:43 +08:00
# Vulkan C headers
if ( EXISTS "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/Vulkan-Headers/include" )
target_include_directories ( VulkanHpp INTERFACE "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/Vulkan-Headers/include" )
else ( )
message ( WARNING "Could not find vulkan C headers locally, pull the Vulkan-Headers submodule or disable VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP" )
endif ( )
2023-05-08 17:54:57 +08:00
else ( )
2025-02-24 16:13:43 +08:00
find_package ( Vulkan REQUIRED )
2023-05-08 17:54:57 +08:00
target_include_directories ( ${ TARGET_NAME } PUBLIC "${Vulkan_INCLUDE_DIRS}" )
endif ( )
endfunction ( )
2023-04-20 22:50:26 +08:00
function ( vulkan_hpp__setup_project )
set ( options )
set ( oneValueArgs NAME )
set ( multiValueArgs )
cmake_parse_arguments ( TARGET "{options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2020-03-20 04:12:25 +08:00
2023-04-20 22:50:26 +08:00
project ( ${ TARGET_NAME } LANGUAGES CXX )
endfunction ( )
2020-04-13 03:49:12 +08:00
2023-04-20 22:50:26 +08:00
function ( vulkan_hpp__setup_library )
set ( options SHARED )
2023-05-08 17:54:57 +08:00
set ( oneValueArgs FOLDER NAME )
2023-04-20 22:50:26 +08:00
set ( multiValueArgs HEADERS SOURCES )
cmake_parse_arguments ( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2023-06-28 20:10:51 +08:00
2023-04-20 22:50:26 +08:00
vulkan_hpp__setup_project ( NAME ${ TARGET_NAME } )
2023-06-28 20:10:51 +08:00
2023-04-20 22:50:26 +08:00
if ( "${TARGET_SOURCES}" STREQUAL "" )
add_library ( ${ TARGET_NAME } INTERFACE ${ TARGET_HEADERS } )
else ( )
if ( ${ TARGET_SHARED } )
add_library ( ${ TARGET_NAME } SHARED ${ TARGET_SOURCES } ${ TARGET_HEADERS } )
else ( )
add_library ( ${ TARGET_NAME } ${ TARGET_SOURCES } ${ TARGET_HEADERS } )
endif ( )
vulkan_hpp__setup_platform ( NAME ${ TARGET_NAME } )
2023-05-08 17:54:57 +08:00
vulkan_hpp__setup_vulkan_include ( NAME ${ TARGET_NAME } )
vulkan_hpp__setup_warning_level ( NAME ${ TARGET_NAME } )
set_target_properties ( ${ TARGET_NAME } PROPERTIES CXX_STANDARD_REQUIRED ON )
2023-04-20 22:50:26 +08:00
endif ( )
2023-05-08 17:54:57 +08:00
set_target_properties ( ${ TARGET_NAME } PROPERTIES FOLDER ${ TARGET_FOLDER } )
2023-04-20 22:50:26 +08:00
endfunction ( )
2020-04-13 03:49:12 +08:00
2023-04-20 22:50:26 +08:00
function ( vulkan_hpp__setup_sample )
set ( options )
set ( oneValueArgs FOLDER NAME PCH_REUSE )
2025-07-01 21:59:53 +08:00
set ( multiValueArgs HEADERS LIBS PCH SOURCES )
2023-04-20 22:50:26 +08:00
cmake_parse_arguments ( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2023-06-20 20:43:35 +08:00
if ( NOT ( VULKAN_HPP_SAMPLES_BUILD_ONLY_DYNAMIC AND VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP ) )
2023-05-08 17:54:57 +08:00
find_package ( Vulkan REQUIRED )
endif ( )
2023-04-20 22:50:26 +08:00
vulkan_hpp__setup_project ( NAME ${ TARGET_NAME } )
add_executable ( ${ TARGET_NAME } ${ TARGET_HEADERS } ${ TARGET_SOURCES } )
2023-06-28 20:10:51 +08:00
2023-04-20 22:50:26 +08:00
vulkan_hpp__setup_platform ( NAME ${ TARGET_NAME } )
2023-05-08 17:54:57 +08:00
vulkan_hpp__setup_vulkan_include ( NAME ${ TARGET_NAME } )
vulkan_hpp__setup_warning_level ( NAME ${ TARGET_NAME } )
2023-04-20 22:50:26 +08:00
2023-12-14 04:56:00 +08:00
set_target_properties ( ${ TARGET_NAME } PROPERTIES CXX_STANDARD_REQUIRED ON )
2023-04-20 22:50:26 +08:00
if ( TARGET_FOLDER )
set_target_properties ( ${ TARGET_NAME } PROPERTIES FOLDER "${TARGET_FOLDER}" )
endif ( )
2023-06-28 20:10:51 +08:00
2023-04-20 22:50:26 +08:00
if ( TARGET_LIBS )
target_link_libraries ( ${ TARGET_NAME } PRIVATE "${TARGET_LIBS}" )
endif ( )
2023-06-28 20:10:51 +08:00
2023-04-20 22:50:26 +08:00
if ( VULKAN_HPP_PRECOMPILE )
if ( TARGET_PCH_REUSE )
target_precompile_headers ( ${ TARGET_NAME } REUSE_FROM "${TARGET_PCH_REUSE}" )
elseif ( TARGET_PCH )
target_precompile_headers ( ${ TARGET_NAME } PRIVATE "${TARGET_PCH}" )
endif ( )
endif ( )
endfunction ( )
2020-07-30 15:21:05 +08:00
2023-04-20 22:50:26 +08:00
function ( vulkan_hpp__setup_sample_static )
set ( options )
set ( oneValueArgs NAME )
set ( multiValueArgs )
cmake_parse_arguments ( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2020-03-20 04:12:25 +08:00
2023-05-08 17:54:57 +08:00
if ( NOT VULKAN_HPP_SAMPLES_BUILD_ONLY_DYNAMIC )
2023-04-20 22:50:26 +08:00
if ( NOT TARGET_NAME )
message ( FATAL_ERROR "NAME must be defined in vulkan_hpp__setup_sample_static" )
endif ( )
2020-03-20 04:12:25 +08:00
2023-04-20 22:50:26 +08:00
find_package ( Vulkan REQUIRED )
2020-03-20 04:12:25 +08:00
2023-04-20 22:50:26 +08:00
vulkan_hpp__setup_sample (
N A M E $ { T A R G E T _ N A M E }
F O L D E R S a m p l e s
P C H < v u l k a n / v u l k a n . h p p >
S O U R C E S $ { T A R G E T _ N A M E } . c p p
L I B S $ { V u l k a n _ L I B R A R I E S } )
2023-06-20 20:43:35 +08:00
target_compile_definitions ( ${ TARGET_NAME } PUBLIC VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=0 )
2023-04-20 22:50:26 +08:00
endif ( )
endfunction ( )
function ( vulkan_hpp__setup_sample_dynamic )
set ( options )
set ( oneValueArgs NAME )
2025-07-01 21:59:53 +08:00
set ( multiValueArgs HEADERS SOURCES )
2023-04-20 22:50:26 +08:00
cmake_parse_arguments ( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
if ( NOT TARGET_NAME )
message ( FATAL_ERROR "NAME must be defined in vulkan_hpp__setup_sample_dynamic" )
endif ( )
if ( NOT TARGET_SOURCES )
set ( TARGET_SOURCES ${ TARGET_NAME } .cpp )
endif ( )
vulkan_hpp__setup_sample (
N A M E $ { T A R G E T _ N A M E }
F O L D E R S a m p l e s
P C H _ R E U S E u t i l s
H E A D E R S $ { T A R G E T _ H E A D E R S }
S O U R C E S $ { T A R G E T _ S O U R C E S }
L I B S u t i l s )
endfunction ( )
function ( vulkan_hpp__setup_sample_raii )
set ( options )
set ( oneValueArgs NAME )
2025-07-01 21:59:53 +08:00
set ( multiValueArgs HEADERS SOURCES )
2023-04-20 22:50:26 +08:00
cmake_parse_arguments ( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
if ( NOT TARGET_NAME )
message ( FATAL_ERROR "NAME must be defined in vulkan_hpp__setup_sample_raii" )
endif ( )
if ( NOT TARGET_SOURCES )
set ( TARGET_SOURCES ${ TARGET_NAME } .cpp )
endif ( )
vulkan_hpp__setup_sample (
N A M E R A I I _ $ { T A R G E T _ N A M E }
F O L D E R R A I I _ S a m p l e s
P C H _ R E U S E u t i l s
H E A D E R S $ { T A R G E T _ H E A D E R S }
S O U R C E S $ { T A R G E T _ S O U R C E S }
L I B S u t i l s )
endfunction ( )
function ( vulkan_hpp__setup_test )
2023-09-07 21:20:10 +08:00
set ( options NO_UTILS )
2023-04-20 22:50:26 +08:00
set ( oneValueArgs CXX_STANDARD NAME )
2023-05-08 17:54:57 +08:00
set ( multiValueArgs LIBRARIES )
2023-04-20 22:50:26 +08:00
cmake_parse_arguments ( TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2023-06-20 20:43:35 +08:00
if ( NOT ( VULKAN_HPP_TESTS_BUILD_ONLY_DYNAMIC AND VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP ) )
2023-05-08 17:54:57 +08:00
find_package ( Vulkan REQUIRED )
endif ( )
2023-04-20 22:50:26 +08:00
if ( NOT TARGET_NAME )
message ( FATAL_ERROR "NAME must be defined in vulkan_hpp__setup_test" )
endif ( )
if ( NOT TARGET_CXX_STANDARD )
2023-12-14 04:56:00 +08:00
set ( TARGET_CXX_STANDARD ${ CMAKE_CXX_STANDARD } )
2023-04-20 22:50:26 +08:00
endif ( )
vulkan_hpp__setup_project ( NAME ${ TARGET_NAME } )
2020-03-20 04:12:25 +08:00
2023-04-20 22:50:26 +08:00
add_executable ( ${ TARGET_NAME } ${ TARGET_NAME } .cpp )
2023-06-28 20:10:51 +08:00
2023-04-20 22:50:26 +08:00
vulkan_hpp__setup_platform ( NAME ${ TARGET_NAME } )
2023-05-08 17:54:57 +08:00
vulkan_hpp__setup_vulkan_include ( NAME ${ TARGET_NAME } )
vulkan_hpp__setup_warning_level ( NAME ${ TARGET_NAME } )
2023-04-20 22:50:26 +08:00
2023-05-08 17:54:57 +08:00
set_target_properties ( ${ TARGET_NAME } PROPERTIES CXX_STANDARD ${ TARGET_CXX_STANDARD } CXX_STANDARD_REQUIRED ON FOLDER "Tests" )
2023-04-27 22:16:10 +08:00
target_include_directories ( ${ TARGET_NAME } PUBLIC ${ VulkanHeaders_INCLUDE_DIR } )
2023-10-09 22:05:13 +08:00
target_include_directories ( ${ TARGET_NAME } PUBLIC "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/glm" )
2023-09-07 21:20:10 +08:00
if ( NOT ${ TARGET_NO_UTILS } )
target_link_libraries ( ${ TARGET_NAME } PRIVATE utils )
endif ( )
target_link_libraries ( ${ TARGET_NAME } PRIVATE ${ TARGET_LIBRARIES } )
2023-04-20 22:50:26 +08:00
endfunction ( )
2025-03-18 20:47:01 +08:00
if ( VULKAN_HPP_SAMPLES_BUILD OR VULKAN_HPP_TESTS_BUILD )
2023-04-20 22:50:26 +08:00
# external libraries
add_subdirectory ( glm )
set ( GLFW_BUILD_EXAMPLES OFF )
set ( GLFW_BUILD_TESTS OFF )
add_subdirectory ( glfw )
2025-05-06 19:40:23 +08:00
set ( ENABLE_OPT OFF ) # could use ALLOW_EXTERNAL_SPIRV_TOOLS=ON instead
2023-04-20 22:50:26 +08:00
add_subdirectory ( glslang )
2025-03-18 20:47:01 +08:00
add_subdirectory ( samples/utils )
add_subdirectory ( RAII_Samples/utils )
endif ( )
if ( VULKAN_HPP_SAMPLES_BUILD )
2023-04-20 22:50:26 +08:00
# samples
add_subdirectory ( samples )
add_subdirectory ( RAII_Samples )
endif ( )
2022-08-10 17:19:06 +08:00
2023-04-27 22:16:10 +08:00
if ( VULKAN_HPP_TESTS_BUILD )
2023-04-20 22:50:26 +08:00
add_subdirectory ( tests )
endif ( )
2022-08-10 17:19:06 +08:00
2023-04-20 22:50:26 +08:00
if ( ${ VULKAN_HPP_INSTALL } )
include ( GNUInstallDirs )
2023-04-27 22:16:10 +08:00
set ( VK_GENERATED_VULKAN_HEADERS
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ e n u m s . h p p
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ f o r m a t _ t r a i t s . h p p
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ f u n c s . h p p
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ h a n d l e s . h p p
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ h a s h . h p p
2023-09-07 21:20:10 +08:00
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ h p p _ m a c r o s . h p p
2023-04-27 22:16:10 +08:00
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ r a i i . h p p
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ s t a t i c _ a s s e r t i o n s . h p p
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ s t r u c t s . h p p
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ t o _ s t r i n g . h p p
2024-02-06 22:11:31 +08:00
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ v i d e o . h p p
2023-06-28 20:10:51 +08:00
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n . c p p m
2025-05-16 00:11:27 +08:00
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n _ v i d e o . c p p m
2024-02-06 22:11:31 +08:00
$ { V u l k a n H e a d e r s _ I N C L U D E _ D I R } / v u l k a n / v u l k a n . h p p
2023-04-27 22:16:10 +08:00
)
2023-04-20 22:50:26 +08:00
install ( FILES ${ VK_GENERATED_VULKAN_HEADERS } DESTINATION ${ CMAKE_INSTALL_INCLUDEDIR } /vulkan )
2023-06-28 20:10:51 +08:00
endif ( )
