mirror of
https://github.com/KhronosGroup/Vulkan-Headers.git
synced 2025-04-07 22:19:11 +00:00
Compare commits
No commits in common. "main" and "v1.4.305" have entirely different histories.
34 changed files with 6118 additions and 46501 deletions
56
.github/workflows/ci.yml
vendored
56
.github/workflows/ci.yml
vendored
|
|
@ -21,7 +21,7 @@ jobs:
|
|||
strategy:
|
||||
matrix:
|
||||
os: [ ubuntu-latest, macos-latest ]
|
||||
cmake-version: [ '3.22.1', 'latest']
|
||||
cmake-version: [ '3.15', 'latest']
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: lukka/get-cmake@latest
|
||||
|
|
@ -39,7 +39,7 @@ jobs:
|
|||
if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
|
||||
strategy:
|
||||
matrix:
|
||||
cmake-version: [ '3.22.1', 'latest']
|
||||
cmake-version: [ '3.15', 'latest']
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: lukka/get-cmake@latest
|
||||
|
|
@ -74,58 +74,6 @@ jobs:
|
|||
- run: ctest --output-on-failure
|
||||
working-directory: build
|
||||
|
||||
cmake-unix-modules:
|
||||
runs-on: ${{ matrix.os }}
|
||||
if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
|
||||
strategy:
|
||||
matrix:
|
||||
os: [ ubuntu-latest ]
|
||||
cmake-version: [ 'latest' ]
|
||||
compiler: [ clang++-18 ]
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: lukka/get-cmake@latest
|
||||
with:
|
||||
cmakeVersion: ${{ matrix.cmake-version }}
|
||||
- uses: ilammy/msvc-dev-cmd@v1
|
||||
- run: |
|
||||
cmake -S . -B build \
|
||||
-D VULKAN_HEADERS_ENABLE_TESTS=ON \
|
||||
-D VULKAN_HEADERS_ENABLE_INSTALL=ON \
|
||||
-D VULKAN_HEADERS_ENABLE_MODULE=ON \
|
||||
-D VULKAN_HEADERS_ENABLE_MODULE_STD=OFF \
|
||||
-D CMAKE_CXX_COMPILER=${{ matrix.compiler }} \
|
||||
-G Ninja
|
||||
- run: cmake --build ./build
|
||||
- run: cmake --install build/ --prefix build/install
|
||||
- run: CXX=${{ matrix.compiler }} ctest --output-on-failure
|
||||
working-directory: build
|
||||
|
||||
cmake-windows-modules:
|
||||
runs-on: ${{ matrix.os }}
|
||||
if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
|
||||
strategy:
|
||||
matrix:
|
||||
os: [ windows-latest ]
|
||||
cmake-version: [ 'latest' ]
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: lukka/get-cmake@latest
|
||||
with:
|
||||
cmakeVersion: ${{ matrix.cmake-version }}
|
||||
- uses: ilammy/msvc-dev-cmd@v1
|
||||
- run: |
|
||||
cmake -S . -B build `
|
||||
-D VULKAN_HEADERS_ENABLE_TESTS=ON `
|
||||
-D VULKAN_HEADERS_ENABLE_INSTALL=ON `
|
||||
-D VULKAN_HEADERS_ENABLE_MODULE=ON `
|
||||
-D VULKAN_HEADERS_ENABLE_MODULE_STD=OFF `
|
||||
-G Ninja
|
||||
- run: cmake --build ./build
|
||||
- run: cmake --install build/ --prefix build/install
|
||||
- run: ctest --output-on-failure
|
||||
working-directory: build
|
||||
|
||||
reuse:
|
||||
runs-on: ubuntu-latest
|
||||
if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
|
||||
|
|
|
|||
5
BUILD.gn
5
BUILD.gn
|
|
@ -13,10 +13,7 @@ config("vulkan_headers_config") {
|
|||
defines += [ "VK_USE_PLATFORM_WIN32_KHR" ]
|
||||
}
|
||||
if (defined(vulkan_use_x11) && vulkan_use_x11) {
|
||||
defines += [
|
||||
"VK_USE_PLATFORM_XCB_KHR",
|
||||
"VK_USE_PLATFORM_XLIB_KHR",
|
||||
]
|
||||
defines += [ "VK_USE_PLATFORM_XCB_KHR" ]
|
||||
}
|
||||
if (defined(vulkan_use_wayland) && vulkan_use_wayland) {
|
||||
defines += [ "VK_USE_PLATFORM_WAYLAND_KHR" ]
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
#
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
# ~~~
|
||||
cmake_minimum_required(VERSION 3.22.1)
|
||||
cmake_minimum_required(VERSION 3.15)
|
||||
|
||||
# NOTE: Parsing the version like this is suboptimal but neccessary due to our release process:
|
||||
# https://github.com/KhronosGroup/Vulkan-Headers/pull/346
|
||||
|
|
@ -38,68 +38,48 @@ vlk_get_header_version()
|
|||
|
||||
project(VULKAN_HEADERS LANGUAGES C CXX VERSION ${VK_VERSION_STRING})
|
||||
|
||||
# options for Vulkan-Headers and the Vulkan-Hpp C++20 module
|
||||
option(VULKAN_HEADERS_ENABLE_TESTS "Test Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
|
||||
option(VULKAN_HEADERS_ENABLE_INSTALL "Install Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
|
||||
option(VULKAN_HEADERS_ENABLE_MODULE "Enables building of the Vulkan C++20 module; requires minimum CMake version 3.28" OFF)
|
||||
option(VULKAN_HEADERS_ENABLE_MODULE_STD "Enables building of the Vulkan C++20 module with import std; requires minimum CMake version 3.30" OFF)
|
||||
|
||||
# set up Vulkan-Headers
|
||||
add_library(Vulkan-Headers INTERFACE)
|
||||
add_library(Vulkan::Headers ALIAS Vulkan-Headers)
|
||||
target_include_directories(Vulkan-Headers INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
|
||||
|
||||
if (VULKAN_HEADERS_ENABLE_MODULE)
|
||||
# check for compiler support
|
||||
if ((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND (MSVC_VERSION GREATER_EQUAL "1941")) OR
|
||||
# clang-cl doesn't currently support modules
|
||||
(CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
|
||||
AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16.0"
|
||||
AND (NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "MSVC")
|
||||
AND (NOT CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS STREQUAL CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS-NOTFOUND)) OR
|
||||
(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0")
|
||||
)
|
||||
# check for CMake support
|
||||
if(VULKAN_HEADERS_ENABLE_MODULE_STD AND CMAKE_VERSION VERSION_LESS "3.30")
|
||||
message(FATAL_ERROR "Vulkan-Hpp: C++20 module with import std requires CMake 3.30 or later")
|
||||
elseif (CMAKE_VERSION VERSION_LESS "3.28")
|
||||
message(FATAL_ERROR "Vulkan-Hpp: C++20 module requires CMake 3.28 or later")
|
||||
endif()
|
||||
|
||||
# set up Vulkan-HppModule
|
||||
add_library(Vulkan-HppModule)
|
||||
add_library(Vulkan::HppModule ALIAS Vulkan-HppModule)
|
||||
target_sources(Vulkan-HppModule
|
||||
PUBLIC
|
||||
FILE_SET module
|
||||
TYPE CXX_MODULES
|
||||
FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/vulkan.cppm")
|
||||
if (VULKAN_HEADERS_ENABLE_MODULE_STD)
|
||||
target_compile_features(Vulkan-HppModule
|
||||
PRIVATE cxx_std_23
|
||||
INTERFACE cxx_std_20) # only C++20 is required to consume this module
|
||||
set_target_properties(Vulkan-HppModule PROPERTIES CXX_MODULE_STD ON)
|
||||
else()
|
||||
target_compile_features(Vulkan-HppModule PUBLIC cxx_std_20)
|
||||
endif()
|
||||
target_link_libraries(Vulkan-HppModule PUBLIC Vulkan::Headers)
|
||||
|
||||
# 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(Vulkan-HppModule PROPERTIES CXX_EXTENSIONS OFF)
|
||||
endif()
|
||||
|
||||
# set up fallback targets to notify about name deprecation
|
||||
add_library(Vulkan-Module INTERFACE)
|
||||
add_library(Vulkan::Module ALIAS Vulkan-Module)
|
||||
target_link_libraries(Vulkan-Module INTERFACE Vulkan::HppModule)
|
||||
set_target_properties(Vulkan-Module PROPERTIES
|
||||
DEPRECATION "The Vulkan-Module and Vulkan::Module targets have been deprecated by the Vulkan-HppModule and Vulkan::HppModule targets respectively and will be removed at a future date.")
|
||||
else()
|
||||
message(FATAL_ERROR "Vulkan-Hpp: C++20 module support is requested but was disabled due to lacking compiler support on this platform")
|
||||
endif()
|
||||
if ((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND (MSVC_VERSION GREATER_EQUAL "1941")) OR
|
||||
# clang-cl doesn't currently support modules
|
||||
(CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
|
||||
AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16.0"
|
||||
AND (NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "MSVC")
|
||||
AND (NOT CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS STREQUAL CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS-NOTFOUND)) OR
|
||||
(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0"))
|
||||
set(COMPILER_SUPPORTS_CXX_MODULES TRUE)
|
||||
endif()
|
||||
|
||||
option(VULKAN_HEADERS_ENABLE_MODULE "Enables building of the Vulkan C++ module" OFF)
|
||||
|
||||
if (VULKAN_HEADERS_ENABLE_MODULE AND (NOT COMPILER_SUPPORTS_CXX_MODULES OR CMAKE_VERSION VERSION_LESS "3.28"))
|
||||
message(WARNING "Vulkan C++ module support is requested but was disabled due to lacking support on this platform")
|
||||
endif()
|
||||
|
||||
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.28" AND VULKAN_HEADERS_ENABLE_MODULE AND COMPILER_SUPPORTS_CXX_MODULES)
|
||||
add_library(Vulkan-Module)
|
||||
add_library(Vulkan::VulkanHppModule ALIAS Vulkan-Module)
|
||||
target_sources(Vulkan-Module
|
||||
PUBLIC
|
||||
FILE_SET module
|
||||
TYPE CXX_MODULES
|
||||
BASE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/include"
|
||||
FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/vulkan.cppm"
|
||||
)
|
||||
target_compile_features(Vulkan-Module PUBLIC cxx_std_20)
|
||||
target_link_libraries(Vulkan-Module PUBLIC Vulkan-Headers)
|
||||
endif ()
|
||||
|
||||
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()
|
||||
|
||||
option(VULKAN_HEADERS_ENABLE_TESTS "Test Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
|
||||
option(VULKAN_HEADERS_ENABLE_INSTALL "Install Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
|
||||
|
||||
if (VULKAN_HEADERS_ENABLE_TESTS)
|
||||
enable_testing() # This is only effective in the top level CMakeLists.txt file.
|
||||
add_subdirectory(tests)
|
||||
|
|
|
|||
|
|
@ -57,7 +57,6 @@ update-headers:
|
|||
|
||||
# Top-level scripts / XML to install
|
||||
SCRIPTS = \
|
||||
$(SPEC)/scripts/base_generator.py \
|
||||
$(SPEC)/scripts/cgenerator.py \
|
||||
$(SPEC)/scripts/generator.py \
|
||||
$(SPEC)/scripts/parse_dependency.py \
|
||||
|
|
@ -65,7 +64,6 @@ SCRIPTS = \
|
|||
$(SPEC)/scripts/stripAPI.py \
|
||||
$(SPEC)/scripts/apiconventions.py \
|
||||
$(SPEC)/scripts/vkconventions.py \
|
||||
$(SPEC)/scripts/vulkan_object.py \
|
||||
$(SPEC)/xml/vk.xml \
|
||||
$(SPEC)/xml/video.xml \
|
||||
$(REGISTRY)/specs/latest/validation/validusage.json
|
||||
|
|
|
|||
|
|
@ -22,9 +22,7 @@ module;
|
|||
#include <vulkan/vulkan_hash.hpp>
|
||||
#include <vulkan/vulkan_raii.hpp>
|
||||
#include <vulkan/vulkan_shared.hpp>
|
||||
#ifndef VULKAN_HPP_NO_TO_STRING
|
||||
# include <vulkan/vulkan_to_string.hpp>
|
||||
#endif
|
||||
#include <vulkan/vulkan_to_string.hpp>
|
||||
|
||||
export module vulkan_hpp;
|
||||
|
||||
|
|
@ -753,10 +751,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV;
|
||||
|
||||
//=== VK_QCOM_tile_shading ===
|
||||
using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagBitsQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
//=== VK_EXT_metal_objects ===
|
||||
using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT;
|
||||
|
|
@ -841,10 +835,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsNV;
|
||||
|
||||
//=== VK_NV_ray_tracing_linear_swept_spheres ===
|
||||
using VULKAN_HPP_NAMESPACE::RayTracingLssIndexingModeNV;
|
||||
using VULKAN_HPP_NAMESPACE::RayTracingLssPrimitiveEndCapsModeNV;
|
||||
|
||||
//=== VK_EXT_subpass_merge_feedback ===
|
||||
using VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT;
|
||||
|
||||
|
|
@ -877,11 +867,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_NV_ray_tracing_invocation_reorder ===
|
||||
using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV;
|
||||
|
||||
//=== VK_NV_cooperative_vector ===
|
||||
using VULKAN_HPP_NAMESPACE::ComponentTypeKHR;
|
||||
using VULKAN_HPP_NAMESPACE::ComponentTypeNV;
|
||||
using VULKAN_HPP_NAMESPACE::CooperativeVectorMatrixLayoutNV;
|
||||
|
||||
//=== VK_EXT_layer_settings ===
|
||||
using VULKAN_HPP_NAMESPACE::LayerSettingTypeEXT;
|
||||
|
||||
|
|
@ -890,6 +875,8 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV;
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
using VULKAN_HPP_NAMESPACE::ComponentTypeKHR;
|
||||
using VULKAN_HPP_NAMESPACE::ComponentTypeNV;
|
||||
using VULKAN_HPP_NAMESPACE::ScopeKHR;
|
||||
using VULKAN_HPP_NAMESPACE::ScopeNV;
|
||||
|
||||
|
|
@ -924,24 +911,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_KHR_maintenance7 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR;
|
||||
|
||||
//=== VK_NV_cluster_acceleration_structure ===
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpModeNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpTypeNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTypeNV;
|
||||
|
||||
//=== VK_NV_partitioned_acceleration_structure ===
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagsNV;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureOpTypeNV;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagBitsEXT;
|
||||
using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagsEXT;
|
||||
|
|
@ -1559,10 +1528,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion;
|
||||
|
||||
//=== VK_KHR_shader_bfloat16 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion;
|
||||
|
||||
//=== VK_EXT_sample_locations ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion;
|
||||
|
|
@ -2096,10 +2061,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchSpecVersion;
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_QCOM_tile_shading ===
|
||||
using VULKAN_HPP_NAMESPACE::QCOMTileShadingExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::QCOMTileShadingSpecVersion;
|
||||
|
||||
//=== VK_NV_low_latency ===
|
||||
using VULKAN_HPP_NAMESPACE::NVLowLatencyExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVLowLatencySpecVersion;
|
||||
|
|
@ -2410,10 +2371,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeSpecVersion;
|
||||
|
||||
//=== VK_NV_ray_tracing_linear_swept_spheres ===
|
||||
using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresSpecVersion;
|
||||
|
||||
//=== VK_NV_linear_color_attachment ===
|
||||
using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentSpecVersion;
|
||||
|
|
@ -2518,10 +2475,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderSpecVersion;
|
||||
|
||||
//=== VK_NV_cooperative_vector ===
|
||||
using VULKAN_HPP_NAMESPACE::NVCooperativeVectorExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVCooperativeVectorSpecVersion;
|
||||
|
||||
//=== VK_NV_extended_sparse_address_space ===
|
||||
using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceSpecVersion;
|
||||
|
|
@ -2661,10 +2614,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueSpecVersion;
|
||||
|
||||
//=== VK_KHR_shader_relaxed_extended_instruction ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion;
|
||||
|
|
@ -2689,15 +2638,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion;
|
||||
|
||||
//=== VK_NV_cluster_acceleration_structure ===
|
||||
using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureSpecVersion;
|
||||
|
||||
//=== VK_NV_partitioned_acceleration_structure ===
|
||||
using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureSpecVersion;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructurePartitionIndexGlobalNV;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsSpecVersion;
|
||||
|
|
@ -2714,10 +2654,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion;
|
||||
|
||||
//=== VK_KHR_video_maintenance2 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2SpecVersion;
|
||||
|
||||
//=== VK_HUAWEI_hdr_vivid ===
|
||||
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion;
|
||||
|
|
@ -2730,12 +2666,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapSpecVersion;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
//=== VK_EXT_external_memory_metal ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalSpecVersion;
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
|
||||
//=== VK_KHR_depth_clamp_zero_one ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneSpecVersion;
|
||||
|
|
@ -2744,16 +2674,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion;
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_NV_present_metering ===
|
||||
using VULKAN_HPP_NAMESPACE::NVPresentMeteringExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_EXT_fragment_density_map_offset ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion;
|
||||
|
||||
//========================
|
||||
//=== CONSTEXPR VALUEs ===
|
||||
//========================
|
||||
|
|
@ -3743,9 +3663,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
|
||||
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;
|
||||
|
||||
//=== VK_KHR_shader_bfloat16 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR;
|
||||
|
||||
//=== VK_EXT_sample_locations ===
|
||||
using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
|
||||
using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
|
||||
|
|
@ -4144,14 +4061,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV;
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_QCOM_tile_shading ===
|
||||
using VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM;
|
||||
|
||||
//=== VK_NV_low_latency ===
|
||||
using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV;
|
||||
|
||||
|
|
@ -4433,6 +4342,11 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM;
|
||||
using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM;
|
||||
|
||||
//=== VK_QCOM_fragment_density_map_offset ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
|
||||
|
||||
//=== VK_NV_copy_memory_indirect ===
|
||||
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
|
||||
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
|
||||
|
|
@ -4450,11 +4364,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV;
|
||||
|
||||
//=== VK_NV_ray_tracing_linear_swept_spheres ===
|
||||
using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV;
|
||||
using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
|
||||
|
||||
//=== VK_NV_linear_color_attachment ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV;
|
||||
|
||||
|
|
@ -4565,12 +4474,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
|
||||
|
||||
//=== VK_NV_cooperative_vector ===
|
||||
using VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV;
|
||||
|
||||
//=== VK_NV_extended_sparse_address_space ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
|
||||
|
|
@ -4717,12 +4620,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_NV_raw_access_chains ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
using VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV;
|
||||
|
||||
//=== VK_KHR_shader_relaxed_extended_instruction ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
|
||||
|
||||
|
|
@ -4745,36 +4642,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_NV_ray_tracing_validation ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV;
|
||||
|
||||
//=== VK_NV_cluster_acceleration_structure ===
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV;
|
||||
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV;
|
||||
using VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV;
|
||||
|
||||
//=== VK_NV_partitioned_acceleration_structure ===
|
||||
using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV;
|
||||
using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV;
|
||||
using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV;
|
||||
using VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
using VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT;
|
||||
using VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT;
|
||||
|
|
@ -4814,12 +4681,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT;
|
||||
|
||||
//=== VK_KHR_video_maintenance2 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR;
|
||||
|
||||
//=== VK_HUAWEI_hdr_vivid ===
|
||||
using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI;
|
||||
|
|
@ -4832,13 +4693,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_ARM_pipeline_opacity_micromap ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
//=== VK_EXT_external_memory_metal ===
|
||||
using VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT;
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
|
||||
//=== VK_KHR_depth_clamp_zero_one ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR;
|
||||
|
|
@ -4846,21 +4700,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_EXT_vertex_attribute_robustness ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_NV_present_metering ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_EXT_fragment_density_map_offset ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
|
||||
|
||||
//===============
|
||||
//=== HANDLEs ===
|
||||
//===============
|
||||
|
|
@ -4966,9 +4805,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_KHR_pipeline_binary ===
|
||||
using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
using VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT;
|
||||
using VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT;
|
||||
|
|
@ -5075,9 +4911,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_KHR_pipeline_binary ===
|
||||
using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
using VULKAN_HPP_NAMESPACE::UniqueExternalComputeQueueNV;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
|
||||
using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutEXT;
|
||||
|
|
@ -5189,9 +5022,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_KHR_pipeline_binary ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedExternalComputeQueueNV;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
|
||||
using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT;
|
||||
|
|
@ -5387,9 +5217,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR;
|
||||
using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
using VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT;
|
||||
using VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT;
|
||||
|
|
@ -5562,10 +5389,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT>;
|
||||
|
|
@ -6828,10 +6651,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>;
|
||||
|
||||
//=== VK_KHR_shader_bfloat16 ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>;
|
||||
|
||||
//=== VK_EXT_sample_locations ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>;
|
||||
|
|
@ -7456,20 +7275,6 @@ export namespace std
|
|||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV>;
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_QCOM_tile_shading ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>;
|
||||
|
||||
//=== VK_NV_low_latency ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV>;
|
||||
|
|
@ -7906,6 +7711,14 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>;
|
||||
|
||||
//=== VK_QCOM_fragment_density_map_offset ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>;
|
||||
|
||||
//=== VK_NV_copy_memory_indirect ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>;
|
||||
|
|
@ -7934,14 +7747,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV>;
|
||||
|
||||
//=== VK_NV_ray_tracing_linear_swept_spheres ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV>;
|
||||
|
||||
//=== VK_NV_linear_color_attachment ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>;
|
||||
|
|
@ -8122,20 +7927,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>;
|
||||
|
||||
//=== VK_NV_cooperative_vector ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR>;
|
||||
|
||||
//=== VK_NV_extended_sparse_address_space ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>;
|
||||
|
|
@ -8360,16 +8151,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>;
|
||||
|
||||
//=== VK_KHR_shader_relaxed_extended_instruction ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>;
|
||||
|
|
@ -8402,62 +8183,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>;
|
||||
|
||||
//=== VK_NV_cluster_acceleration_structure ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV>;
|
||||
|
||||
//=== VK_NV_partitioned_acceleration_structure ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV>;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>;
|
||||
|
|
@ -8528,16 +8253,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DepthClampRangeEXT>;
|
||||
|
||||
//=== VK_KHR_video_maintenance2 ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>;
|
||||
|
||||
//=== VK_HUAWEI_hdr_vivid ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI>;
|
||||
|
|
@ -8556,16 +8271,6 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
//=== VK_EXT_external_memory_metal ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>;
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
|
||||
//=== VK_KHR_depth_clamp_zero_one ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>;
|
||||
|
|
@ -8574,34 +8279,8 @@ export namespace std
|
|||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>;
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_NV_present_metering ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>;
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_EXT_fragment_density_map_offset ===
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>;
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>;
|
||||
|
||||
//=================================================================
|
||||
//=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain ===
|
||||
//=================================================================
|
||||
|
||||
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
||||
using std::tuple_element;
|
||||
using std::tuple_size;
|
||||
#endif
|
||||
} // namespace std
|
||||
|
||||
// This VkFlags type is used as part of a bitfield in some structure.
|
||||
// As it can't be mimicked by vk-data types, we need to export just that!!
|
||||
export using ::VkGeometryInstanceFlagsKHR;
|
||||
// As it that can't be mimiced by vk-data types, we need to export just that!!
|
||||
export VkGeometryInstanceFlagsKHR;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -180,7 +180,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_AMD_shader_fragment_mask",
|
||||
"VK_EXT_inline_uniform_block",
|
||||
"VK_EXT_shader_stencil_export",
|
||||
"VK_KHR_shader_bfloat16",
|
||||
"VK_EXT_sample_locations",
|
||||
"VK_KHR_relaxed_block_layout",
|
||||
"VK_KHR_get_memory_requirements2",
|
||||
|
|
@ -311,7 +310,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
"VK_NV_cuda_kernel_launch",
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
"VK_QCOM_tile_shading",
|
||||
"VK_NV_low_latency",
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
"VK_EXT_metal_objects",
|
||||
|
|
@ -390,7 +388,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_NV_copy_memory_indirect",
|
||||
"VK_NV_memory_decompression",
|
||||
"VK_NV_device_generated_commands_compute",
|
||||
"VK_NV_ray_tracing_linear_swept_spheres",
|
||||
"VK_NV_linear_color_attachment",
|
||||
"VK_KHR_shader_maximal_reconvergence",
|
||||
"VK_EXT_image_compression_control_swapchain",
|
||||
|
|
@ -416,7 +413,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_SEC_amigo_profiling",
|
||||
"VK_QCOM_multiview_per_view_viewports",
|
||||
"VK_NV_ray_tracing_invocation_reorder",
|
||||
"VK_NV_cooperative_vector",
|
||||
"VK_NV_extended_sparse_address_space",
|
||||
"VK_EXT_mutable_descriptor_type",
|
||||
"VK_EXT_legacy_vertex_attributes",
|
||||
|
|
@ -451,32 +447,21 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_NV_descriptor_pool_overallocation",
|
||||
"VK_KHR_video_encode_quantization_map",
|
||||
"VK_NV_raw_access_chains",
|
||||
"VK_NV_external_compute_queue",
|
||||
"VK_KHR_shader_relaxed_extended_instruction",
|
||||
"VK_NV_command_buffer_inheritance",
|
||||
"VK_KHR_maintenance7",
|
||||
"VK_NV_shader_atomic_float16_vector",
|
||||
"VK_EXT_shader_replicated_composites",
|
||||
"VK_NV_ray_tracing_validation",
|
||||
"VK_NV_cluster_acceleration_structure",
|
||||
"VK_NV_partitioned_acceleration_structure",
|
||||
"VK_EXT_device_generated_commands",
|
||||
"VK_KHR_maintenance8",
|
||||
"VK_MESA_image_alignment_control",
|
||||
"VK_EXT_depth_clamp_control",
|
||||
"VK_KHR_video_maintenance2",
|
||||
"VK_HUAWEI_hdr_vivid",
|
||||
"VK_NV_cooperative_matrix2",
|
||||
"VK_ARM_pipeline_opacity_micromap",
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
"VK_EXT_external_memory_metal",
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
"VK_KHR_depth_clamp_zero_one",
|
||||
"VK_EXT_vertex_attribute_robustness",
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
"VK_NV_present_metering",
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
"VK_EXT_fragment_density_map_offset"
|
||||
"VK_EXT_vertex_attribute_robustness"
|
||||
};
|
||||
return deviceExtensions;
|
||||
}
|
||||
|
|
@ -573,8 +558,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_display_swapchain",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_display",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_display",
|
||||
} } } } },
|
||||
#if defined( VK_USE_PLATFORM_XLIB_KHR )
|
||||
{ "VK_KHR_xlib_surface",
|
||||
|
|
@ -625,13 +610,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_video_decode_queue",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_video_queue",
|
||||
"VK_KHR_synchronization2",
|
||||
"VK_KHR_video_queue",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
"VK_KHR_video_queue",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_3", { {} } } } },
|
||||
{ "VK_EXT_transform_feedback",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -662,7 +644,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_dynamic_rendering",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_depth_stencil_resolve",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -889,7 +870,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_image_format_list",
|
||||
"VK_KHR_maintenance2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -900,8 +880,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_create_renderpass2",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_maintenance2",
|
||||
"VK_KHR_multiview",
|
||||
"VK_KHR_maintenance2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_IMG_relaxed_line_rasterization",
|
||||
|
|
@ -913,14 +893,14 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_shared_presentable_image",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
} } } } },
|
||||
{ "VK_KHR_external_fence_capabilities",
|
||||
{ { "VK_VERSION_1_0",
|
||||
|
|
@ -1004,10 +984,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_ANDROID_external_memory_android_hardware_buffer",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_queue_family_foreign",
|
||||
"VK_KHR_dedicated_allocation",
|
||||
"VK_KHR_external_memory",
|
||||
"VK_KHR_sampler_ycbcr_conversion",
|
||||
"VK_KHR_external_memory",
|
||||
"VK_KHR_dedicated_allocation",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
|
|
@ -1024,11 +1003,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_AMDX_shader_enqueue",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_extended_dynamic_state",
|
||||
"VK_KHR_maintenance5",
|
||||
"VK_KHR_pipeline_library",
|
||||
"VK_KHR_spirv_1_4",
|
||||
"VK_KHR_synchronization2",
|
||||
"VK_KHR_spirv_1_4",
|
||||
"VK_EXT_extended_dynamic_state",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
|
|
@ -1043,12 +1020,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_KHR_maintenance1",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_KHR_shader_bfloat16",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_sample_locations",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -1066,7 +1037,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ {
|
||||
"VK_EXT_descriptor_indexing",
|
||||
"VK_KHR_buffer_device_address",
|
||||
"VK_KHR_deferred_host_operations",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
|
|
@ -1075,31 +1045,23 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_ray_tracing_pipeline",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_acceleration_structure",
|
||||
"VK_KHR_spirv_1_4",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
"VK_KHR_acceleration_structure",
|
||||
} } } } },
|
||||
{ "VK_KHR_ray_query",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_acceleration_structure",
|
||||
"VK_KHR_spirv_1_4",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
"VK_KHR_acceleration_structure",
|
||||
} } } } },
|
||||
{ "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_KHR_sampler_ycbcr_conversion",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_maintenance1",
|
||||
"VK_KHR_bind_memory2",
|
||||
"VK_KHR_get_memory_requirements2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_maintenance1",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_image_drm_format_modifier",
|
||||
|
|
@ -1107,7 +1069,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ {
|
||||
"VK_KHR_bind_memory2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_image_format_list",
|
||||
"VK_KHR_sampler_ycbcr_conversion",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -1139,8 +1100,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_NV_ray_tracing",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_memory_requirements2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_get_memory_requirements2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_NV_representative_fragment_test",
|
||||
|
|
@ -1214,8 +1175,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_GGP_frame_token",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_GGP_stream_descriptor_surface",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_GGP_stream_descriptor_surface",
|
||||
} } } } },
|
||||
#endif /*VK_USE_PLATFORM_GGP*/
|
||||
{ "VK_KHR_driver_properties",
|
||||
|
|
@ -1240,14 +1201,14 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_swapchain_mutable_format",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_image_format_list",
|
||||
"VK_KHR_maintenance2",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_maintenance2",
|
||||
"VK_KHR_image_format_list",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_KHR_image_format_list",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_image_format_list",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
|
|
@ -1317,8 +1278,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_swapchain",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
|
|
@ -1361,7 +1320,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_fragment_shading_rate",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_create_renderpass2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -1395,11 +1353,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_shader_quad_control",
|
||||
{ { "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_KHR_shader_maximal_reconvergence",
|
||||
"VK_KHR_vulkan_memory_model",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
"VK_KHR_shader_maximal_reconvergence",
|
||||
} } } } },
|
||||
{ "VK_KHR_spirv_1_4",
|
||||
|
|
@ -1434,7 +1388,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_separate_depth_stencil_layouts",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_create_renderpass2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -1451,8 +1404,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_present_wait",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_present_id",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_present_id",
|
||||
} } } } },
|
||||
{ "VK_NV_cooperative_matrix",
|
||||
{ { "VK_VERSION_1_0",
|
||||
|
|
@ -1463,13 +1416,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_NV_coverage_reduction_mode",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_NV_framebuffer_mixed_samples",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_NV_framebuffer_mixed_samples",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_NV_framebuffer_mixed_samples",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_fragment_shader_interlock",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -1499,14 +1449,11 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_surface",
|
||||
"VK_KHR_swapchain",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_surface",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_swapchain",
|
||||
} } } } },
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
|
@ -1518,8 +1465,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_buffer_device_address",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_device_group",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_device_group",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_line_rasterization",
|
||||
|
|
@ -1561,8 +1508,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_host_image_copy",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_copy_commands2",
|
||||
"VK_KHR_format_feature_flags2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -1585,21 +1530,17 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_surface_maintenance1",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_surface",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
} } } } },
|
||||
{ "VK_EXT_swapchain_maintenance1",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_swapchain",
|
||||
"VK_EXT_surface_maintenance1",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_swapchain",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_EXT_surface_maintenance1",
|
||||
"VK_KHR_swapchain",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_shader_demote_to_helper_invocation",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -1663,21 +1604,18 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_surface",
|
||||
"VK_KHR_swapchain",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_surface",
|
||||
"VK_KHR_get_surface_capabilities2",
|
||||
"VK_KHR_swapchain",
|
||||
} } } } },
|
||||
{ "VK_KHR_present_id",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_private_data",
|
||||
|
|
@ -1695,27 +1633,16 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_video_encode_queue",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_video_queue",
|
||||
"VK_KHR_synchronization2",
|
||||
"VK_KHR_video_queue",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
"VK_KHR_video_queue",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_3", { {} } } } },
|
||||
{ "VK_NV_device_diagnostics_config",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_QCOM_tile_shading",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_QCOM_tile_properties",
|
||||
},
|
||||
{
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } } } },
|
||||
{ "VK_KHR_synchronization2",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -1725,16 +1652,12 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_descriptor_buffer",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_descriptor_indexing",
|
||||
"VK_KHR_buffer_device_address",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_synchronization2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_EXT_descriptor_indexing",
|
||||
"VK_KHR_buffer_device_address",
|
||||
"VK_KHR_synchronization2",
|
||||
"VK_EXT_descriptor_indexing",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
|
|
@ -1745,7 +1668,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_pipeline_library",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
|
|
@ -1784,8 +1706,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_spirv_1_4",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2", { {} } } } },
|
||||
} } } } },
|
||||
{ "VK_EXT_ycbcr_2plane_444_formats",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -1891,7 +1812,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_device_address_binding_report",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_debug_utils",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -1925,15 +1845,15 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_FUCHSIA_external_memory",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_external_memory",
|
||||
"VK_KHR_external_memory_capabilities",
|
||||
"VK_KHR_external_memory",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_FUCHSIA_external_semaphore",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_external_semaphore",
|
||||
"VK_KHR_external_semaphore_capabilities",
|
||||
"VK_KHR_external_semaphore",
|
||||
} } } } },
|
||||
{ "VK_FUCHSIA_buffer_collection",
|
||||
{ { "VK_VERSION_1_0",
|
||||
|
|
@ -1941,16 +1861,12 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_FUCHSIA_external_memory",
|
||||
"VK_KHR_sampler_ycbcr_conversion",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_FUCHSIA_external_memory",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
{ "VK_HUAWEI_subpass_shading",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_create_renderpass2",
|
||||
"VK_KHR_synchronization2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
|
|
@ -1963,10 +1879,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_KHR_ray_tracing_pipeline",
|
||||
"VK_KHR_synchronization2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
"VK_KHR_ray_tracing_pipeline",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_3", { {} } } } },
|
||||
{ "VK_NV_external_memory_rdma",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -2021,10 +1934,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_EXT_global_priority",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_EXT_global_priority",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_image_view_min_lod",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -2040,8 +1950,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_image_2d_view_of_3d",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_maintenance1",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_shader_tile_image", { { "VK_VERSION_1_3", { {} } } } },
|
||||
|
|
@ -2051,10 +1961,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_KHR_acceleration_structure",
|
||||
"VK_KHR_synchronization2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
"VK_KHR_acceleration_structure",
|
||||
} } } } },
|
||||
{ "VK_VERSION_1_3", { {} } } } },
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
{ "VK_NV_displacement_micromap",
|
||||
{ { "VK_VERSION_1_0",
|
||||
|
|
@ -2088,8 +1995,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_image_sliced_view_of_3d",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_maintenance1",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_VALVE_descriptor_set_host_mapping",
|
||||
|
|
@ -2114,7 +2021,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_synchronization2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
|
|
@ -2124,7 +2030,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_QCOM_fragment_density_map_offset",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_fragment_density_map",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -2134,7 +2039,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_NV_copy_memory_indirect",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_buffer_device_address",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -2145,7 +2049,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_NV_memory_decompression",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_buffer_device_address",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -2158,11 +2061,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ {
|
||||
"VK_NV_device_generated_commands",
|
||||
} } } } },
|
||||
{ "VK_NV_ray_tracing_linear_swept_spheres",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_ray_tracing_pipeline",
|
||||
} } } } },
|
||||
{ "VK_NV_linear_color_attachment",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -2213,7 +2111,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_shader_module_identifier",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_pipeline_creation_cache_control",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -2230,9 +2127,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_NV_optical_flow",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_format_feature_flags2",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_synchronization2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
|
|
@ -2273,7 +2168,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_shader_object",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_dynamic_rendering",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -2285,8 +2179,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_maintenance5",
|
||||
} } },
|
||||
{ "VK_VERSION_1_4", { {} } } } },
|
||||
} } } } },
|
||||
{ "VK_QCOM_tile_properties",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -2314,8 +2207,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_maintenance3",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
} } } } },
|
||||
{ "VK_EXT_legacy_vertex_attributes",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -2330,13 +2222,12 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_pipeline_library_group_handles",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_pipeline_library",
|
||||
"VK_KHR_ray_tracing_pipeline",
|
||||
"VK_KHR_pipeline_library",
|
||||
} } } } },
|
||||
{ "VK_EXT_dynamic_rendering_unused_attachments",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_dynamic_rendering",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -2360,8 +2251,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
} } } } },
|
||||
{ "VK_KHR_video_decode_av1",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -2406,7 +2296,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_attachment_feedback_loop_dynamic_state",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_attachment_feedback_loop_layout",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
|
|
@ -2428,10 +2317,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_QNX_external_memory_screen_buffer",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_queue_family_foreign",
|
||||
"VK_KHR_dedicated_allocation",
|
||||
"VK_KHR_external_memory",
|
||||
"VK_KHR_sampler_ycbcr_conversion",
|
||||
"VK_KHR_external_memory",
|
||||
"VK_KHR_dedicated_allocation",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
|
|
@ -2479,35 +2367,16 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_video_encode_quantization_map",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_video_encode_queue",
|
||||
"VK_KHR_format_feature_flags2",
|
||||
"VK_KHR_video_encode_queue",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
"VK_KHR_video_encode_queue",
|
||||
} } } } },
|
||||
{ "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_NV_cluster_acceleration_structure",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_acceleration_structure",
|
||||
} } } } },
|
||||
{ "VK_NV_partitioned_acceleration_structure",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_acceleration_structure",
|
||||
} } } } },
|
||||
{ "VK_EXT_device_generated_commands",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_buffer_device_address",
|
||||
"VK_KHR_maintenance5",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
"VK_KHR_maintenance5",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3", { {} } } } },
|
||||
} } } } },
|
||||
{ "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_MESA_image_alignment_control",
|
||||
{ { "VK_VERSION_1_0",
|
||||
|
|
@ -2521,22 +2390,15 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_KHR_video_maintenance2",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_video_queue",
|
||||
} } } } },
|
||||
{ "VK_HUAWEI_hdr_vivid",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_hdr_metadata",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
"VK_KHR_swapchain",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_EXT_hdr_metadata",
|
||||
"VK_KHR_swapchain",
|
||||
"VK_EXT_hdr_metadata",
|
||||
} } } } },
|
||||
{ "VK_NV_cooperative_matrix2",
|
||||
{ { "VK_VERSION_1_0",
|
||||
|
|
@ -2548,14 +2410,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ {
|
||||
"VK_EXT_opacity_micromap",
|
||||
} } } } },
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
{ "VK_EXT_external_memory_metal",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_external_memory",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
{ "VK_KHR_depth_clamp_zero_one",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
|
|
@ -2567,30 +2421,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ {
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1", { {} } } } },
|
||||
{ "VK_EXT_fragment_density_map_offset",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_EXT_fragment_density_map",
|
||||
"VK_KHR_create_renderpass2",
|
||||
"VK_KHR_dynamic_rendering",
|
||||
"VK_KHR_get_physical_device_properties2",
|
||||
} } },
|
||||
{ "VK_VERSION_1_1",
|
||||
{ {
|
||||
"VK_EXT_fragment_density_map",
|
||||
"VK_KHR_create_renderpass2",
|
||||
"VK_KHR_dynamic_rendering",
|
||||
} } },
|
||||
{ "VK_VERSION_1_2",
|
||||
{ {
|
||||
"VK_EXT_fragment_density_map",
|
||||
"VK_KHR_dynamic_rendering",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
"VK_EXT_fragment_density_map",
|
||||
} } } } }
|
||||
{ "VK_VERSION_1_1", { {} } } } }
|
||||
};
|
||||
auto depIt = dependencies.find( extension );
|
||||
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
|
||||
|
|
@ -2728,7 +2559,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_KHR_maintenance4", "VK_VERSION_1_3" },
|
||||
{ "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" },
|
||||
{ "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" },
|
||||
{ "VK_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" },
|
||||
{ "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" },
|
||||
{ "VK_KHR_maintenance5", "VK_VERSION_1_4" },
|
||||
{ "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" },
|
||||
|
|
@ -3202,10 +3032,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{
|
||||
return "VK_KHR_depth_clamp_zero_one";
|
||||
}
|
||||
if ( extension == "VK_QCOM_fragment_density_map_offset" )
|
||||
{
|
||||
return "VK_EXT_fragment_density_map_offset";
|
||||
}
|
||||
if ( extension == "VK_EXT_pipeline_protected_access" )
|
||||
{
|
||||
return "VK_VERSION_1_4";
|
||||
|
|
@ -3321,8 +3147,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|| ( extension == "VK_AMDX_shader_enqueue" )
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|| ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
|
||||
( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) ||
|
||||
( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
|
||||
( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_EXT_sample_locations" ) ||
|
||||
( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
|
||||
( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) ||
|
||||
( extension == "VK_NV_fragment_coverage_to_color" ) || ( extension == "VK_KHR_acceleration_structure" ) ||
|
||||
( extension == "VK_KHR_ray_tracing_pipeline" ) || ( extension == "VK_KHR_ray_query" ) || ( extension == "VK_NV_framebuffer_mixed_samples" ) ||
|
||||
|
|
@ -3385,7 +3211,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
|| ( extension == "VK_NV_cuda_kernel_launch" )
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|| ( extension == "VK_QCOM_tile_shading" ) || ( extension == "VK_NV_low_latency" )
|
||||
|| ( extension == "VK_NV_low_latency" )
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
|| ( extension == "VK_EXT_metal_objects" )
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
|
|
@ -3427,27 +3253,25 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_ARM_render_pass_striped" ) ||
|
||||
( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) ||
|
||||
( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_device_generated_commands_compute" ) ||
|
||||
( extension == "VK_NV_ray_tracing_linear_swept_spheres" ) || ( extension == "VK_NV_linear_color_attachment" ) ||
|
||||
( extension == "VK_KHR_shader_maximal_reconvergence" ) || ( extension == "VK_EXT_image_compression_control_swapchain" ) ||
|
||||
( extension == "VK_QCOM_image_processing" ) || ( extension == "VK_EXT_nested_command_buffer" ) ||
|
||||
( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
|
||||
( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
|
||||
( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) ||
|
||||
( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
|
||||
( extension == "VK_NV_linear_color_attachment" ) || ( extension == "VK_KHR_shader_maximal_reconvergence" ) ||
|
||||
( extension == "VK_EXT_image_compression_control_swapchain" ) || ( extension == "VK_QCOM_image_processing" ) ||
|
||||
( extension == "VK_EXT_nested_command_buffer" ) || ( extension == "VK_EXT_external_memory_acquire_unmodified" ) ||
|
||||
( extension == "VK_EXT_extended_dynamic_state3" ) || ( extension == "VK_EXT_subpass_merge_feedback" ) ||
|
||||
( extension == "VK_EXT_shader_module_identifier" ) || ( extension == "VK_EXT_rasterization_order_attachment_access" ) ||
|
||||
( extension == "VK_NV_optical_flow" ) || ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
|| ( extension == "VK_ANDROID_external_format_resolve" )
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|| ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
|
||||
( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
|
||||
( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
|
||||
( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_cooperative_vector" ) ||
|
||||
( extension == "VK_NV_extended_sparse_address_space" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
|
||||
( extension == "VK_EXT_legacy_vertex_attributes" ) || ( extension == "VK_ARM_shader_core_builtins" ) ||
|
||||
( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) ||
|
||||
( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
|
||||
( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) ||
|
||||
( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_maintenance1" ) ||
|
||||
( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
|
||||
( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
|
||||
( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
|
||||
( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
|
||||
( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
|
||||
( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
|
||||
( extension == "VK_KHR_compute_shader_derivatives" ) || ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) ||
|
||||
( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
|
||||
( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
|
||||
( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
|
||||
( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" )
|
||||
|
|
@ -3457,23 +3281,13 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
|
||||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
|
||||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) ||
|
||||
( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) ||
|
||||
( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
|
||||
( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
|
||||
( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
|
||||
( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) ||
|
||||
( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
|
||||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
|
||||
( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
|
||||
( extension == "VK_ARM_pipeline_opacity_micromap" )
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
|| ( extension == "VK_EXT_external_memory_metal" )
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" )
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
|| ( extension == "VK_NV_present_metering" )
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|| ( extension == "VK_EXT_fragment_density_map_offset" );
|
||||
( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) ||
|
||||
( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) ||
|
||||
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
|
||||
( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
|
||||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
|
||||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) ||
|
||||
( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
|
||||
|
|
@ -3584,8 +3398,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
|
||||
( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) ||
|
||||
( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) ||
|
||||
( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_EXT_pipeline_protected_access" ) ||
|
||||
( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
|
||||
( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
|
||||
( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
|
||||
( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
|
||||
( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" );
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4662,7 +4662,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eB8G8R8A8Unorm:
|
||||
|
|
@ -4725,7 +4725,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8UnormPack32:
|
||||
|
|
@ -4785,7 +4785,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8SrgbPack32:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "UNORM";
|
||||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "SRGB";
|
||||
|
|
@ -5381,7 +5381,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc2UnormBlock:
|
||||
|
|
@ -5399,7 +5399,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc3UnormBlock:
|
||||
|
|
@ -5417,7 +5417,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc4UnormBlock:
|
||||
|
|
@ -5477,7 +5477,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8UnormBlock:
|
||||
|
|
@ -5511,7 +5511,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock:
|
||||
|
|
@ -5529,7 +5529,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eEacR11UnormBlock:
|
||||
|
|
@ -5573,7 +5573,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc5x4UnormBlock:
|
||||
|
|
@ -5591,7 +5591,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc5x5UnormBlock:
|
||||
|
|
@ -5609,7 +5609,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc6x5UnormBlock:
|
||||
|
|
@ -5627,7 +5627,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc6x6UnormBlock:
|
||||
|
|
@ -5645,7 +5645,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc8x5UnormBlock:
|
||||
|
|
@ -5663,7 +5663,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc8x6UnormBlock:
|
||||
|
|
@ -5681,7 +5681,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc8x8UnormBlock:
|
||||
|
|
@ -5699,7 +5699,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc10x5UnormBlock:
|
||||
|
|
@ -5717,7 +5717,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc10x6UnormBlock:
|
||||
|
|
@ -5735,7 +5735,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc10x8UnormBlock:
|
||||
|
|
@ -5753,7 +5753,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc10x10UnormBlock:
|
||||
|
|
@ -5771,7 +5771,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc12x10UnormBlock:
|
||||
|
|
@ -5789,7 +5789,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eAstc12x12UnormBlock:
|
||||
|
|
@ -5807,7 +5807,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eG8B8G8R8422Unorm:
|
||||
|
|
@ -6319,7 +6319,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG:
|
||||
|
|
@ -6328,7 +6328,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG:
|
||||
|
|
@ -6337,7 +6337,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG:
|
||||
|
|
@ -6346,7 +6346,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 2: return "SRGB";
|
||||
case 3: return "UNORM";
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -188,47 +188,6 @@ VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
|
|||
VkExportMetalObjectsInfoEXT* pMetalObjectsInfo);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_external_memory_metal 1
|
||||
#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1
|
||||
#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal"
|
||||
typedef struct VkImportMemoryMetalHandleInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkExternalMemoryHandleTypeFlagBits handleType;
|
||||
void* handle;
|
||||
} VkImportMemoryMetalHandleInfoEXT;
|
||||
|
||||
typedef struct VkMemoryMetalHandlePropertiesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint32_t memoryTypeBits;
|
||||
} VkMemoryMetalHandlePropertiesEXT;
|
||||
|
||||
typedef struct VkMemoryGetMetalHandleInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkDeviceMemory memory;
|
||||
VkExternalMemoryHandleTypeFlagBits handleType;
|
||||
} VkMemoryGetMetalHandleInfoEXT;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(
|
||||
VkDevice device,
|
||||
const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
|
||||
void** pHandle);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(
|
||||
VkDevice device,
|
||||
VkExternalMemoryHandleTypeFlagBits handleType,
|
||||
const void* pHandle,
|
||||
VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -315,9 +315,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
|
||||
# pragma GCC diagnostic push
|
||||
# pragma GCC diagnostic ignored "-Wcast-function-type"
|
||||
# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
|
||||
# pragma clang diagnostic push
|
||||
# pragma clang diagnostic ignored "-Wcast-function-type"
|
||||
# endif
|
||||
|
||||
template <typename HandleType>
|
||||
|
|
@ -462,8 +459,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|
||||
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
|
||||
# pragma GCC diagnostic pop
|
||||
# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
|
||||
# pragma clang diagnostic pop
|
||||
# endif
|
||||
|
||||
} // namespace detail
|
||||
|
|
@ -981,17 +976,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|
||||
using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
template <>
|
||||
class SharedHandleTraits<ExternalComputeQueueNV>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = detail::ObjectDestroyShared<ExternalComputeQueueNV>;
|
||||
};
|
||||
|
||||
using SharedExternalComputeQueueNV = SharedHandle<ExternalComputeQueueNV>;
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
template <>
|
||||
class SharedHandleTraits<IndirectCommandsLayoutEXT>
|
||||
|
|
|
|||
|
|
@ -3611,15 +3611,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Attachme
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>::value,
|
||||
"AttachmentSampleCountInfoAMD is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_shader_bfloat16 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderBfloat16FeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderBfloat16FeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_sample_locations ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
|
||||
|
|
@ -5402,44 +5393,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
|
|||
"PhysicalDeviceCudaKernelLaunchPropertiesNV is not nothrow_move_constructible!" );
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_QCOM_tile_shading ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileShadingFeaturesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>::value,
|
||||
"PhysicalDeviceTileShadingFeaturesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileShadingPropertiesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>::value,
|
||||
"PhysicalDeviceTileShadingPropertiesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM ) == sizeof( VkRenderPassTileShadingCreateInfoQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>::value,
|
||||
"RenderPassTileShadingCreateInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM ) == sizeof( VkPerTileBeginInfoQCOM ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>::value,
|
||||
"PerTileBeginInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM ) == sizeof( VkPerTileEndInfoQCOM ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>::value,
|
||||
"PerTileEndInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM ) == sizeof( VkDispatchTileInfoQCOM ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>::value,
|
||||
"DispatchTileInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_low_latency ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV ) == sizeof( VkQueryLowLatencySupportNV ),
|
||||
|
|
@ -6642,6 +6595,31 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPa
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>::value,
|
||||
"RenderPassStripeSubmitInfoARM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_QCOM_fragment_density_map_offset ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) ==
|
||||
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
|
||||
"PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) ==
|
||||
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
|
||||
"PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) == sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
|
||||
"SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_copy_memory_indirect ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV ) == sizeof( VkCopyMemoryIndirectCommandNV ),
|
||||
|
|
@ -6726,31 +6704,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BindPipe
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV>::value,
|
||||
"BindPipelineIndirectCommandNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_ray_tracing_linear_swept_spheres ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ) ==
|
||||
sizeof( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>::value,
|
||||
"PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV ) ==
|
||||
sizeof( VkAccelerationStructureGeometryLinearSweptSpheresDataNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV>::value,
|
||||
"AccelerationStructureGeometryLinearSweptSpheresDataNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV ) == sizeof( VkAccelerationStructureGeometrySpheresDataNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV>::value,
|
||||
"AccelerationStructureGeometrySpheresDataNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_linear_color_attachment ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV ) ==
|
||||
|
|
@ -7244,36 +7197,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>::value,
|
||||
"PhysicalDeviceRayTracingInvocationReorderFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_cooperative_vector ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV ) ==
|
||||
sizeof( VkPhysicalDeviceCooperativeVectorPropertiesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV>::value,
|
||||
"PhysicalDeviceCooperativeVectorPropertiesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeVectorFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV>::value,
|
||||
"PhysicalDeviceCooperativeVectorFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV ) == sizeof( VkCooperativeVectorPropertiesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>::value,
|
||||
"CooperativeVectorPropertiesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV ) == sizeof( VkConvertCooperativeVectorMatrixInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV>::value,
|
||||
"ConvertCooperativeVectorMatrixInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_extended_sparse_address_space ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ) ==
|
||||
|
|
@ -7903,42 +7826,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>::value,
|
||||
"PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_external_compute_queue ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV ) == sizeof( VkExternalComputeQueueNV ),
|
||||
"handle and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::value,
|
||||
"ExternalComputeQueueNV is not copy_constructible!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::value,
|
||||
"ExternalComputeQueueNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV ) == sizeof( VkExternalComputeQueueDeviceCreateInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>::value,
|
||||
"ExternalComputeQueueDeviceCreateInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV ) == sizeof( VkExternalComputeQueueCreateInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>::value,
|
||||
"ExternalComputeQueueCreateInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV ) == sizeof( VkExternalComputeQueueDataParamsNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>::value,
|
||||
"ExternalComputeQueueDataParamsNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV ) ==
|
||||
sizeof( VkPhysicalDeviceExternalComputeQueuePropertiesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>::value,
|
||||
"PhysicalDeviceExternalComputeQueuePropertiesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_shader_relaxed_extended_instruction ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) ==
|
||||
|
|
@ -8027,212 +7914,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
|
||||
"PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_cluster_acceleration_structure ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV ) ==
|
||||
sizeof( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV>::value,
|
||||
"PhysicalDeviceClusterAccelerationStructureFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV ) ==
|
||||
sizeof( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV>::value,
|
||||
"PhysicalDeviceClusterAccelerationStructurePropertiesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureClustersBottomLevelInputNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV>::value,
|
||||
"ClusterAccelerationStructureClustersBottomLevelInputNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureTriangleClusterInputNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV>::value,
|
||||
"ClusterAccelerationStructureTriangleClusterInputNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureMoveObjectsInputNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV>::value,
|
||||
"ClusterAccelerationStructureMoveObjectsInputNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV ) == sizeof( VkClusterAccelerationStructureOpInputNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV>::value,
|
||||
"ClusterAccelerationStructureOpInputNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV ) == sizeof( VkClusterAccelerationStructureInputInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV>::value,
|
||||
"ClusterAccelerationStructureInputInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV ) == sizeof( VkClusterAccelerationStructureCommandsInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV>::value,
|
||||
"ClusterAccelerationStructureCommandsInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV ) == sizeof( VkStridedDeviceAddressNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV>::value,
|
||||
"StridedDeviceAddressNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>::value,
|
||||
"ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureMoveObjectsInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV>::value,
|
||||
"ClusterAccelerationStructureMoveObjectsInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>::value,
|
||||
"ClusterAccelerationStructureBuildClustersBottomLevelInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureBuildTriangleClusterInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV>::value,
|
||||
"ClusterAccelerationStructureBuildTriangleClusterInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>::value,
|
||||
"ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV ) ==
|
||||
sizeof( VkClusterAccelerationStructureInstantiateClusterInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV>::value,
|
||||
"ClusterAccelerationStructureInstantiateClusterInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV ) ==
|
||||
sizeof( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV>::value,
|
||||
"RayTracingPipelineClusterAccelerationStructureCreateInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_partitioned_acceleration_structure ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV ) ==
|
||||
sizeof( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV>::value,
|
||||
"PhysicalDevicePartitionedAccelerationStructureFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV ) ==
|
||||
sizeof( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV>::value,
|
||||
"PhysicalDevicePartitionedAccelerationStructurePropertiesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV ) == sizeof( VkPartitionedAccelerationStructureFlagsNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV>::value,
|
||||
"PartitionedAccelerationStructureFlagsNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV ) ==
|
||||
sizeof( VkBuildPartitionedAccelerationStructureIndirectCommandNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV>::value,
|
||||
"BuildPartitionedAccelerationStructureIndirectCommandNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV ) ==
|
||||
sizeof( VkPartitionedAccelerationStructureWriteInstanceDataNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV>::value,
|
||||
"PartitionedAccelerationStructureWriteInstanceDataNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV ) ==
|
||||
sizeof( VkPartitionedAccelerationStructureUpdateInstanceDataNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV>::value,
|
||||
"PartitionedAccelerationStructureUpdateInstanceDataNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV ) ==
|
||||
sizeof( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV>::value,
|
||||
"PartitionedAccelerationStructureWritePartitionTranslationDataNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV ) ==
|
||||
sizeof( VkWriteDescriptorSetPartitionedAccelerationStructureNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV>::value,
|
||||
"WriteDescriptorSetPartitionedAccelerationStructureNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV ) ==
|
||||
sizeof( VkPartitionedAccelerationStructureInstancesInputNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV>::value,
|
||||
"PartitionedAccelerationStructureInstancesInputNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV ) ==
|
||||
sizeof( VkBuildPartitionedAccelerationStructureInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV>::value,
|
||||
"BuildPartitionedAccelerationStructureInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_device_generated_commands ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT ) ==
|
||||
|
|
@ -8465,39 +8146,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DepthCla
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DepthClampRangeEXT>::value,
|
||||
"DepthClampRangeEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_video_maintenance2 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance2FeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>::value,
|
||||
"PhysicalDeviceVideoMaintenance2FeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR ) ==
|
||||
sizeof( VkVideoDecodeH264InlineSessionParametersInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>::value,
|
||||
"VideoDecodeH264InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR ) ==
|
||||
sizeof( VkVideoDecodeH265InlineSessionParametersInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>::value,
|
||||
"VideoDecodeH265InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR ) ==
|
||||
sizeof( VkVideoDecodeAV1InlineSessionParametersInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value,
|
||||
"VideoDecodeAV1InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_HUAWEI_hdr_vivid ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceHdrVividFeaturesHUAWEI ),
|
||||
|
|
@ -8548,28 +8196,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>::value,
|
||||
"PhysicalDevicePipelineOpacityMicromapFeaturesARM is not nothrow_move_constructible!" );
|
||||
|
||||
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
||||
//=== VK_EXT_external_memory_metal ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT ) == sizeof( VkImportMemoryMetalHandleInfoEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>::value,
|
||||
"ImportMemoryMetalHandleInfoEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT ) == sizeof( VkMemoryMetalHandlePropertiesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::value,
|
||||
"MemoryMetalHandlePropertiesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT ) == sizeof( VkMemoryGetMetalHandleInfoEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>::value,
|
||||
"MemoryGetMetalHandleInfoEXT is not nothrow_move_constructible!" );
|
||||
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
||||
|
||||
//=== VK_KHR_depth_clamp_zero_one ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR ),
|
||||
|
|
@ -8589,51 +8215,4 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>::value,
|
||||
"PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_NV_present_metering ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetPresentConfigNV ) == sizeof( VkSetPresentConfigNV ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value,
|
||||
"SetPresentConfigNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV ) == sizeof( VkPhysicalDevicePresentMeteringFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
|
||||
"PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" );
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_EXT_fragment_density_map_offset ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT ) == sizeof( VkRenderingEndInfoEXT ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value,
|
||||
"RenderingEndInfoEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ) ==
|
||||
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
|
||||
"PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ) ==
|
||||
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
|
||||
"PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT ) ==
|
||||
sizeof( VkRenderPassFragmentDensityMapOffsetEndInfoEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
|
||||
"RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" );
|
||||
|
||||
#endif
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -1,803 +0,0 @@
|
|||
#!/usr/bin/env python3 -i
|
||||
#
|
||||
# Copyright 2023-2025 The Khronos Group Inc.
|
||||
#
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
import pickle
|
||||
import os
|
||||
import tempfile
|
||||
from vulkan_object import (VulkanObject,
|
||||
Extension, Version, Handle, Param, Queues, CommandScope, Command,
|
||||
EnumField, Enum, Flag, Bitmask, Member, Struct,
|
||||
FormatComponent, FormatPlane, Format,
|
||||
SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
|
||||
SpirvEnables, Spirv)
|
||||
|
||||
# These live in the Vulkan-Docs repo, but are pulled in via the
|
||||
# Vulkan-Headers/registry folder
|
||||
from generator import OutputGenerator, GeneratorOptions, write
|
||||
from vkconventions import VulkanConventions
|
||||
|
||||
# An API style convention object
|
||||
vulkanConventions = VulkanConventions()
|
||||
|
||||
# Helpers to keep things cleaner
|
||||
def splitIfGet(elem, name):
|
||||
return elem.get(name).split(',') if elem.get(name) is not None and elem.get(name) != '' else None
|
||||
|
||||
def textIfFind(elem, name):
|
||||
return elem.find(name).text if elem.find(name) is not None else None
|
||||
|
||||
def intIfGet(elem, name):
|
||||
return None if elem.get(name) is None else int(elem.get(name), 0)
|
||||
|
||||
def boolGet(elem, name) -> bool:
|
||||
return elem.get(name) is not None and elem.get(name) == "true"
|
||||
|
||||
def getQueues(elem) -> Queues:
|
||||
queues = 0
|
||||
queues_list = splitIfGet(elem, 'queues')
|
||||
if queues_list is not None:
|
||||
queues |= Queues.TRANSFER if 'transfer' in queues_list else 0
|
||||
queues |= Queues.GRAPHICS if 'graphics' in queues_list else 0
|
||||
queues |= Queues.COMPUTE if 'compute' in queues_list else 0
|
||||
queues |= Queues.PROTECTED if 'protected' in queues_list else 0
|
||||
queues |= Queues.SPARSE_BINDING if 'sparse_binding' in queues_list else 0
|
||||
queues |= Queues.OPTICAL_FLOW if 'opticalflow' in queues_list else 0
|
||||
queues |= Queues.DECODE if 'decode' in queues_list else 0
|
||||
queues |= Queues.ENCODE if 'encode' in queues_list else 0
|
||||
return queues
|
||||
|
||||
# Shared object used by Sync elements that do not have ones
|
||||
maxSyncSupport = SyncSupport(None, None, True)
|
||||
maxSyncEquivalent = SyncEquivalent(None, None, True)
|
||||
|
||||
# Helpers to set GeneratorOptions options globally
|
||||
def SetOutputFileName(fileName: str) -> None:
|
||||
global globalFileName
|
||||
globalFileName = fileName
|
||||
|
||||
def SetOutputDirectory(directory: str) -> None:
|
||||
global globalDirectory
|
||||
globalDirectory = directory
|
||||
|
||||
def SetTargetApiName(apiname: str) -> None:
|
||||
global globalApiName
|
||||
globalApiName = apiname
|
||||
|
||||
def SetMergedApiNames(names: str) -> None:
|
||||
global mergedApiNames
|
||||
mergedApiNames = names
|
||||
|
||||
cachingEnabled = False
|
||||
def EnableCaching() -> None:
|
||||
global cachingEnabled
|
||||
cachingEnabled = True
|
||||
|
||||
# This class is a container for any source code, data, or other behavior that is necessary to
|
||||
# customize the generator script for a specific target API variant (e.g. Vulkan SC). As such,
|
||||
# all of these API-specific interfaces and their use in the generator script are part of the
|
||||
# contract between this repository and its downstream users. Changing or removing any of these
|
||||
# interfaces or their use in the generator script will have downstream effects and thus
|
||||
# should be avoided unless absolutely necessary.
|
||||
class APISpecific:
|
||||
# Version object factory method
|
||||
@staticmethod
|
||||
def createApiVersion(targetApiName: str, name: str) -> Version:
|
||||
match targetApiName:
|
||||
|
||||
# Vulkan SC specific API version creation
|
||||
case 'vulkansc':
|
||||
nameApi = name.replace('VK_', 'VK_API_')
|
||||
nameApi = nameApi.replace('VKSC_', 'VKSC_API_')
|
||||
nameString = f'"{name}"'
|
||||
return Version(name, nameString, nameApi)
|
||||
|
||||
# Vulkan specific API version creation
|
||||
case 'vulkan':
|
||||
nameApi = name.replace('VK_', 'VK_API_')
|
||||
nameString = f'"{name}"'
|
||||
return Version(name, nameString, nameApi)
|
||||
|
||||
|
||||
# This Generator Option is used across all generators.
|
||||
# After years of use, it has shown that most the options are unified across each generator (file)
|
||||
# as it is easier to modify things per-file that need the difference
|
||||
class BaseGeneratorOptions(GeneratorOptions):
|
||||
def __init__(self,
|
||||
customFileName = None,
|
||||
customDirectory = None,
|
||||
customApiName = None):
|
||||
GeneratorOptions.__init__(self,
|
||||
conventions = vulkanConventions,
|
||||
filename = customFileName if customFileName else globalFileName,
|
||||
directory = customDirectory if customDirectory else globalDirectory,
|
||||
apiname = customApiName if customApiName else globalApiName,
|
||||
mergeApiNames = mergedApiNames,
|
||||
defaultExtensions = customApiName if customApiName else globalApiName,
|
||||
emitExtensions = '.*',
|
||||
emitSpirv = '.*',
|
||||
emitFormats = '.*')
|
||||
# These are used by the generator.py script
|
||||
self.apicall = 'VKAPI_ATTR '
|
||||
self.apientry = 'VKAPI_CALL '
|
||||
self.apientryp = 'VKAPI_PTR *'
|
||||
self.alignFuncParam = 48
|
||||
|
||||
#
|
||||
# This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers
|
||||
# It will grab all the data and form it into a single object the rest of the generators will use
|
||||
class BaseGenerator(OutputGenerator):
|
||||
def __init__(self):
|
||||
OutputGenerator.__init__(self, None, None, None)
|
||||
self.vk = VulkanObject()
|
||||
self.targetApiName = globalApiName
|
||||
|
||||
# reg.py has a `self.featureName` but this is nicer because
|
||||
# it will be either the Version or Extension object
|
||||
self.currentExtension = None
|
||||
self.currentVersion = None
|
||||
|
||||
# Will map alias to promoted name
|
||||
# ex. ['VK_FILTER_CUBIC_IMG' : 'VK_FILTER_CUBIC_EXT']
|
||||
# When generating any code, there is no reason so use the old name
|
||||
self.enumAliasMap = dict()
|
||||
self.enumFieldAliasMap = dict()
|
||||
self.bitmaskAliasMap = dict()
|
||||
self.flagAliasMap = dict()
|
||||
self.structAliasMap = dict()
|
||||
self.handleAliasMap = dict()
|
||||
|
||||
def write(self, data):
|
||||
# Prevents having to check before writing
|
||||
if data is not None and data != "":
|
||||
write(data, file=self.outFile)
|
||||
|
||||
|
||||
def beginFile(self, genOpts):
|
||||
OutputGenerator.beginFile(self, genOpts)
|
||||
self.filename = genOpts.filename
|
||||
|
||||
# No gen*() command to get these, so do it manually
|
||||
for platform in self.registry.tree.findall('platforms/platform'):
|
||||
self.vk.platforms[platform.get('name')] = platform.get('protect')
|
||||
|
||||
for tags in self.registry.tree.findall('tags'):
|
||||
for tag in tags.findall('tag'):
|
||||
self.vk.vendorTags.append(tag.get('name'))
|
||||
|
||||
# No way known to get this from the XML
|
||||
self.vk.queueBits[Queues.TRANSFER] = 'VK_QUEUE_TRANSFER_BIT'
|
||||
self.vk.queueBits[Queues.GRAPHICS] = 'VK_QUEUE_GRAPHICS_BIT'
|
||||
self.vk.queueBits[Queues.COMPUTE] = 'VK_QUEUE_COMPUTE_BIT'
|
||||
self.vk.queueBits[Queues.PROTECTED] = 'VK_QUEUE_PROTECTED_BIT'
|
||||
self.vk.queueBits[Queues.SPARSE_BINDING] = 'VK_QUEUE_SPARSE_BINDING_BIT'
|
||||
self.vk.queueBits[Queues.OPTICAL_FLOW] = 'VK_QUEUE_OPTICAL_FLOW_BIT_NV'
|
||||
self.vk.queueBits[Queues.DECODE] = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR'
|
||||
self.vk.queueBits[Queues.ENCODE] = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR'
|
||||
|
||||
# This function should be overloaded
|
||||
def generate(self):
|
||||
print("WARNING: This should not be called from the child class")
|
||||
return
|
||||
|
||||
# This function is dense, it does all the magic to set the right extensions dependencies!
|
||||
#
|
||||
# The issue is if 2 extension expose a command, genCmd() will only
|
||||
# show one of the extension, at endFile() we can finally go through
|
||||
# and update which things depend on which extensions
|
||||
#
|
||||
# self.featureDictionary is built for use in the reg.py framework
|
||||
# Details found in Vulkan-Docs/scripts/scriptgenerator.py
|
||||
def applyExtensionDependency(self):
|
||||
for extension in self.vk.extensions.values():
|
||||
# dict.key() can be None, so need to double loop
|
||||
dict = self.featureDictionary[extension.name]['command']
|
||||
|
||||
# "required" == None
|
||||
# or
|
||||
# an additional feature dependency, which is a boolean expression of
|
||||
# one or more extension and/or core version names
|
||||
for required in dict:
|
||||
for commandName in dict[required]:
|
||||
# Skip commands removed in the target API
|
||||
# This check is needed because parts of the base generator code bypass the
|
||||
# dependency resolution logic in the registry tooling and thus the generator
|
||||
# may attempt to generate code for commands which are not supported in the
|
||||
# target API variant, thus this check needs to happen even if any specific
|
||||
# target API variant may not specifically need it
|
||||
if not commandName in self.vk.commands:
|
||||
continue
|
||||
|
||||
command = self.vk.commands[commandName]
|
||||
# Make sure list is unique
|
||||
command.extensions.extend([extension] if extension not in command.extensions else [])
|
||||
extension.commands.extend([command] if command not in extension.commands else [])
|
||||
|
||||
# While genGroup() will call twice with aliased value, it does not provide all the information we need
|
||||
dict = self.featureDictionary[extension.name]['enumconstant']
|
||||
for required in dict:
|
||||
# group can be a Enum or Bitmask
|
||||
for group in dict[required]:
|
||||
if group in self.vk.enums:
|
||||
if group not in extension.enumFields:
|
||||
extension.enumFields[group] = [] # Dict needs init
|
||||
enum = self.vk.enums[group]
|
||||
# Need to convert all alias so they match what is in EnumField
|
||||
enumList = list(map(lambda x: x if x not in self.enumFieldAliasMap else self.enumFieldAliasMap[x], dict[required][group]))
|
||||
|
||||
for enumField in [x for x in enum.fields if x.name in enumList]:
|
||||
# Make sure list is unique
|
||||
enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
|
||||
enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
|
||||
extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else [])
|
||||
if group in self.vk.bitmasks:
|
||||
if group not in extension.flags:
|
||||
extension.flags[group] = [] # Dict needs init
|
||||
bitmask = self.vk.bitmasks[group]
|
||||
# Need to convert all alias so they match what is in Flags
|
||||
flagList = list(map(lambda x: x if x not in self.flagAliasMap else self.flagAliasMap[x], dict[required][group]))
|
||||
|
||||
for flags in [x for x in bitmask.flags if x.name in flagList]:
|
||||
# Make sure list is unique
|
||||
bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
|
||||
flags.extensions.extend([extension] if extension not in flags.extensions else [])
|
||||
extension.flags[group].extend([flags] if flags not in extension.flags[group] else [])
|
||||
|
||||
# Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions
|
||||
#
|
||||
# Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed
|
||||
# This information seems to be implicit, so need to update it here
|
||||
# Go through each Flag and append the Enum extension to it
|
||||
#
|
||||
# ex. VkAccelerationStructureTypeKHR where GENERIC_KHR is not allowed with just VK_NV_ray_tracing
|
||||
# This only works because the values are aliased as well, making the KHR a superset enum
|
||||
for extension in self.vk.extensions.values():
|
||||
dict = self.featureDictionary[extension.name]['enum']
|
||||
for required in dict:
|
||||
for group in dict[required]:
|
||||
for enumName in dict[required][group]:
|
||||
isAlias = enumName in self.enumAliasMap
|
||||
enumName = self.enumAliasMap[enumName] if isAlias else enumName
|
||||
if enumName in self.vk.enums:
|
||||
enum = self.vk.enums[enumName]
|
||||
enum.extensions.extend([extension] if extension not in enum.extensions else [])
|
||||
extension.enums.extend([enum] if enum not in extension.enums else [])
|
||||
# Update fields with implicit base extension
|
||||
if isAlias:
|
||||
continue
|
||||
enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
|
||||
for enumField in [x for x in enum.fields if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]:
|
||||
enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
|
||||
if enumName not in extension.enumFields:
|
||||
extension.enumFields[enumName] = [] # Dict needs init
|
||||
extension.enumFields[enumName].extend([enumField] if enumField not in extension.enumFields[enumName] else [])
|
||||
|
||||
dict = self.featureDictionary[extension.name]['bitmask']
|
||||
for required in dict:
|
||||
for group in dict[required]:
|
||||
for bitmaskName in dict[required][group]:
|
||||
bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags is not repeated in name
|
||||
isAlias = bitmaskName in self.bitmaskAliasMap
|
||||
bitmaskName = self.bitmaskAliasMap[bitmaskName] if isAlias else bitmaskName
|
||||
if bitmaskName in self.vk.bitmasks:
|
||||
bitmask = self.vk.bitmasks[bitmaskName]
|
||||
bitmask.extensions.extend([extension] if extension not in bitmask.extensions else [])
|
||||
extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else [])
|
||||
# Update flags with implicit base extension
|
||||
if isAlias:
|
||||
continue
|
||||
bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
|
||||
for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]:
|
||||
flag.extensions.extend([extension] if extension not in flag.extensions else [])
|
||||
if bitmaskName not in extension.flags:
|
||||
extension.flags[bitmaskName] = [] # Dict needs init
|
||||
extension.flags[bitmaskName].extend([flag] if flag not in extension.flags[bitmaskName] else [])
|
||||
|
||||
# Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
|
||||
for extension in self.vk.extensions.values():
|
||||
dict = self.featureDictionary[extension.name]['struct']
|
||||
for required in dict:
|
||||
for group in dict[required]:
|
||||
for structName in dict[required][group]:
|
||||
isAlias = structName in self.structAliasMap
|
||||
structName = self.structAliasMap[structName] if isAlias else structName
|
||||
# An EXT struct can alias a KHR struct,
|
||||
# that in turns aliaes a core struct
|
||||
# => Try to propagate aliasing, it can safely result in a no-op
|
||||
isAlias = structName in self.structAliasMap
|
||||
structName = self.structAliasMap[structName] if isAlias else structName
|
||||
if structName in self.vk.structs:
|
||||
struct = self.vk.structs[structName]
|
||||
struct.extensions.extend([extension] if extension not in struct.extensions else [])
|
||||
|
||||
# While we update struct alias inside other structs, the command itself might have the struct as a first level param.
|
||||
# We use this time to update params to have the promoted name
|
||||
# Example - https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/9322
|
||||
for command in self.vk.commands.values():
|
||||
for member in command.params:
|
||||
if member.type in self.structAliasMap:
|
||||
member.type = self.structAliasMap[member.type]
|
||||
|
||||
# Could build up a reverse lookup map, but since these are not too large of list, just do here
|
||||
# (Need to be done after we have found all the aliases)
|
||||
for key, value in self.structAliasMap.items():
|
||||
self.vk.structs[value].aliases.append(key)
|
||||
for key, value in self.enumAliasMap.items():
|
||||
self.vk.enums[value].aliases.append(key)
|
||||
for key, value in self.bitmaskAliasMap.items():
|
||||
self.vk.bitmasks[value].aliases.append(key)
|
||||
for key, value in self.handleAliasMap.items():
|
||||
self.vk.handles[value].aliases.append(key)
|
||||
|
||||
def endFile(self):
|
||||
# This is the point were reg.py has ran, everything is collected
|
||||
# We do some post processing now
|
||||
self.applyExtensionDependency()
|
||||
|
||||
# Use structs and commands to find which things are returnedOnly
|
||||
for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]:
|
||||
for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]:
|
||||
enum.returnedOnly = False
|
||||
for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]:
|
||||
bitmask.returnedOnly = False
|
||||
for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in struct.members if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
|
||||
bitmask.returnedOnly = False
|
||||
for command in self.vk.commands.values():
|
||||
for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]:
|
||||
enum.returnedOnly = False
|
||||
for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]:
|
||||
bitmask.returnedOnly = False
|
||||
for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in command.params if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
|
||||
bitmask.returnedOnly = False
|
||||
|
||||
# Turn handle parents into pointers to classes
|
||||
for handle in [x for x in self.vk.handles.values() if x.parent is not None]:
|
||||
handle.parent = self.vk.handles[handle.parent]
|
||||
# search up parent chain to see if instance or device
|
||||
for handle in [x for x in self.vk.handles.values()]:
|
||||
next_parent = handle.parent
|
||||
while (not handle.instance and not handle.device):
|
||||
handle.instance = next_parent.name == 'VkInstance'
|
||||
handle.device = next_parent.name == 'VkDevice'
|
||||
next_parent = next_parent.parent
|
||||
|
||||
maxSyncSupport.queues = Queues.ALL
|
||||
maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
|
||||
maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags
|
||||
maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
|
||||
|
||||
# All inherited generators should run from here
|
||||
self.generate()
|
||||
|
||||
if cachingEnabled:
|
||||
cachePath = os.path.join(tempfile.gettempdir(), f'vkobject_{os.getpid()}')
|
||||
if not os.path.isfile(cachePath):
|
||||
cacheFile = open(cachePath, 'wb')
|
||||
pickle.dump(self.vk, cacheFile)
|
||||
cacheFile.close()
|
||||
|
||||
# This should not have to do anything but call into OutputGenerator
|
||||
OutputGenerator.endFile(self)
|
||||
|
||||
#
|
||||
# Bypass the entire processing and load in the VkObject data
|
||||
# Still need to handle the beingFile/endFile for reg.py
|
||||
def generateFromCache(self, cacheVkObjectData, genOpts):
|
||||
OutputGenerator.beginFile(self, genOpts)
|
||||
self.filename = genOpts.filename
|
||||
self.vk = cacheVkObjectData
|
||||
self.generate()
|
||||
OutputGenerator.endFile(self)
|
||||
|
||||
#
|
||||
# Processing point at beginning of each extension definition
|
||||
def beginFeature(self, interface, emit):
|
||||
OutputGenerator.beginFeature(self, interface, emit)
|
||||
platform = interface.get('platform')
|
||||
self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None
|
||||
protect = self.vk.platforms[platform] if platform in self.vk.platforms else None
|
||||
name = interface.get('name')
|
||||
|
||||
if interface.tag == 'extension':
|
||||
instance = interface.get('type') == 'instance'
|
||||
device = not instance
|
||||
depends = interface.get('depends')
|
||||
vendorTag = interface.get('author')
|
||||
platform = interface.get('platform')
|
||||
provisional = boolGet(interface, 'provisional')
|
||||
promotedto = interface.get('promotedto')
|
||||
deprecatedby = interface.get('deprecatedby')
|
||||
obsoletedby = interface.get('obsoletedby')
|
||||
specialuse = splitIfGet(interface, 'specialuse')
|
||||
# Not sure if better way to get this info
|
||||
specVersion = self.featureDictionary[name]['enumconstant'][None][None][0]
|
||||
nameString = self.featureDictionary[name]['enumconstant'][None][None][1]
|
||||
|
||||
self.currentExtension = Extension(name, nameString, specVersion, instance, device, depends, vendorTag,
|
||||
platform, protect, provisional, promotedto, deprecatedby,
|
||||
obsoletedby, specialuse)
|
||||
self.vk.extensions[name] = self.currentExtension
|
||||
else: # version
|
||||
number = interface.get('number')
|
||||
if number != '1.0':
|
||||
self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name)
|
||||
self.vk.versions[name] = self.currentVersion
|
||||
|
||||
def endFeature(self):
|
||||
OutputGenerator.endFeature(self)
|
||||
self.currentExtension = None
|
||||
self.currentVersion = None
|
||||
|
||||
#
|
||||
# All <command> from XML
|
||||
def genCmd(self, cmdinfo, name, alias):
|
||||
OutputGenerator.genCmd(self, cmdinfo, name, alias)
|
||||
|
||||
params = []
|
||||
for param in cmdinfo.elem.findall('param'):
|
||||
paramName = param.find('name').text
|
||||
paramType = textIfFind(param, 'type')
|
||||
paramAlias = param.get('alias')
|
||||
|
||||
cdecl = self.makeCParamDecl(param, 0)
|
||||
paramFullType = ' '.join(cdecl.split()[:-1])
|
||||
pointer = '*' in cdecl or paramType.startswith('PFN_')
|
||||
paramConst = 'const' in cdecl
|
||||
fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
|
||||
|
||||
paramNoautovalidity = boolGet(param, 'noautovalidity')
|
||||
|
||||
nullTerminated = False
|
||||
length = param.get('altlen') if param.get('altlen') is not None else param.get('len')
|
||||
if length:
|
||||
# we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
|
||||
# This finds both
|
||||
nullTerminated = 'null-terminated' in length
|
||||
length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
|
||||
length = None if length == 'null-terminated' else length
|
||||
|
||||
if fixedSizeArray and not length:
|
||||
length = ','.join(fixedSizeArray)
|
||||
|
||||
# See Member::optional code for details of this
|
||||
optionalValues = splitIfGet(param, 'optional')
|
||||
optional = optionalValues is not None and optionalValues[0].lower() == "true"
|
||||
optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
|
||||
|
||||
# externsync will be 'true' or expression
|
||||
# if expression, it should be same as 'true'
|
||||
externSync = boolGet(param, 'externsync')
|
||||
externSyncPointer = None if externSync else splitIfGet(param, 'externsync')
|
||||
if not externSync and externSyncPointer is not None:
|
||||
externSync = True
|
||||
|
||||
params.append(Param(paramName, paramAlias, paramType, paramFullType, paramNoautovalidity,
|
||||
paramConst, length, nullTerminated, pointer, fixedSizeArray,
|
||||
optional, optionalPointer,
|
||||
externSync, externSyncPointer, cdecl))
|
||||
|
||||
attrib = cmdinfo.elem.attrib
|
||||
alias = attrib.get('alias')
|
||||
tasks = splitIfGet(attrib, 'tasks')
|
||||
|
||||
queues = getQueues(attrib)
|
||||
successcodes = splitIfGet(attrib, 'successcodes')
|
||||
errorcodes = splitIfGet(attrib, 'errorcodes')
|
||||
cmdbufferlevel = attrib.get('cmdbufferlevel')
|
||||
primary = cmdbufferlevel is not None and 'primary' in cmdbufferlevel
|
||||
secondary = cmdbufferlevel is not None and 'secondary' in cmdbufferlevel
|
||||
|
||||
renderpass = attrib.get('renderpass')
|
||||
renderpass = CommandScope.NONE if renderpass is None else getattr(CommandScope, renderpass.upper())
|
||||
videocoding = attrib.get('videocoding')
|
||||
videocoding = CommandScope.NONE if videocoding is None else getattr(CommandScope, videocoding.upper())
|
||||
|
||||
protoElem = cmdinfo.elem.find('proto')
|
||||
returnType = textIfFind(protoElem, 'type')
|
||||
|
||||
decls = self.makeCDecls(cmdinfo.elem)
|
||||
cPrototype = decls[0]
|
||||
cFunctionPointer = decls[1]
|
||||
|
||||
protect = self.currentExtension.protect if self.currentExtension is not None else None
|
||||
|
||||
# These coammds have no way from the XML to detect they would be an instance command
|
||||
specialInstanceCommand = ['vkCreateInstance', 'vkEnumerateInstanceExtensionProperties','vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion']
|
||||
instance = len(params) > 0 and (params[0].type == 'VkInstance' or params[0].type == 'VkPhysicalDevice' or name in specialInstanceCommand)
|
||||
device = not instance
|
||||
|
||||
implicitElem = cmdinfo.elem.find('implicitexternsyncparams')
|
||||
implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem else []
|
||||
|
||||
self.vk.commands[name] = Command(name, alias, protect, [], self.currentVersion,
|
||||
returnType, params, instance, device,
|
||||
tasks, queues, successcodes, errorcodes,
|
||||
primary, secondary, renderpass, videocoding,
|
||||
implicitExternSyncParams, cPrototype, cFunctionPointer)
|
||||
|
||||
#
|
||||
# List the enum for the commands
|
||||
# TODO - Seems empty groups like `VkDeviceDeviceMemoryReportCreateInfoEXT` do not show up in here
|
||||
def genGroup(self, groupinfo, groupName, alias):
|
||||
# There can be case where the Enum/Bitmask is in a protect, but the individual
|
||||
# fields also have their own protect
|
||||
groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
|
||||
enumElem = groupinfo.elem
|
||||
bitwidth = 32 if enumElem.get('bitwidth') is None else int(enumElem.get('bitwidth'))
|
||||
fields = []
|
||||
if enumElem.get('type') == "enum":
|
||||
if alias is not None:
|
||||
self.enumAliasMap[groupName] = alias
|
||||
return
|
||||
|
||||
for elem in enumElem.findall('enum'):
|
||||
fieldName = elem.get('name')
|
||||
|
||||
if elem.get('alias') is not None:
|
||||
self.enumFieldAliasMap[fieldName] = elem.get('alias')
|
||||
continue
|
||||
|
||||
negative = elem.get('dir') is not None
|
||||
protect = elem.get('protect')
|
||||
(valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)
|
||||
|
||||
# Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
|
||||
# genGroup() lists them twice
|
||||
if next((x for x in fields if x.name == fieldName), None) is None:
|
||||
fields.append(EnumField(fieldName, protect, negative, valueInt, valueStr, []))
|
||||
|
||||
self.vk.enums[groupName] = Enum(groupName, [], groupProtect, bitwidth, True, fields, [], [])
|
||||
|
||||
else: # "bitmask"
|
||||
if alias is not None:
|
||||
self.bitmaskAliasMap[groupName] = alias
|
||||
return
|
||||
|
||||
for elem in enumElem.findall('enum'):
|
||||
flagName = elem.get('name')
|
||||
|
||||
if elem.get('alias') is not None:
|
||||
self.flagAliasMap[flagName] = elem.get('alias')
|
||||
continue
|
||||
|
||||
protect = elem.get('protect')
|
||||
|
||||
(valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)
|
||||
flagZero = valueInt == 0
|
||||
flagMultiBit = False
|
||||
# if flag uses 'value' instead of 'bitpos', will be zero or a mask
|
||||
if elem.get('bitpos') is None and elem.get('value'):
|
||||
flagMultiBit = valueInt != 0
|
||||
|
||||
# Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
|
||||
# genGroup() lists them twice
|
||||
if next((x for x in fields if x.name == flagName), None) is None:
|
||||
fields.append(Flag(flagName, protect, valueInt, valueStr, flagMultiBit, flagZero, []))
|
||||
|
||||
flagName = groupName.replace('FlagBits', 'Flags')
|
||||
self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], [])
|
||||
|
||||
def genType(self, typeInfo, typeName, alias):
|
||||
OutputGenerator.genType(self, typeInfo, typeName, alias)
|
||||
typeElem = typeInfo.elem
|
||||
protect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
|
||||
category = typeElem.get('category')
|
||||
if (category == 'struct' or category == 'union'):
|
||||
extension = [self.currentExtension] if self.currentExtension is not None else []
|
||||
if alias is not None:
|
||||
self.structAliasMap[typeName] = alias
|
||||
return
|
||||
|
||||
union = category == 'union'
|
||||
|
||||
returnedOnly = boolGet(typeElem, 'returnedonly')
|
||||
allowDuplicate = boolGet(typeElem, 'allowduplicate')
|
||||
|
||||
extends = splitIfGet(typeElem, 'structextends')
|
||||
extendedBy = self.registry.validextensionstructs[typeName] if len(self.registry.validextensionstructs[typeName]) > 0 else None
|
||||
|
||||
membersElem = typeInfo.elem.findall('.//member')
|
||||
members = []
|
||||
sType = None
|
||||
|
||||
for member in membersElem:
|
||||
for comment in member.findall('comment'):
|
||||
member.remove(comment)
|
||||
|
||||
name = textIfFind(member, 'name')
|
||||
type = textIfFind(member, 'type')
|
||||
sType = member.get('values') if member.get('values') is not None else sType
|
||||
externSync = boolGet(member, 'externsync')
|
||||
noautovalidity = boolGet(member, 'noautovalidity')
|
||||
limittype = member.get('limittype')
|
||||
|
||||
nullTerminated = False
|
||||
length = member.get('altlen') if member.get('altlen') is not None else member.get('len')
|
||||
if length:
|
||||
# we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
|
||||
# This finds both
|
||||
nullTerminated = 'null-terminated' in length
|
||||
length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
|
||||
length = None if length == 'null-terminated' else length
|
||||
|
||||
cdecl = self.makeCParamDecl(member, 0)
|
||||
fullType = ' '.join(cdecl.split()[:-1])
|
||||
pointer = '*' in cdecl or type.startswith('PFN_')
|
||||
const = 'const' in cdecl
|
||||
# Some structs like VkTransformMatrixKHR have a 2D array
|
||||
fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
|
||||
|
||||
if fixedSizeArray and not length:
|
||||
length = ','.join(fixedSizeArray)
|
||||
|
||||
# if a pointer, this can be a something like:
|
||||
# optional="true,false" for ppGeometries
|
||||
# optional="false,true" for pPhysicalDeviceCount
|
||||
# the first is if the variable itself is optional
|
||||
# the second is the value of the pointer is optional;
|
||||
optionalValues = splitIfGet(member, 'optional')
|
||||
optional = optionalValues is not None and optionalValues[0].lower() == "true"
|
||||
optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
|
||||
|
||||
members.append(Member(name, type, fullType, noautovalidity, limittype,
|
||||
const, length, nullTerminated, pointer, fixedSizeArray,
|
||||
optional, optionalPointer,
|
||||
externSync, cdecl))
|
||||
|
||||
self.vk.structs[typeName] = Struct(typeName, [], extension, self.currentVersion, protect, members,
|
||||
union, returnedOnly, sType, allowDuplicate, extends, extendedBy)
|
||||
|
||||
elif category == 'handle':
|
||||
if alias is not None:
|
||||
self.handleAliasMap[typeName] = alias
|
||||
return
|
||||
type = typeElem.get('objtypeenum')
|
||||
|
||||
# will resolve these later, the VulkanObjectType does not list things in dependent order
|
||||
parent = typeElem.get('parent')
|
||||
instance = typeName == 'VkInstance'
|
||||
device = typeName == 'VkDevice'
|
||||
|
||||
dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE'
|
||||
|
||||
self.vk.handles[typeName] = Handle(typeName, [], type, protect, parent, instance, device, dispatchable)
|
||||
|
||||
elif category == 'define':
|
||||
if typeName == 'VK_HEADER_VERSION':
|
||||
self.vk.headerVersion = typeElem.find('name').tail.strip()
|
||||
|
||||
else:
|
||||
# not all categories are used
|
||||
# 'group'/'enum'/'bitmask' are routed to genGroup instead
|
||||
# 'basetype'/'include' are only for headers
|
||||
# 'funcpointer` ignore until needed
|
||||
return
|
||||
|
||||
def genSpirv(self, spirvinfo, spirvName, alias):
|
||||
OutputGenerator.genSpirv(self, spirvinfo, spirvName, alias)
|
||||
spirvElem = spirvinfo.elem
|
||||
name = spirvElem.get('name')
|
||||
extension = True if spirvElem.tag == 'spirvextension' else False
|
||||
capability = not extension
|
||||
|
||||
enables = []
|
||||
for elem in spirvElem:
|
||||
version = elem.attrib.get('version')
|
||||
extensionEnable = elem.attrib.get('extension')
|
||||
struct = elem.attrib.get('struct')
|
||||
feature = elem.attrib.get('feature')
|
||||
requires = elem.attrib.get('requires')
|
||||
propertyEnable = elem.attrib.get('property')
|
||||
member = elem.attrib.get('member')
|
||||
value = elem.attrib.get('value')
|
||||
enables.append(SpirvEnables(version, extensionEnable, struct, feature,
|
||||
requires, propertyEnable, member, value))
|
||||
|
||||
self.vk.spirv.append(Spirv(name, extension, capability, enables))
|
||||
|
||||
def genFormat(self, format, formatinfo, alias):
|
||||
OutputGenerator.genFormat(self, format, formatinfo, alias)
|
||||
formatElem = format.elem
|
||||
name = formatElem.get('name')
|
||||
|
||||
components = []
|
||||
for component in formatElem.iterfind('component'):
|
||||
type = component.get('name')
|
||||
bits = component.get('bits')
|
||||
numericFormat = component.get('numericFormat')
|
||||
planeIndex = intIfGet(component, 'planeIndex')
|
||||
components.append(FormatComponent(type, bits, numericFormat, planeIndex))
|
||||
|
||||
planes = []
|
||||
for plane in formatElem.iterfind('plane'):
|
||||
index = int(plane.get('index'))
|
||||
widthDivisor = int(plane.get('widthDivisor'))
|
||||
heightDivisor = int(plane.get('heightDivisor'))
|
||||
compatible = plane.get('compatible')
|
||||
planes.append(FormatPlane(index, widthDivisor, heightDivisor, compatible))
|
||||
|
||||
className = formatElem.get('class')
|
||||
blockSize = int(formatElem.get('blockSize'))
|
||||
texelsPerBlock = int(formatElem.get('texelsPerBlock'))
|
||||
blockExtent = splitIfGet(formatElem, 'blockExtent')
|
||||
packed = intIfGet(formatElem, 'packed')
|
||||
chroma = formatElem.get('chroma')
|
||||
compressed = formatElem.get('compressed')
|
||||
spirvImageFormat = formatElem.find('spirvimageformat')
|
||||
if spirvImageFormat is not None:
|
||||
spirvImageFormat = spirvImageFormat.get('name')
|
||||
|
||||
self.vk.formats[name] = Format(name, className, blockSize, texelsPerBlock,
|
||||
blockExtent, packed, chroma, compressed,
|
||||
components, planes, spirvImageFormat)
|
||||
|
||||
def genSyncStage(self, sync):
|
||||
OutputGenerator.genSyncStage(self, sync)
|
||||
syncElem = sync.elem
|
||||
|
||||
support = maxSyncSupport
|
||||
supportElem = syncElem.find('syncsupport')
|
||||
if supportElem is not None:
|
||||
queues = getQueues(supportElem)
|
||||
stageNames = splitIfGet(supportElem, 'stage')
|
||||
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
|
||||
support = SyncSupport(queues, stages, False)
|
||||
|
||||
equivalent = maxSyncEquivalent
|
||||
equivalentElem = syncElem.find('syncequivalent')
|
||||
if equivalentElem is not None:
|
||||
stageNames = splitIfGet(equivalentElem, 'stage')
|
||||
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
|
||||
accessNames = splitIfGet(equivalentElem, 'access')
|
||||
accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
|
||||
equivalent = SyncEquivalent(stages, accesses, False)
|
||||
|
||||
flagName = syncElem.get('name')
|
||||
flag = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name == flagName]
|
||||
# This check is needed because not all API variants have VK_KHR_synchronization2
|
||||
if flag:
|
||||
self.vk.syncStage.append(SyncStage(flag[0], support, equivalent))
|
||||
|
||||
def genSyncAccess(self, sync):
|
||||
OutputGenerator.genSyncAccess(self, sync)
|
||||
syncElem = sync.elem
|
||||
|
||||
support = maxSyncSupport
|
||||
supportElem = syncElem.find('syncsupport')
|
||||
if supportElem is not None:
|
||||
queues = getQueues(supportElem)
|
||||
stageNames = splitIfGet(supportElem, 'stage')
|
||||
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
|
||||
support = SyncSupport(queues, stages, False)
|
||||
|
||||
equivalent = maxSyncEquivalent
|
||||
equivalentElem = syncElem.find('syncequivalent')
|
||||
if equivalentElem is not None:
|
||||
stageNames = splitIfGet(equivalentElem, 'stage')
|
||||
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
|
||||
accessNames = splitIfGet(equivalentElem, 'access')
|
||||
accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
|
||||
equivalent = SyncEquivalent(stages, accesses, False)
|
||||
|
||||
flagName = syncElem.get('name')
|
||||
flag = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name == flagName]
|
||||
# This check is needed because not all API variants have VK_KHR_synchronization2
|
||||
if flag:
|
||||
self.vk.syncAccess.append(SyncAccess(flag[0], support, equivalent))
|
||||
|
||||
def genSyncPipeline(self, sync):
|
||||
OutputGenerator.genSyncPipeline(self, sync)
|
||||
syncElem = sync.elem
|
||||
name = syncElem.get('name')
|
||||
depends = splitIfGet(syncElem, 'depends')
|
||||
stages = []
|
||||
for stageElem in syncElem.findall('syncpipelinestage'):
|
||||
order = stageElem.get('order')
|
||||
before = stageElem.get('before')
|
||||
after = stageElem.get('after')
|
||||
value = stageElem.text
|
||||
stages.append(SyncPipelineStage(order, before, after, value))
|
||||
|
||||
self.vk.syncPipeline.append(SyncPipeline(name, depends, stages))
|
||||
|
|
@ -242,7 +242,7 @@ class COutputGenerator(OutputGenerator):
|
|||
raise MissingGeneratorOptionsError()
|
||||
if self.genOpts.conventions is None:
|
||||
raise MissingGeneratorOptionsConventionsError()
|
||||
is_core = self.featureName and self.featureName.startswith(f"{self.conventions.api_prefix}VERSION_")
|
||||
is_core = self.featureName and self.featureName.startswith(self.conventions.api_prefix + 'VERSION_')
|
||||
if self.genOpts.conventions.writeFeature(self.featureName, self.featureExtraProtect, self.genOpts.filename):
|
||||
self.newline()
|
||||
if self.genOpts.protectFeature:
|
||||
|
|
@ -340,7 +340,7 @@ class COutputGenerator(OutputGenerator):
|
|||
# OpenXR: this section was not under 'else:' previously, just fell through
|
||||
if alias:
|
||||
# If the type is an alias, just emit a typedef declaration
|
||||
body += f"typedef {alias} {name};\n"
|
||||
body += 'typedef ' + alias + ' ' + name + ';\n'
|
||||
else:
|
||||
# Replace <apientry /> tags with an APIENTRY-style string
|
||||
# (from self.genOpts). Copy other text through unchanged.
|
||||
|
|
@ -373,13 +373,13 @@ class COutputGenerator(OutputGenerator):
|
|||
|
||||
if ',' in protect_str:
|
||||
protect_list = protect_str.split(',')
|
||||
protect_defs = (f'defined({d})' for d in protect_list)
|
||||
protect_defs = ('defined(%s)' % d for d in protect_list)
|
||||
protect_def_str = ' && '.join(protect_defs)
|
||||
protect_if_str = f'#if {protect_def_str}\n'
|
||||
protect_end_str = f'#endif // {protect_def_str}\n'
|
||||
protect_if_str = '#if %s\n' % protect_def_str
|
||||
protect_end_str = '#endif // %s\n' % protect_def_str
|
||||
else:
|
||||
protect_if_str = f'#ifdef {protect_str}\n'
|
||||
protect_end_str = f'#endif // {protect_str}\n'
|
||||
protect_if_str = '#ifdef %s\n' % protect_str
|
||||
protect_end_str = '#endif // %s\n' % protect_str
|
||||
|
||||
return (protect_if_str, protect_end_str)
|
||||
|
||||
|
|
@ -423,7 +423,7 @@ class COutputGenerator(OutputGenerator):
|
|||
body = self.deprecationComment(typeElem)
|
||||
|
||||
if alias:
|
||||
body += f"typedef {alias} {typeName};\n"
|
||||
body += 'typedef ' + alias + ' ' + typeName + ';\n'
|
||||
else:
|
||||
(protect_begin, protect_end) = self.genProtectString(typeElem.get('protect'))
|
||||
if protect_begin:
|
||||
|
|
@ -431,24 +431,24 @@ class COutputGenerator(OutputGenerator):
|
|||
|
||||
if self.genOpts.genStructExtendsComment:
|
||||
structextends = typeElem.get('structextends')
|
||||
body += f"// {typeName} extends {structextends}\n" if structextends else ''
|
||||
body += '// ' + typeName + ' extends ' + structextends + '\n' if structextends else ''
|
||||
|
||||
body += f"typedef {typeElem.get('category')}"
|
||||
body += 'typedef ' + typeElem.get('category')
|
||||
|
||||
# This is an OpenXR-specific alternative where aliasing refers
|
||||
# to an inheritance hierarchy of types rather than C-level type
|
||||
# aliases.
|
||||
if self.genOpts.genAliasMacro and self.typeMayAlias(typeName):
|
||||
body += f" {self.genOpts.aliasMacro}"
|
||||
body += ' ' + self.genOpts.aliasMacro
|
||||
|
||||
body += f" {typeName} {{\n"
|
||||
body += ' ' + typeName + ' {\n'
|
||||
|
||||
targetLen = self.getMaxCParamTypeLength(typeinfo)
|
||||
for member in typeElem.findall('.//member'):
|
||||
body += self.deprecationComment(member, indent = 4)
|
||||
body += self.makeCParamDecl(member, targetLen + 4)
|
||||
body += ';\n'
|
||||
body += f"}} {typeName};\n"
|
||||
body += '} ' + typeName + ';\n'
|
||||
if protect_end:
|
||||
body += protect_end
|
||||
|
||||
|
|
@ -474,13 +474,13 @@ class COutputGenerator(OutputGenerator):
|
|||
if alias:
|
||||
# If the group name is aliased, just emit a typedef declaration
|
||||
# for the alias.
|
||||
body = f"typedef {alias} {groupName};\n"
|
||||
body = 'typedef ' + alias + ' ' + groupName + ';\n'
|
||||
self.appendSection(section, body)
|
||||
else:
|
||||
if self.genOpts is None:
|
||||
raise MissingGeneratorOptionsError()
|
||||
(section, body) = self.buildEnumCDecl(self.genOpts.genEnumBeginEndRange, groupinfo, groupName)
|
||||
self.appendSection(section, f"\n{body}")
|
||||
self.appendSection(section, '\n' + body)
|
||||
|
||||
def genEnum(self, enuminfo, name, alias):
|
||||
"""Generate the C declaration for a constant (a single <enum> value).
|
||||
|
|
@ -507,7 +507,7 @@ class COutputGenerator(OutputGenerator):
|
|||
|
||||
prefix = ''
|
||||
decls = self.makeCDecls(cmdinfo.elem)
|
||||
self.appendSection('command', f"{prefix + decls[0]}\n")
|
||||
self.appendSection('command', prefix + decls[0] + '\n')
|
||||
if self.genOpts.genFuncPointers:
|
||||
self.appendSection('commandPointer', decls[1])
|
||||
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ class MissingGeneratorOptionsError(RuntimeError):
|
|||
def __init__(self, msg=None):
|
||||
full_msg = 'Missing generator options object self.genOpts'
|
||||
if msg:
|
||||
full_msg += f": {msg}"
|
||||
full_msg += ': ' + msg
|
||||
super().__init__(full_msg)
|
||||
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ class MissingRegistryError(RuntimeError):
|
|||
def __init__(self, msg=None):
|
||||
full_msg = 'Missing Registry object self.registry'
|
||||
if msg:
|
||||
full_msg += f": {msg}"
|
||||
full_msg += ': ' + msg
|
||||
super().__init__(full_msg)
|
||||
|
||||
|
||||
|
|
@ -136,7 +136,7 @@ class MissingGeneratorOptionsConventionsError(RuntimeError):
|
|||
def __init__(self, msg=None):
|
||||
full_msg = 'Missing Conventions object self.genOpts.conventions'
|
||||
if msg:
|
||||
full_msg += f": {msg}"
|
||||
full_msg += ': ' + msg
|
||||
super().__init__(full_msg)
|
||||
|
||||
|
||||
|
|
@ -338,7 +338,7 @@ class OutputGenerator:
|
|||
)
|
||||
|
||||
if name in bad and True:
|
||||
print(f'breakName {name}: {msg}')
|
||||
print('breakName {}: {}'.format(name, msg))
|
||||
pdb.set_trace()
|
||||
|
||||
def __init__(self, errFile=sys.stderr, warnFile=sys.stderr, diagFile=sys.stdout):
|
||||
|
|
@ -399,7 +399,7 @@ class OutputGenerator:
|
|||
write('DIAG:', *args, file=self.diagFile)
|
||||
else:
|
||||
raise UserWarning(
|
||||
f"*** FATAL ERROR in Generator.logMsg: unknown level:{level}")
|
||||
'*** FATAL ERROR in Generator.logMsg: unknown level:' + level)
|
||||
|
||||
def enumToValue(self, elem, needsNum, bitwidth = 32,
|
||||
forceSuffix = False, parent_for_alias_dereference=None):
|
||||
|
|
@ -452,20 +452,20 @@ class OutputGenerator:
|
|||
# value += enuminfo.type
|
||||
if forceSuffix:
|
||||
if bitwidth == 64:
|
||||
value = f"{value}ULL"
|
||||
value = value + 'ULL'
|
||||
else:
|
||||
value = f"{value}U"
|
||||
value = value + 'U'
|
||||
self.logMsg('diag', 'Enum', name, '-> value [', numVal, ',', value, ']')
|
||||
return [numVal, value]
|
||||
if 'bitpos' in elem.keys():
|
||||
value = elem.get('bitpos')
|
||||
bitpos = int(value, 0)
|
||||
numVal = 1 << bitpos
|
||||
value = f'0x{numVal:08x}'
|
||||
value = '0x%08x' % numVal
|
||||
if bitwidth == 64 or bitpos >= 32:
|
||||
value = f"{value}ULL"
|
||||
value = value + 'ULL'
|
||||
elif forceSuffix:
|
||||
value = f"{value}U"
|
||||
value = value + 'U'
|
||||
self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']')
|
||||
return [numVal, value]
|
||||
if 'offset' in elem.keys():
|
||||
|
|
@ -655,12 +655,12 @@ class OutputGenerator:
|
|||
flagTypeName = groupElem.get('name')
|
||||
|
||||
# Prefix
|
||||
body = f"// Flag bits for {flagTypeName}\n"
|
||||
body = "// Flag bits for " + flagTypeName + "\n"
|
||||
|
||||
if bitwidth == 64:
|
||||
body += f"typedef VkFlags64 {flagTypeName};\n";
|
||||
body += "typedef VkFlags64 %s;\n" % flagTypeName;
|
||||
else:
|
||||
body += f"typedef VkFlags {flagTypeName};\n";
|
||||
body += "typedef VkFlags %s;\n" % flagTypeName;
|
||||
|
||||
# Maximum allowable value for a flag (unsigned 64-bit integer)
|
||||
maxValidValue = 2**(64) - 1
|
||||
|
|
@ -697,25 +697,25 @@ class OutputGenerator:
|
|||
if self.isEnumRequired(elem):
|
||||
protect = elem.get('protect')
|
||||
if protect is not None:
|
||||
body += f'#ifdef {protect}\n'
|
||||
body += '#ifdef {}\n'.format(protect)
|
||||
|
||||
body += self.deprecationComment(elem, indent = 0)
|
||||
|
||||
if usedefine:
|
||||
decl += f"#define {name} {strVal}\n"
|
||||
decl += "#define {} {}\n".format(name, strVal)
|
||||
elif self.misracppstyle():
|
||||
decl += f"static constexpr {flagTypeName} {name} {{{strVal}}};\n"
|
||||
decl += "static constexpr {} {} {{{}}};\n".format(flagTypeName, name, strVal)
|
||||
else:
|
||||
# Some C compilers only allow initializing a 'static const' variable with a literal value.
|
||||
# So initializing an alias from another 'static const' value would fail to compile.
|
||||
# Work around this by chasing the aliases to get the actual value.
|
||||
while numVal is None:
|
||||
alias = self.registry.tree.find(f"enums/enum[@name='{strVal}']")
|
||||
alias = self.registry.tree.find("enums/enum[@name='" + strVal + "']")
|
||||
if alias is not None:
|
||||
(numVal, strVal) = self.enumToValue(alias, True, bitwidth, True)
|
||||
else:
|
||||
self.logMsg('error', f'No such alias {strVal} for enum {name}')
|
||||
decl += f"static const {flagTypeName} {name} = {strVal};\n"
|
||||
self.logMsg('error', 'No such alias {} for enum {}'.format(strVal, name))
|
||||
decl += "static const {} {} = {};\n".format(flagTypeName, name, strVal)
|
||||
|
||||
if numVal is not None:
|
||||
body += decl
|
||||
|
|
@ -743,7 +743,7 @@ class OutputGenerator:
|
|||
expandSuffix = ''
|
||||
expandSuffixMatch = re.search(r'[A-Z][A-Z]+$', groupName)
|
||||
if expandSuffixMatch:
|
||||
expandSuffix = f"_{expandSuffixMatch.group()}"
|
||||
expandSuffix = '_' + expandSuffixMatch.group()
|
||||
# Strip off the suffix from the prefix
|
||||
expandPrefix = expandName.rsplit(expandSuffix, 1)[0]
|
||||
|
||||
|
|
@ -792,12 +792,12 @@ class OutputGenerator:
|
|||
|
||||
protect = elem.get('protect')
|
||||
if protect is not None:
|
||||
decl += f'#ifdef {protect}\n'
|
||||
decl += '#ifdef {}\n'.format(protect)
|
||||
|
||||
|
||||
decl += self.genRequirements(name, mustBeFound = False, indent = 2)
|
||||
decl += self.deprecationComment(elem, indent = 2)
|
||||
decl += f' {name} = {strVal},'
|
||||
decl += ' {} = {},'.format(name, strVal)
|
||||
|
||||
if protect is not None:
|
||||
decl += '\n#endif'
|
||||
|
|
@ -868,8 +868,8 @@ class OutputGenerator:
|
|||
if typeStr != "float":
|
||||
number += 'U'
|
||||
strVal = "~" if invert else ""
|
||||
strVal += f"static_cast<{typeStr}>({number})"
|
||||
body = f"static constexpr {typeStr.ljust(9)}{name.ljust(33)} {{{strVal}}};"
|
||||
strVal += "static_cast<" + typeStr + ">(" + number + ")"
|
||||
body = 'static constexpr ' + typeStr.ljust(9) + name.ljust(33) + ' {' + strVal + '};'
|
||||
elif enuminfo.elem.get('type') and not alias:
|
||||
# Generate e.g.: #define x (~0ULL)
|
||||
typeStr = enuminfo.elem.get('type');
|
||||
|
|
@ -884,10 +884,10 @@ class OutputGenerator:
|
|||
strVal = "~" if invert else ""
|
||||
strVal += number
|
||||
if paren:
|
||||
strVal = f"({strVal})";
|
||||
body = f"#define {name.ljust(33)} {strVal}";
|
||||
strVal = "(" + strVal + ")";
|
||||
body = '#define ' + name.ljust(33) + ' ' + strVal;
|
||||
else:
|
||||
body = f"#define {name.ljust(33)} {strVal}"
|
||||
body = '#define ' + name.ljust(33) + ' ' + strVal
|
||||
|
||||
return body
|
||||
|
||||
|
|
@ -1102,7 +1102,7 @@ class OutputGenerator:
|
|||
"""Make the function-pointer typedef name for a command."""
|
||||
if self.genOpts is None:
|
||||
raise MissingGeneratorOptionsError()
|
||||
return f"({self.genOpts.apientryp}PFN_{name}{tail})"
|
||||
return '(' + self.genOpts.apientryp + 'PFN_' + name + tail + ')'
|
||||
|
||||
def makeCParamDecl(self, param, aligncol):
|
||||
"""Return a string which is an indented, formatted
|
||||
|
|
@ -1135,14 +1135,14 @@ class OutputGenerator:
|
|||
# This works around a problem where very long type names -
|
||||
# longer than the alignment column - would run into the tail
|
||||
# text.
|
||||
paramdecl = f"{paramdecl.ljust(aligncol - 1)} "
|
||||
paramdecl = paramdecl.ljust(aligncol - 1) + ' '
|
||||
newLen = len(paramdecl)
|
||||
self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl)
|
||||
|
||||
if (self.misracppstyle() and prefix.find('const ') != -1):
|
||||
# Change pointer type order from e.g. "const void *" to "void const *".
|
||||
# If the string starts with 'const', reorder it to be after the first type.
|
||||
paramdecl += f"{prefix.replace('const ', '') + text} const{tail}"
|
||||
paramdecl += prefix.replace('const ', '') + text + ' const' + tail
|
||||
else:
|
||||
paramdecl += prefix + text + tail
|
||||
|
||||
|
|
@ -1169,7 +1169,7 @@ class OutputGenerator:
|
|||
|
||||
# Allow for missing <name> tag
|
||||
newLen = 0
|
||||
paramdecl = f" {noneStr(param.text)}"
|
||||
paramdecl = ' ' + noneStr(param.text)
|
||||
for elem in param:
|
||||
text = noneStr(elem.text)
|
||||
tail = noneStr(elem.tail)
|
||||
|
|
@ -1400,7 +1400,7 @@ class OutputGenerator:
|
|||
# Change pointer type order from e.g. "const void *" to "void const *".
|
||||
# If the string starts with 'const', reorder it to be after the first type.
|
||||
if (prefix.find('const ') != -1):
|
||||
param += f"{prefix.replace('const ', '') + t} const "
|
||||
param += prefix.replace('const ', '') + t + ' const '
|
||||
else:
|
||||
param += prefix + t
|
||||
# Clear prefix for subsequent iterations
|
||||
|
|
|
|||
|
|
@ -111,7 +111,7 @@ def push_first(toks):
|
|||
exprStack.append(toks[0])
|
||||
|
||||
# An identifier (version, feature boolean, or extension name)
|
||||
dependencyIdent = Word(f"{alphanums}_:")
|
||||
dependencyIdent = Word(alphanums + '_' + ':')
|
||||
|
||||
# Infix expression for depends expressions
|
||||
dependencyExpr = pp.infixNotation(dependencyIdent,
|
||||
|
|
@ -288,7 +288,7 @@ def markupTraverse(expr, level = 0, root = True):
|
|||
- root - True only on initial call"""
|
||||
|
||||
if level > 0:
|
||||
prefix = f"{'{nbsp}{nbsp}' * level * 2} "
|
||||
prefix = '{nbsp}{nbsp}' * level * 2 + ' '
|
||||
else:
|
||||
prefix = ''
|
||||
str = ''
|
||||
|
|
@ -303,9 +303,9 @@ def markupTraverse(expr, level = 0, root = True):
|
|||
|
||||
str = str + markupTraverse(elem, level = nextlevel, root = False)
|
||||
elif elem in ('+', ','):
|
||||
str = f"{str}{prefix}{opMarkupAsciidoc(elem)} +\n"
|
||||
str = str + f'{prefix}{opMarkupAsciidoc(elem)} +\n'
|
||||
else:
|
||||
str = f"{str}{prefix}{leafMarkupAsciidoc(elem)} +\n"
|
||||
str = str + f'{prefix}{leafMarkupAsciidoc(elem)} +\n'
|
||||
|
||||
return str
|
||||
|
||||
|
|
|
|||
|
|
@ -801,7 +801,7 @@ class Registry:
|
|||
if enum.get('alias'):
|
||||
format_name = enum.get('alias')
|
||||
if format_name in format_condition:
|
||||
format_condition[format_name] += f",{featureInfo.name}"
|
||||
format_condition[format_name] += "," + featureInfo.name
|
||||
else:
|
||||
format_condition[format_name] = featureInfo.name
|
||||
elif groupName == "VkPipelineStageFlagBits2":
|
||||
|
|
@ -810,7 +810,7 @@ class Registry:
|
|||
stage_flag = enum.get('alias')
|
||||
featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
|
||||
if stage_flag in sync_pipeline_stage_condition:
|
||||
sync_pipeline_stage_condition[stage_flag] += f",{featureName}"
|
||||
sync_pipeline_stage_condition[stage_flag] += "," + featureName
|
||||
else:
|
||||
sync_pipeline_stage_condition[stage_flag] = featureName
|
||||
elif groupName == "VkAccessFlagBits2":
|
||||
|
|
@ -819,7 +819,7 @@ class Registry:
|
|||
access_flag = enum.get('alias')
|
||||
featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
|
||||
if access_flag in sync_access_condition:
|
||||
sync_access_condition[access_flag] += f",{featureName}"
|
||||
sync_access_condition[access_flag] += "," + featureName
|
||||
else:
|
||||
sync_access_condition[access_flag] = featureName
|
||||
|
||||
|
|
@ -991,7 +991,7 @@ class Registry:
|
|||
# Look up the Info with matching groupName
|
||||
if groupName in self.groupdict:
|
||||
gi = self.groupdict[groupName]
|
||||
gienum = gi.elem.find(f"enum[@name='{enumname}']")
|
||||
gienum = gi.elem.find("enum[@name='" + enumname + "']")
|
||||
if gienum is not None:
|
||||
# Remove copy of this enum from the group
|
||||
gi.elem.remove(gienum)
|
||||
|
|
@ -1207,7 +1207,7 @@ class Registry:
|
|||
self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
|
||||
self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
|
||||
else:
|
||||
self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')
|
||||
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
|
||||
|
||||
|
||||
for enumElem in require.findall('enum'):
|
||||
|
|
@ -1224,7 +1224,7 @@ class Registry:
|
|||
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
|
||||
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
|
||||
else:
|
||||
self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')
|
||||
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
|
||||
|
||||
for cmdElem in require.findall('command'):
|
||||
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
|
||||
|
|
@ -1234,7 +1234,7 @@ class Registry:
|
|||
self.gen.featureDictionary[featurename]['command'][required_key] = []
|
||||
self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
|
||||
else:
|
||||
self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')
|
||||
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
|
||||
|
||||
def requireFeatures(self, interface, featurename, api, profile):
|
||||
"""Process `<require>` tags for a `<version>` or `<extension>`.
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ class ProseListFormats(Enum):
|
|||
return cls.OR
|
||||
if s == 'and':
|
||||
return cls.AND
|
||||
raise RuntimeError(f"Unrecognized string connective: {s}")
|
||||
raise RuntimeError("Unrecognized string connective: " + s)
|
||||
|
||||
@property
|
||||
def connective(self):
|
||||
|
|
@ -96,11 +96,11 @@ class ConventionsBase(abc.ABC):
|
|||
|
||||
def formatVersion(self, name, apivariant, major, minor):
|
||||
"""Mark up an API version name as a link in the spec."""
|
||||
return f'`<<{name}>>`'
|
||||
return '`<<{}>>`'.format(name)
|
||||
|
||||
def formatExtension(self, name):
|
||||
"""Mark up an extension name as a link in the spec."""
|
||||
return f'`<<{name}>>`'
|
||||
return '`<<{}>>`'.format(name)
|
||||
|
||||
def formatSPIRVlink(self, name):
|
||||
"""Mark up a SPIR-V extension name as an external link in the spec.
|
||||
|
|
@ -224,7 +224,7 @@ class ConventionsBase(abc.ABC):
|
|||
|
||||
my_elts = list(elements)
|
||||
if len(my_elts) > 1:
|
||||
my_elts[-1] = f'{fmt.connective} {my_elts[-1]}'
|
||||
my_elts[-1] = '{} {}'.format(fmt.connective, my_elts[-1])
|
||||
|
||||
if not comma_for_two_elts and len(my_elts) <= 2:
|
||||
prose = ' '.join(my_elts)
|
||||
|
|
@ -351,7 +351,7 @@ class ConventionsBase(abc.ABC):
|
|||
Implemented in terms of api_prefix.
|
||||
|
||||
May override."""
|
||||
return f"{self.api_prefix}VERSION_"
|
||||
return self.api_prefix + 'VERSION_'
|
||||
|
||||
@property
|
||||
def KHR_prefix(self):
|
||||
|
|
@ -360,7 +360,7 @@ class ConventionsBase(abc.ABC):
|
|||
Implemented in terms of api_prefix.
|
||||
|
||||
May override."""
|
||||
return f"{self.api_prefix}KHR_"
|
||||
return self.api_prefix + 'KHR_'
|
||||
|
||||
@property
|
||||
def EXT_prefix(self):
|
||||
|
|
@ -369,7 +369,7 @@ class ConventionsBase(abc.ABC):
|
|||
Implemented in terms of api_prefix.
|
||||
|
||||
May override."""
|
||||
return f"{self.api_prefix}EXT_"
|
||||
return self.api_prefix + 'EXT_'
|
||||
|
||||
def writeFeature(self, featureName, featureExtraProtect, filename):
|
||||
"""Return True if OutputGenerator.endFeature should write this feature.
|
||||
|
|
@ -483,7 +483,8 @@ class ConventionsBase(abc.ABC):
|
|||
file.
|
||||
- name - extension name"""
|
||||
|
||||
return f'include::{{appendices}}/{self.extension_file_path(name)}[]'
|
||||
return 'include::{{appendices}}/{}[]'.format(
|
||||
self.extension_file_path(name))
|
||||
|
||||
@property
|
||||
def provisional_extension_warning(self):
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
1618
registry/vk.xml
Executable file → Normal file
1618
registry/vk.xml
Executable file → Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -28,7 +28,6 @@ SPECIAL_WORDS = set((
|
|||
'ASTC', # VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
|
||||
'D3D12', # VkD3D12FenceSubmitInfoKHR
|
||||
'Float16', # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
|
||||
'Bfloat16', # VkPhysicalDeviceShaderBfloat16FeaturesKHR
|
||||
'ImagePipe', # VkImagePipeSurfaceCreateInfoFUCHSIA
|
||||
'Int64', # VkPhysicalDeviceShaderAtomicInt64FeaturesKHR
|
||||
'Int8', # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
|
||||
|
|
@ -39,7 +38,7 @@ SPECIAL_WORDS = set((
|
|||
))
|
||||
# A regex to match any of the SPECIAL_WORDS
|
||||
EXCEPTION_PATTERN = r'(?P<exception>{})'.format(
|
||||
'|'.join(f'({re.escape(w)})' for w in SPECIAL_WORDS))
|
||||
'|'.join('(%s)' % re.escape(w) for w in SPECIAL_WORDS))
|
||||
MAIN_RE = re.compile(
|
||||
# the negative lookahead is to prevent the all-caps pattern from being too greedy.
|
||||
r'({}|([0-9]+)|([A-Z][a-z]+)|([A-Z][A-Z]*(?![a-z])))'.format(EXCEPTION_PATTERN))
|
||||
|
|
|
|||
|
|
@ -1,438 +0,0 @@
|
|||
#!/usr/bin/env python3 -i
|
||||
#
|
||||
# Copyright 2023-2025 The Khronos Group Inc.
|
||||
#
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from enum import IntFlag, Enum, auto
|
||||
|
||||
@dataclass
|
||||
class Extension:
|
||||
"""<extension>"""
|
||||
name: str # ex) VK_KHR_SURFACE
|
||||
nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME
|
||||
specVersion: str # marco with string, ex) VK_KHR_SURFACE_SPEC_VERSION
|
||||
|
||||
# Only one will be True, the other is False
|
||||
instance: bool
|
||||
device: bool
|
||||
|
||||
depends: (str | None)
|
||||
vendorTag: (str | None) # ex) EXT, KHR, etc
|
||||
platform: (str | None) # ex) android
|
||||
protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
|
||||
provisional: bool
|
||||
promotedTo: (str | None) # ex) VK_VERSION_1_1
|
||||
deprecatedBy: (str | None)
|
||||
obsoletedBy: (str | None)
|
||||
specialUse: list[str]
|
||||
|
||||
# These are here to allow for easy reverse lookups
|
||||
# Quotes allow us to forward declare the dataclass
|
||||
commands: list['Command'] = field(default_factory=list, init=False)
|
||||
enums: list['Enum'] = field(default_factory=list, init=False)
|
||||
bitmasks: list['Bitmask'] = field(default_factory=list, init=False)
|
||||
# Use the Enum name to see what fields are extended
|
||||
enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
|
||||
# Use the Bitmaks name to see what flags are extended
|
||||
flags: dict[str, list['Flag']] = field(default_factory=dict, init=False)
|
||||
|
||||
@dataclass
|
||||
class Version:
|
||||
"""
|
||||
<feature> which represents a version
|
||||
This will NEVER be Version 1.0, since having 'no version' is same as being 1.0
|
||||
"""
|
||||
name: str # ex) VK_VERSION_1_1
|
||||
nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes)
|
||||
nameApi: str # ex) VK_API_VERSION_1_1
|
||||
|
||||
@dataclass
|
||||
class Handle:
|
||||
"""<type> which represents a dispatch handle"""
|
||||
name: str # ex) VkBuffer
|
||||
aliases: list[str] # ex) ['VkSamplerYcbcrConversionKHR']
|
||||
|
||||
type: str # ex) VK_OBJECT_TYPE_BUFFER
|
||||
protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
|
||||
|
||||
parent: 'Handle' # Chain of parent handles, can be None
|
||||
|
||||
# Only one will be True, the other is False
|
||||
instance: bool
|
||||
device: bool
|
||||
|
||||
dispatchable: bool
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class Param:
|
||||
"""<command/param>"""
|
||||
name: str # ex) pCreateInfo, pAllocator, pBuffer
|
||||
alias: str
|
||||
|
||||
# the "base type" - will not preserve the 'const' or pointer info
|
||||
# ex) void, uint32_t, VkFormat, VkBuffer, etc
|
||||
type: str
|
||||
# the "full type" - will be cDeclaration without the type name
|
||||
# ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc
|
||||
# For arrays, this will only display the type, fixedSizeArray can be used to get the length
|
||||
fullType: str
|
||||
|
||||
noAutoValidity: bool
|
||||
|
||||
const: bool # type contains 'const'
|
||||
length: (str | None) # the known length of pointer, will never be 'null-terminated'
|
||||
nullTerminated: bool # If a UTF-8 string, it will be null-terminated
|
||||
pointer: bool # type contains a pointer (include 'PFN' function pointers)
|
||||
# Used to list how large an array of the type is
|
||||
# ex) lineWidthRange is ['2']
|
||||
# ex) memoryTypes is ['VK_MAX_MEMORY_TYPES']
|
||||
# ex) VkTransformMatrixKHR:matrix is ['3', '4']
|
||||
fixedSizeArray: list[str]
|
||||
|
||||
optional: bool
|
||||
optionalPointer: bool # if type contains a pointer, is the pointer value optional
|
||||
|
||||
externSync: bool
|
||||
externSyncPointer: list[str] # if type contains a pointer, might only specific members modified
|
||||
|
||||
# C string of member, example:
|
||||
# - const void* pNext
|
||||
# - VkFormat format
|
||||
# - VkStructureType sType
|
||||
cDeclaration: str
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
class Queues(IntFlag):
|
||||
TRANSFER = auto() # VK_QUEUE_TRANSFER_BIT
|
||||
GRAPHICS = auto() # VK_QUEUE_GRAPHICS_BIT
|
||||
COMPUTE = auto() # VK_QUEUE_COMPUTE_BIT
|
||||
PROTECTED = auto() # VK_QUEUE_PROTECTED_BIT
|
||||
SPARSE_BINDING = auto() # VK_QUEUE_SPARSE_BINDING_BIT
|
||||
OPTICAL_FLOW = auto() # VK_QUEUE_OPTICAL_FLOW_BIT_NV
|
||||
DECODE = auto() # VK_QUEUE_VIDEO_DECODE_BIT_KHR
|
||||
ENCODE = auto() # VK_QUEUE_VIDEO_ENCODE_BIT_KHR
|
||||
ALL = TRANSFER | GRAPHICS | COMPUTE | PROTECTED | SPARSE_BINDING | OPTICAL_FLOW | DECODE | ENCODE
|
||||
|
||||
class CommandScope(Enum):
|
||||
NONE = auto()
|
||||
INSIDE = auto()
|
||||
OUTSIDE = auto()
|
||||
BOTH = auto()
|
||||
|
||||
@dataclass
|
||||
class Command:
|
||||
"""<command>"""
|
||||
name: str # ex) vkCmdDraw
|
||||
alias: (str | None) # Because commands are interfaces into layers/drivers, we need all command alias
|
||||
protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS'
|
||||
|
||||
extensions: list[Extension] # All extensions that enable the struct
|
||||
version: (Version | None) # None if Version 1.0
|
||||
|
||||
returnType: str # ex) void, VkResult, etc
|
||||
|
||||
params: list[Param] # Each parameter of the command
|
||||
|
||||
# Only one will be True, the other is False
|
||||
instance: bool
|
||||
device: bool
|
||||
|
||||
tasks: list[str] # ex) [ action, state, synchronization ]
|
||||
queues: Queues # zero == No Queues found
|
||||
successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ]
|
||||
errorCodes: list[str] # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ]
|
||||
|
||||
# Shows support if command can be in a primary and/or secondary command buffer
|
||||
primary: bool
|
||||
secondary: bool
|
||||
|
||||
renderPass: CommandScope
|
||||
videoCoding: CommandScope
|
||||
|
||||
implicitExternSyncParams: list[str]
|
||||
|
||||
# C prototype string - ex:
|
||||
# VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
|
||||
# const VkInstanceCreateInfo* pCreateInfo,
|
||||
# const VkAllocationCallbacks* pAllocator,
|
||||
# VkInstance* pInstance);
|
||||
cPrototype: str
|
||||
|
||||
# function pointer typedef - ex:
|
||||
# typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)
|
||||
# (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
|
||||
cFunctionPointer: str
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class Member:
|
||||
"""<member>"""
|
||||
name: str # ex) sType, pNext, flags, size, usage
|
||||
|
||||
# the "base type" - will not preserve the 'const' or pointer info
|
||||
# ex) void, uint32_t, VkFormat, VkBuffer, etc
|
||||
type: str
|
||||
# the "full type" - will be cDeclaration without the type name
|
||||
# ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc
|
||||
# For arrays, this will only display the type, fixedSizeArray can be used to get the length
|
||||
fullType: str
|
||||
|
||||
noAutoValidity: bool
|
||||
limitType: (str | None) # ex) 'max', 'bitmask', 'bits', 'min,mul'
|
||||
|
||||
const: bool # type contains 'const'
|
||||
length: (str | None) # the known length of pointer, will never be 'null-terminated'
|
||||
nullTerminated: bool # If a UTF-8 string, it will be null-terminated
|
||||
pointer: bool # type contains a pointer (include 'PFN' function pointers)
|
||||
# Used to list how large an array of the type is
|
||||
# ex) lineWidthRange is ['2']
|
||||
# ex) memoryTypes is ['VK_MAX_MEMORY_TYPES']
|
||||
# ex) VkTransformMatrixKHR:matrix is ['3', '4']
|
||||
fixedSizeArray: list[str]
|
||||
|
||||
optional: bool
|
||||
optionalPointer: bool # if type contains a pointer, is the pointer value optional
|
||||
|
||||
externSync: bool
|
||||
|
||||
# C string of member, example:
|
||||
# - const void* pNext
|
||||
# - VkFormat format
|
||||
# - VkStructureType sType
|
||||
cDeclaration: str
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class Struct:
|
||||
"""<type category="struct"> or <type category="union">"""
|
||||
name: str # ex) VkImageSubresource2
|
||||
aliases: list[str] # ex) ['VkImageSubresource2KHR', 'VkImageSubresource2EXT']
|
||||
|
||||
extensions: list[Extension] # All extensions that enable the struct
|
||||
version: (Version | None) # None if Version 1.0
|
||||
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
|
||||
|
||||
members: list[Member]
|
||||
|
||||
union: bool # Unions are just a subset of a Structs
|
||||
returnedOnly: bool
|
||||
|
||||
sType: (str | None) # ex) VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
|
||||
allowDuplicate: bool # can have a pNext point to itself
|
||||
|
||||
# These use to be list['Struct'] but some circular loops occur and cause
|
||||
# pydevd warnings and made debugging slow (30 seconds to index a Struct)
|
||||
extends: list[str] # Struct names that this struct extends
|
||||
extendedBy: list[str] # Struct names that can be extended by this struct
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class EnumField:
|
||||
"""<enum> of type enum"""
|
||||
name: str # ex) VK_DYNAMIC_STATE_SCISSOR
|
||||
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
|
||||
|
||||
negative: bool # True if negative values are allowed (ex. VkResult)
|
||||
value: int
|
||||
valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004")
|
||||
|
||||
# some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
|
||||
extensions: list[Extension] # None if part of 1.0 core
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class Enum:
|
||||
"""<enums> of type enum"""
|
||||
name: str # ex) VkLineRasterizationMode
|
||||
aliases: list[str] # ex) ['VkLineRasterizationModeKHR', 'VkLineRasterizationModeEXT']
|
||||
|
||||
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
|
||||
|
||||
bitWidth: int # 32 or 64 (currently all are 32, but field is to match with Bitmask)
|
||||
returnedOnly: bool
|
||||
|
||||
fields: list[EnumField]
|
||||
|
||||
extensions: list[Extension] # None if part of 1.0 core
|
||||
# Unique list of all extension that are involved in 'fields' (superset of 'extensions')
|
||||
fieldExtensions: list[Extension]
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class Flag:
|
||||
"""<enum> of type bitmask"""
|
||||
name: str # ex) VK_ACCESS_2_SHADER_READ_BIT
|
||||
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
|
||||
|
||||
value: int
|
||||
valueStr: str # value as shown in spec (ex. 0x00000000", "0x00000004", "0x0000000F", "0x800000000ULL")
|
||||
multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
|
||||
zero: bool # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)
|
||||
|
||||
# some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
|
||||
extensions: list[Extension] # None if part of 1.0 core
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class Bitmask:
|
||||
"""<enums> of type bitmask"""
|
||||
name: str # ex) VkAccessFlagBits2
|
||||
aliases: list[str] # ex) ['VkAccessFlagBits2KHR']
|
||||
|
||||
flagName: str # ex) VkAccessFlags2
|
||||
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
|
||||
|
||||
bitWidth: int # 32 or 64
|
||||
returnedOnly: bool
|
||||
|
||||
flags: list[Flag]
|
||||
|
||||
extensions: list[Extension] # None if part of 1.0 core
|
||||
# Unique list of all extension that are involved in 'flag' (superset of 'extensions')
|
||||
flagExtensions: list[Extension]
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.name < other.name
|
||||
|
||||
@dataclass
|
||||
class FormatComponent:
|
||||
"""<format/component>"""
|
||||
type: str # ex) R, G, B, A, D, S, etc
|
||||
bits: str # will be an INT or 'compressed'
|
||||
numericFormat: str # ex) UNORM, SINT, etc
|
||||
planeIndex: (int | None) # None if no planeIndex in format
|
||||
|
||||
@dataclass
|
||||
class FormatPlane:
|
||||
"""<format/plane>"""
|
||||
index: int
|
||||
widthDivisor: int
|
||||
heightDivisor: int
|
||||
compatible: str
|
||||
|
||||
@dataclass
|
||||
class Format:
|
||||
"""<format>"""
|
||||
name: str
|
||||
className: str
|
||||
blockSize: int
|
||||
texelsPerBlock: int
|
||||
blockExtent: list[str]
|
||||
packed: (int | None) # None == not-packed
|
||||
chroma: (str | None)
|
||||
compressed: (str | None)
|
||||
components: list[FormatComponent] # <format/component>
|
||||
planes: list[FormatPlane] # <format/plane>
|
||||
spirvImageFormat: (str | None)
|
||||
|
||||
@dataclass
|
||||
class SyncSupport:
|
||||
"""<syncsupport>"""
|
||||
queues: Queues
|
||||
stages: list[Flag] # VkPipelineStageFlagBits2
|
||||
max: bool # If this supports max values
|
||||
|
||||
@dataclass
|
||||
class SyncEquivalent:
|
||||
"""<syncequivalent>"""
|
||||
stages: list[Flag] # VkPipelineStageFlagBits2
|
||||
accesses: list[Flag] # VkAccessFlagBits2
|
||||
max: bool # If this equivalent to everything
|
||||
|
||||
@dataclass
|
||||
class SyncStage:
|
||||
"""<syncstage>"""
|
||||
flag: Flag # VkPipelineStageFlagBits2
|
||||
support: SyncSupport
|
||||
equivalent: SyncEquivalent
|
||||
|
||||
@dataclass
|
||||
class SyncAccess:
|
||||
"""<syncaccess>"""
|
||||
flag: Flag # VkAccessFlagBits2
|
||||
support: SyncSupport
|
||||
equivalent: SyncEquivalent
|
||||
|
||||
@dataclass
|
||||
class SyncPipelineStage:
|
||||
"""<syncpipelinestage>"""
|
||||
order: (str | None)
|
||||
before: (str | None)
|
||||
after: (str | None)
|
||||
value: str
|
||||
|
||||
@dataclass
|
||||
class SyncPipeline:
|
||||
"""<syncpipeline>"""
|
||||
name: str
|
||||
depends: list[str]
|
||||
stages: list[SyncPipelineStage]
|
||||
|
||||
@dataclass
|
||||
class SpirvEnables:
|
||||
"""What is needed to enable the SPIR-V element"""
|
||||
version: (str | None)
|
||||
extension: (str | None)
|
||||
struct: (str | None)
|
||||
feature: (str | None)
|
||||
requires: (str | None)
|
||||
property: (str | None)
|
||||
member: (str | None)
|
||||
value: (str | None)
|
||||
|
||||
@dataclass
|
||||
class Spirv:
|
||||
"""<spirvextension> and <spirvcapability>"""
|
||||
name: str
|
||||
# Only one will be True, the other is False
|
||||
extension: bool
|
||||
capability: bool
|
||||
enable: list[SpirvEnables]
|
||||
|
||||
# This is the global Vulkan Object that holds all the information from parsing the XML
|
||||
# This class is designed so all generator scripts can use this to obtain data
|
||||
@dataclass
|
||||
class VulkanObject():
|
||||
headerVersion: int = 0 # value of VK_HEADER_VERSION
|
||||
|
||||
extensions: dict[str, Extension] = field(default_factory=dict, init=False)
|
||||
versions: dict[str, Version] = field(default_factory=dict, init=False)
|
||||
|
||||
handles: dict[str, Handle] = field(default_factory=dict, init=False)
|
||||
commands: dict[str, Command] = field(default_factory=dict, init=False)
|
||||
structs: dict[str, Struct] = field(default_factory=dict, init=False)
|
||||
enums: dict[str, Enum] = field(default_factory=dict, init=False)
|
||||
bitmasks: dict[str, Bitmask] = field(default_factory=dict, init=False)
|
||||
formats: dict[str, Format] = field(default_factory=dict, init=False)
|
||||
|
||||
syncStage: list[SyncStage] = field(default_factory=list, init=False)
|
||||
syncAccess: list[SyncAccess] = field(default_factory=list, init=False)
|
||||
syncPipeline: list[SyncPipeline] = field(default_factory=list, init=False)
|
||||
|
||||
spirv: list[Spirv] = field(default_factory=list, init=False)
|
||||
|
||||
# ex) [ xlib : VK_USE_PLATFORM_XLIB_KHR ]
|
||||
platforms: dict[str, str] = field(default_factory=dict, init=False)
|
||||
# list of all vendor Suffix names (KHR, EXT, etc. )
|
||||
vendorTags: list[str] = field(default_factory=list, init=False)
|
||||
# ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ]
|
||||
queueBits: dict[IntFlag, str] = field(default_factory=dict, init=False)
|
||||
|
|
@ -12,7 +12,7 @@ add_test(NAME integration.add_subdirectory
|
|||
--build-and-test ${CMAKE_CURRENT_LIST_DIR}/integration
|
||||
${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory
|
||||
--build-generator ${CMAKE_GENERATOR}
|
||||
--build-options -DFIND_PACKAGE_TESTING=OFF -DVULKAN_HEADERS_ENABLE_MODULE=${VULKAN_HEADERS_ENABLE_MODULE}
|
||||
--build-options -DFIND_PACKAGE_TESTING=OFF -DVULKAN_HEADERS_ENABLE_MODULE=OFF
|
||||
)
|
||||
|
||||
set(test_install_dir "${CMAKE_CURRENT_BINARY_DIR}/install")
|
||||
|
|
|
|||
|
|
@ -5,9 +5,9 @@
|
|||
#
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
# ~~~
|
||||
cmake_minimum_required(VERSION 3.22.1)
|
||||
cmake_minimum_required(VERSION 3.14.2)
|
||||
|
||||
project(API LANGUAGES C CXX)
|
||||
project(API LANGUAGES C)
|
||||
|
||||
if (FIND_PACKAGE_TESTING)
|
||||
find_package(VulkanHeaders REQUIRED CONFIG)
|
||||
|
|
@ -18,9 +18,6 @@ endif()
|
|||
if (NOT TARGET Vulkan::Headers)
|
||||
message(FATAL_ERROR "Vulkan::Headers target not defined")
|
||||
endif()
|
||||
if (NOT TARGET Vulkan::HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
|
||||
message(FATAL_ERROR "Vulkan::HppModule target not defined")
|
||||
endif()
|
||||
|
||||
if (FIND_PACKAGE_TESTING)
|
||||
if (NOT DEFINED VulkanHeaders_VERSION)
|
||||
|
|
@ -40,9 +37,6 @@ if (NOT FIND_PACKAGE_TESTING)
|
|||
if (NOT TARGET Vulkan-Headers)
|
||||
message(FATAL_ERROR "Backcompat for Vulkan-Headers target broken!")
|
||||
endif()
|
||||
if (NOT TARGET Vulkan-HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
|
||||
message(FATAL_ERROR "Backcompat for Vulkan-HppModule target broken!")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
set(CMAKE_C_STANDARD 99)
|
||||
|
|
@ -77,15 +71,3 @@ target_link_libraries(vk_icd PRIVATE Vulkan::Headers)
|
|||
# vk_layer.h
|
||||
add_library(vk_layer MODULE ../vk_layer.c)
|
||||
target_link_libraries(vk_layer PRIVATE Vulkan::Headers)
|
||||
|
||||
# vulkan.hpp
|
||||
add_library(vk_hpp MODULE ../vk_hpp.cpp)
|
||||
target_compile_features(vk_hpp PUBLIC cxx_std_11)
|
||||
target_link_libraries(vk_hpp PRIVATE Vulkan::Headers)
|
||||
|
||||
# vulkan.cppm
|
||||
if (VULKAN_HEADERS_ENABLE_MODULE)
|
||||
add_library(vk_hpp_module MODULE ../vk_hpp_module.cpp)
|
||||
set_target_properties(vk_hpp_module PROPERTIES CXX_SCAN_FOR_MODULES ON)
|
||||
target_link_libraries(vk_hpp_module PRIVATE Vulkan::HppModule)
|
||||
endif()
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
/*
|
||||
* Copyright 2025 The Khronos Group Inc.
|
||||
* Copyright 2025 Valve Corporation
|
||||
* Copyright 2025 LunarG, Inc.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include <vulkan/vulkan.hpp>
|
||||
|
||||
int header_version()
|
||||
{
|
||||
return VK_HEADER_VERSION;
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
/*
|
||||
* Copyright 2025 The Khronos Group Inc.
|
||||
* Copyright 2025 Valve Corporation
|
||||
* Copyright 2025 LunarG, Inc.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
import vulkan_hpp;
|
||||
|
||||
int test_version()
|
||||
{
|
||||
return static_cast<int>(vk::makeApiVersion(1, 0, 0, 0));
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue