From e3f90c60683c1feedf8044b1b5d62b4351f121f2 Mon Sep 17 00:00:00 2001
From: Ozkan Sezer <[EMAIL REDACTED]>
Date: Mon, 17 Jul 2023 00:10:50 +0300
Subject: [PATCH] remove unused vulkan/*.hpp files.
(cherry picked from commit 611b3dd1fd7aec30ba9c830c7c5f8a0cdbaf9ff5)
---
src/video/khronos/vulkan/vulkan.hpp | 14537 ---
src/video/khronos/vulkan/vulkan_enums.hpp | 8538 --
.../khronos/vulkan/vulkan_format_traits.hpp | 7333 --
src/video/khronos/vulkan/vulkan_funcs.hpp | 20008 ----
src/video/khronos/vulkan/vulkan_handles.hpp | 13585 ---
src/video/khronos/vulkan/vulkan_hash.hpp | 13489 ---
src/video/khronos/vulkan/vulkan_raii.hpp | 17460 ---
.../vulkan/vulkan_static_assertions.hpp | 5847 -
src/video/khronos/vulkan/vulkan_structs.hpp | 99721 ----------------
src/video/khronos/vulkan/vulkan_to_string.hpp | 7732 --
10 files changed, 208250 deletions(-)
delete mode 100644 src/video/khronos/vulkan/vulkan.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_enums.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_format_traits.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_funcs.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_handles.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_hash.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_raii.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_static_assertions.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_structs.hpp
delete mode 100644 src/video/khronos/vulkan/vulkan_to_string.hpp
diff --git a/src/video/khronos/vulkan/vulkan.hpp b/src/video/khronos/vulkan/vulkan.hpp
deleted file mode 100644
index eac9ff0b6cfd..000000000000
--- a/src/video/khronos/vulkan/vulkan.hpp
+++ /dev/null
@@ -1,14537 +0,0 @@
-// Copyright 2015-2022 The Khronos Group Inc.
-//
-// SPDX-License-Identifier: Apache-2.0 OR MIT
-//
-
-// This header is generated from the Khronos Vulkan XML API Registry.
-
-#ifndef VULKAN_HPP
-#define VULKAN_HPP
-
-#if defined( _MSVC_LANG )
-# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
-#else
-# define VULKAN_HPP_CPLUSPLUS __cplusplus
-#endif
-
-#if 201703L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 20
-#elif 201402L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 17
-#elif 201103L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 14
-#elif 199711L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 11
-#else
-# error "vulkan.hpp needs at least c++ standard version 11"
-#endif
-
-#include <array> // ArrayWrapperND
-#include <string> // std::string
-#include <vulkan/vulkan.h>
-#if 17 <= VULKAN_HPP_CPP_VERSION
-# include <string_view> // std::string_view
-#endif
-
-#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-# define VULKAN_HPP_NO_SMART_HANDLE
-# endif
-#else
-# include <tuple> // std::tie
-# include <vector> // std::vector
-#endif
-
-#if !defined( VULKAN_HPP_NO_EXCEPTIONS )
-# include <system_error> // std::is_error_code_enum
-#endif
-
-#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-# include <algorithm> // std::transform
-#endif
-
-#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
-# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
-# endif
-# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
-# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
-# endif
-#endif
-
-#if defined( VULKAN_HPP_NO_SETTERS )
-# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-# define VULKAN_HPP_NO_STRUCT_SETTERS
-# endif
-# if !defined( VULKAN_HPP_NO_UNION_SETTERS )
-# define VULKAN_HPP_NO_UNION_SETTERS
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_ASSERT )
-# include <cassert>
-# define VULKAN_HPP_ASSERT assert
-#endif
-
-#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
-# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
-#endif
-
-#if !defined( VULKAN_HPP_STATIC_ASSERT )
-# define VULKAN_HPP_STATIC_ASSERT static_assert
-#endif
-
-#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
-# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
-#endif
-
-#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
-# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
-# include <dlfcn.h>
-# elif defined( _WIN32 )
-typedef struct HINSTANCE__ * HINSTANCE;
-# if defined( _WIN64 )
-typedef int64_t( __stdcall * FARPROC )();
-# else
-typedef int( __stdcall * FARPROC )();
-# endif
-extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
-extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
-extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
-# endif
-#endif
-
-#if !defined( __has_include )
-# define __has_include( x ) false
-#endif
-
-#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
-# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
-#endif
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-# include <compare>
-#endif
-
-#if ( 201803 <= __cpp_lib_span )
-# define VULKAN_HPP_SUPPORT_SPAN
-# include <span>
-#endif
-
-static_assert( VK_HEADER_VERSION == 227, "Wrong VK_HEADER_VERSION!" );
-
-// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
-// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
-#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
-# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-# define VULKAN_HPP_TYPESAFE_CONVERSION
-# endif
-#endif
-
-// <tuple> includes <sys/sysmacros.h> through some other header
-// this results in major(x) being resolved to gnu_dev_major(x)
-// which is an expression in a constructor initializer list.
-#if defined( major )
-# undef major
-#endif
-#if defined( minor )
-# undef minor
-#endif
-
-// Windows defines MemoryBarrier which is deprecated and collides
-// with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
-#if defined( MemoryBarrier )
-# undef MemoryBarrier
-#endif
-
-#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
-# if defined( __clang__ )
-# if __has_feature( cxx_unrestricted_unions )
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# elif defined( __GNUC__ )
-# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
-# if 40600 <= GCC_VERSION
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# elif defined( _MSC_VER )
-# if 1900 <= _MSC_VER
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# endif
-#endif
-
-#if !defined( VULKAN_HPP_INLINE )
-# if defined( __clang__ )
-# if __has_attribute( always_inline )
-# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
-# else
-# define VULKAN_HPP_INLINE inline
-# endif
-# elif defined( __GNUC__ )
-# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
-# elif defined( _MSC_VER )
-# define VULKAN_HPP_INLINE inline
-# else
-# define VULKAN_HPP_INLINE inline
-# endif
-#endif
-
-#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-# define VULKAN_HPP_TYPESAFE_EXPLICIT
-#else
-# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
-#endif
-
-#if defined( __cpp_constexpr )
-# define VULKAN_HPP_CONSTEXPR constexpr
-# if __cpp_constexpr >= 201304
-# define VULKAN_HPP_CONSTEXPR_14 constexpr
-# else
-# define VULKAN_HPP_CONSTEXPR_14
-# endif
-# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
-#else
-# define VULKAN_HPP_CONSTEXPR
-# define VULKAN_HPP_CONSTEXPR_14
-# define VULKAN_HPP_CONST_OR_CONSTEXPR const
-#endif
-
-#if !defined( VULKAN_HPP_NOEXCEPT )
-# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
-# define VULKAN_HPP_NOEXCEPT
-# else
-# define VULKAN_HPP_NOEXCEPT noexcept
-# define VULKAN_HPP_HAS_NOEXCEPT 1
-# if defined( VULKAN_HPP_NO_EXCEPTIONS )
-# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
-# else
-# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-# endif
-# endif
-#endif
-
-#if 14 <= VULKAN_HPP_CPP_VERSION
-# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
-#else
-# define VULKAN_HPP_DEPRECATED( msg )
-#endif
-
-#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
-# define VULKAN_HPP_NODISCARD [[nodiscard]]
-# if defined( VULKAN_HPP_NO_EXCEPTIONS )
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
-# else
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-# endif
-#else
-# define VULKAN_HPP_NODISCARD
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-#endif
-
-#if !defined( VULKAN_HPP_NAMESPACE )
-# define VULKAN_HPP_NAMESPACE vk
-#endif
-
-#define VULKAN_HPP_STRINGIFY2( text ) #text
-#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
-#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
-
-namespace VULKAN_HPP_NAMESPACE
-{
- template <typename T, size_t N>
- class ArrayWrapper1D : public std::array<T, N>
- {
- public:
- VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
-
- VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
-
-#if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
- // on 32 bit compiles, needs overloads on index type int to resolve ambiguities
- VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT
- {
- return std::array<T, N>::operator[]( index );
- }
-
- T & operator[]( int index ) VULKAN_HPP_NOEXCEPT
- {
- return std::array<T, N>::operator[]( index );
- }
-#endif
-
- operator T const *() const VULKAN_HPP_NOEXCEPT
- {
- return this->data();
- }
-
- operator T *() VULKAN_HPP_NOEXCEPT
- {
- return this->data();
- }
-
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- operator std::string() const
- {
- return std::string( this->data() );
- }
-
-#if 17 <= VULKAN_HPP_CPP_VERSION
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- operator std::string_view() const
- {
- return std::string_view( this->data() );
- }
-#endif
-
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>( this ) <=> *static_cast<std::array<char, N> const *>( &rhs );
- }
-#else
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator<( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>( this ) < *static_cast<std::array<char, N> const *>( &rhs );
- }
-
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator<=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>( this ) <= *static_cast<std::array<char, N> const *>( &rhs );
- }
-
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>( this ) > *static_cast<std::array<char, N> const *>( &rhs );
- }
-
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator>=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>( this ) >= *static_cast<std::array<char, N> const *>( &rhs );
- }
-#endif
-
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator==( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>( this ) == *static_cast<std::array<char, N> const *>( &rhs );
- }
-
- template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator!=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>( this ) != *static_cast<std::array<char, N> const *>( &rhs );
- }
- };
-
- // specialization of relational operators between std::string and arrays of chars
- template <size_t N>
- bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- return lhs < rhs.data();
- }
-
- template <size_t N>
- bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- return lhs <= rhs.data();
- }
-
- template <size_t N>
- bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- return lhs > rhs.data();
- }
-
- template <size_t N>
- bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- return lhs >= rhs.data();
- }
-
- template <size_t N>
- bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- return lhs == rhs.data();
- }
-
- template <size_t N>
- bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- return lhs != rhs.data();
- }
-
- template <typename T, size_t N, size_t M>
- class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
- {
- public:
- VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}
-
- VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
- : std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
- {
- }
- };
-
- template <typename FlagBitsType>
- struct FlagTraits
- {
- };
-
- template <typename BitType>
- class Flags
- {
- public:
- using MaskType = typename std::underlying_type<BitType>::type;
-
- // constructors
- VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
-
- // relational operators
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( Flags<BitType> const & ) const = default;
-#else
- VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask < rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask <= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask > rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask >= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask == rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask != rhs.m_mask;
- }
-#endif
-
- // logical operator
- VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
- {
- return !m_mask;
- }
-
- // bitwise operators
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask & rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask | rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags );
- }
-
- // assignment operators
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask |= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask &= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask ^= rhs.m_mask;
- return *this;
- }
-
- // cast operators
- explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return !!m_mask;
- }
-
- explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
- {
- return m_mask;
- }
-
-#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
- public:
-#else
- private:
-#endif
- MaskType m_mask;
- };
-
-#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- // relational operators only needed for pre C++20
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator==( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator!=( bit );
- }
-#endif
-
- // bitwise operators
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator&( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator|( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator^( bit );
- }
-
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- template <typename T>
- class ArrayProxy
- {
- public:
- VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
- : m_count( 0 )
- , m_ptr( nullptr )
- {
- }
-
- VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
- : m_count( 0 )
- , m_ptr( nullptr )
- {
- }
-
- ArrayProxy( T & value ) VULKAN_HPP_NOEXCEPT
- : m_count( 1 )
- , m_ptr( &value )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
- : m_count( 1 )
- , m_ptr( &value )
- {
- }
-
- ArrayProxy( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
- : m_count( count )
- , m_ptr( ptr )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
- : m_count( count )
- , m_ptr( ptr )
- {
- }
-
- template <std::size_t C>
- ArrayProxy( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
- : m_count( C )
- , m_ptr( ptr )
- {
- }
-
- template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
- : m_count( C )
- , m_ptr( ptr )
- {
- }
-
-# if __GNUC__ >= 9
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Winit-list-lifetime"
-# endif
-
- ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
- ArrayProxy( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
-# if __GNUC__ >= 9
-# pragma GCC diagnostic pop
-# endif
-
- // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
- // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
- template <typename V,
- typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
- std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
- ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( v.size() ) )
- , m_ptr( v.data() )
- {
- }
-
- template <typename V,
- typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
- std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
- ArrayProxy( V & v ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( v.size() ) )
- , m_ptr( v.data() )
- {
- }
-
- const T * begin() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
- const T * end() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr + m_count;
- }
-
- const T & front() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT( m_count && m_ptr );
- return *m_ptr;
- }
-
- const T & back() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT( m_count && m_ptr );
- return *( m_ptr + m_count - 1 );
- }
-
- bool empty() const VULKAN_HPP_NOEXCEPT
- {
- return ( m_count == 0 );
- }
-
- uint32_t size() const VULKAN_HPP_NOEXCEPT
- {
- return m_count;
- }
-
- T * data() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
- private:
- uint32_t m_count;
- T * m_ptr;
- };
-
- template <typename T>
- class ArrayProxyNoTemporaries
- {
- public:
- VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
- : m_count( 0 )
- , m_ptr( nullptr )
- {
- }
-
- VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
- : m_count( 0 )
- , m_ptr( nullptr )
- {
- }
-
- ArrayProxyNoTemporaries( T & value ) VULKAN_HPP_NOEXCEPT
- : m_count( 1 )
- , m_ptr( &value )
- {
- }
-
- template <typename V>
- ArrayProxyNoTemporaries( V && value ) = delete;
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
- : m_count( 1 )
- , m_ptr( &value )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( typename std::remove_const<T>::type && value ) = delete;
-
- ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
- : m_count( count )
- , m_ptr( ptr )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
- : m_count( count )
- , m_ptr( ptr )
- {
- }
-
- template <std::size_t C>
- ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
- : m_count( C )
- , m_ptr( ptr )
- {
- }
-
- template <std::size_t C>
- ArrayProxyNoTemporaries( T( &&ptr )[C] ) = delete;
-
- template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
- : m_count( C )
- , m_ptr( ptr )
- {
- }
-
- template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( typename std::remove_const<T>::type( &&ptr )[C] ) = delete;
-
- ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
- ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete;
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete;
-
- ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
- ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete;
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( list.size() ) )
- , m_ptr( list.begin() )
- {
- }
-
- template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete;
-
- // Any type with a .data() return type implicitly convertible to T*, and a // .size() return type implicitly
- // convertible to size_t.
- template <typename V,
- typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
- std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
- ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT
- : m_count( static_cast<uint32_t>( v.size() ) )
- , m_ptr( v.data() )
- {
- }
-
- const T * begin() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
- const T * end() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr + m_count;
- }
-
- const T & front() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT( m_count && m_ptr );
- return *m_ptr;
- }
-
- const T & back() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT( m_count && m_ptr );
- return *( m_ptr + m_count - 1 );
- }
-
- bool empty() const VULKAN_HPP_NOEXCEPT
- {
- return ( m_count == 0 );
- }
-
- uint32_t size() const VULKAN_HPP_NOEXCEPT
- {
- return m_count;
- }
-
- T * data() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
- private:
- uint32_t m_count;
- T * m_ptr;
- };
-
- template <typename RefType>
- class Optional
- {
- public:
- Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT
- {
- m_ptr = &reference;
- }
- Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT
- {
- m_ptr = ptr;
- }
- Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
- {
- m_ptr = nullptr;
- }
-
- operator RefType *() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
- RefType const * operator->() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
- explicit operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return !!m_ptr;
- }
-
- private:
- RefType * m_ptr;
- };
-
- template <typename X, typename Y>
- struct StructExtends
- {
- enum
- {
- value = false
- };
- };
-
- template <typename Type, class...>
- struct IsPartOfStructureChain
- {
- static const bool valid = false;
- };
-
- template <typename Type, typename Head, typename... Tail>
- struct IsPartOfStructureChain<Type, Head, Tail...>
- {
- static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
- };
-
- template <size_t Index, typename T, typename... ChainElements>
- struct StructureChainContains
- {
- static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
- StructureChainContains<Index - 1, T, ChainElements...>::value;
- };
-
- template <typename T, typename... ChainElements>
- struct StructureChainContains<0, T, ChainElements...>
- {
- static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
- };
-
- template <size_t Index, typename... ChainElements>
- struct StructureChainValidation
- {
- using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
- static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
- ( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
- StructureChainValidation<Index - 1, ChainElements...>::valid;
- };
-
- template <typename... ChainElements>
- struct StructureChainValidation<0, ChainElements...>
- {
- static const bool valid = true;
- };
-
- template <typename... Chai
(Patch may be truncated, please check the link at the top of this post.)