Compiler Explorer

Source code

typedef min16uint uint16_t;
typedef min16int int16_t;

//// Copyright (C) 2023-2024 - DevSH Graphics Programming Sp. z O.O.
//// This file is part of the "Nabla Engine".
//// For conditions of distribution and use, see copyright notice in nabla.h
#line 4 "C:/Users/fjlet/Desktop/Nabla/examples_tests/12_Mortons/app_resources/mortonTest.comp.hlsl"
#pragma shader_stage(compute)

#line 1 "C:/Users/fjlet/Desktop/Nabla/examples_tests/12_Mortons/app_resources/common.hlsl"
//// Copyright (C) 2023-2024 - DevSH Graphics Programming Sp. z O.O.
//// This file is part of the "Nabla Engine".
//// For conditions of distribution and use, see copyright notice in nabla.h

#line 34 "C:/Users/fjlet/Desktop/Nabla/3rdparty/boost/superproject/libs/preprocessor/include/boost/preprocessor/tuple/rem.hpp"
/*
  VC++8.0 cannot handle the variadic version of BOOST_PP_TUPLE_REM(size)
*/

#line 16 "C:/Users/fjlet/Desktop/Nabla/3rdparty/boost/superproject/libs/preprocessor/include/boost/preprocessor/tuple/limits/to_seq_64.hpp"
/* An empty array can be passed */

#line 21 "C:/Users/fjlet/Desktop/Nabla/3rdparty/boost/superproject/libs/preprocessor/include/boost/preprocessor/seq/detail/is_empty.hpp"
/* An empty seq is one that is just BOOST_PP_SEQ_NIL */

#line 8 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/macros.h"
// TODO: DXC doesn't get this, we need our own

// TODO: switch between enabled and disabled depending on Nabla build config

#line 43 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/macros.h"
// basics

#line 49 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/macros.h"
// variadics

#line 55 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/macros.h"
// TODO: Use BOOST_PP!

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/impl/base.hlsl"
// Copyright (C) 2023-2024 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/impl/base.hlsl"
namespace nbl
{
namespace hlsl
{
namespace concepts
{

//! Now diverge

#line 25 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/impl/base.hlsl"
// to define a concept using `concept Name = SomeContexprBoolCondition<T>;`

// to put right before the closing `>` of the primary template definition, otherwise `NBL_PARTIAL_REQUIRES` wont work on specializations

#line 32 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/impl/base.hlsl"
}
}
}

#line 54 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/basic.h"
namespace nbl
{
namespace hlsl
{

#line 72 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/basic.h"
}
}

#line 80 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/basic.h"
namespace nbl
{
namespace hlsl
{
namespace impl
{
template<typename To, typename From, typename Enabled = void ,typename __requires=void >
struct static_cast_helper
{
 static inline To cast(const in From u)
 {
#line 94 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/basic.h"
 return To(u);

}
};

}

template<typename To, typename From>
inline To _static_cast(const in From v)
{
 return impl::static_cast_helper<To, From>::cast(v);
}

}
}

#line 5 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat.hlsl"
// it includes vector and matrix

#line 4 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/vector.hlsl"
// stuff for C++

#line 48 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/vector.hlsl"
// general typedefs for both langs
namespace nbl
{
namespace hlsl
{
typedef half float16_t;
typedef float float32_t;
typedef double float64_t;

#line 63 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/vector.hlsl"
// ideally we should have sized bools, but no idea what they'd be
typedef vector<bool,4> bool4; typedef vector<bool,3> bool3; typedef vector<bool,2> bool2; typedef vector<bool,1> bool1;

typedef vector<int16_t,4> int16_t4; typedef vector<int16_t,3> int16_t3; typedef vector<int16_t,2> int16_t2; typedef vector<int16_t,1> int16_t1;
typedef vector<int32_t,4> int32_t4; typedef vector<int32_t,3> int32_t3; typedef vector<int32_t,2> int32_t2; typedef vector<int32_t,1> int32_t1;
typedef vector<int64_t,4> int64_t4; typedef vector<int64_t,3> int64_t3; typedef vector<int64_t,2> int64_t2; typedef vector<int64_t,1> int64_t1;

typedef vector<uint16_t,4> uint16_t4; typedef vector<uint16_t,3> uint16_t3; typedef vector<uint16_t,2> uint16_t2; typedef vector<uint16_t,1> uint16_t1;
typedef vector<uint32_t,4> uint32_t4; typedef vector<uint32_t,3> uint32_t3; typedef vector<uint32_t,2> uint32_t2; typedef vector<uint32_t,1> uint32_t1;
typedef vector<uint64_t,4> uint64_t4; typedef vector<uint64_t,3> uint64_t3; typedef vector<uint64_t,2> uint64_t2; typedef vector<uint64_t,1> uint64_t1;

typedef vector<float16_t,4> float16_t4; typedef vector<float16_t,3> float16_t3; typedef vector<float16_t,2> float16_t2; typedef vector<float16_t,1> float16_t1;
typedef vector<float32_t,4> float32_t4; typedef vector<float32_t,3> float32_t3; typedef vector<float32_t,2> float32_t2; typedef vector<float32_t,1> float32_t1;
typedef vector<float64_t,4> float64_t4; typedef vector<float64_t,3> float64_t3; typedef vector<float64_t,2> float64_t2; typedef vector<float64_t,1> float64_t1;

}

#line 94 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/vector.hlsl"
}

#line 6 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/matrix.hlsl"
namespace nbl
{
namespace hlsl
{

#line 61 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/matrix.hlsl"
typedef matrix<bool, 4, 4> bool4x4; typedef matrix<bool, 4, 3> bool4x3; typedef matrix<bool, 4, 2> bool4x2; typedef matrix<bool, 3, 4> bool3x4; typedef matrix<bool, 3, 3> bool3x3; typedef matrix<bool, 3, 2> bool3x2; typedef matrix<bool, 2, 4> bool2x4; typedef matrix<bool, 2, 3> bool2x3; typedef matrix<bool, 2, 2> bool2x2;;
typedef matrix<int16_t, 4, 4> int16_t4x4; typedef matrix<int16_t, 4, 3> int16_t4x3; typedef matrix<int16_t, 4, 2> int16_t4x2; typedef matrix<int16_t, 3, 4> int16_t3x4; typedef matrix<int16_t, 3, 3> int16_t3x3; typedef matrix<int16_t, 3, 2> int16_t3x2; typedef matrix<int16_t, 2, 4> int16_t2x4; typedef matrix<int16_t, 2, 3> int16_t2x3; typedef matrix<int16_t, 2, 2> int16_t2x2;;
typedef matrix<int32_t, 4, 4> int32_t4x4; typedef matrix<int32_t, 4, 3> int32_t4x3; typedef matrix<int32_t, 4, 2> int32_t4x2; typedef matrix<int32_t, 3, 4> int32_t3x4; typedef matrix<int32_t, 3, 3> int32_t3x3; typedef matrix<int32_t, 3, 2> int32_t3x2; typedef matrix<int32_t, 2, 4> int32_t2x4; typedef matrix<int32_t, 2, 3> int32_t2x3; typedef matrix<int32_t, 2, 2> int32_t2x2;;
typedef matrix<int64_t, 4, 4> int64_t4x4; typedef matrix<int64_t, 4, 3> int64_t4x3; typedef matrix<int64_t, 4, 2> int64_t4x2; typedef matrix<int64_t, 3, 4> int64_t3x4; typedef matrix<int64_t, 3, 3> int64_t3x3; typedef matrix<int64_t, 3, 2> int64_t3x2; typedef matrix<int64_t, 2, 4> int64_t2x4; typedef matrix<int64_t, 2, 3> int64_t2x3; typedef matrix<int64_t, 2, 2> int64_t2x2;;
typedef matrix<uint16_t, 4, 4> uint16_t4x4; typedef matrix<uint16_t, 4, 3> uint16_t4x3; typedef matrix<uint16_t, 4, 2> uint16_t4x2; typedef matrix<uint16_t, 3, 4> uint16_t3x4; typedef matrix<uint16_t, 3, 3> uint16_t3x3; typedef matrix<uint16_t, 3, 2> uint16_t3x2; typedef matrix<uint16_t, 2, 4> uint16_t2x4; typedef matrix<uint16_t, 2, 3> uint16_t2x3; typedef matrix<uint16_t, 2, 2> uint16_t2x2;;
typedef matrix<uint32_t, 4, 4> uint32_t4x4; typedef matrix<uint32_t, 4, 3> uint32_t4x3; typedef matrix<uint32_t, 4, 2> uint32_t4x2; typedef matrix<uint32_t, 3, 4> uint32_t3x4; typedef matrix<uint32_t, 3, 3> uint32_t3x3; typedef matrix<uint32_t, 3, 2> uint32_t3x2; typedef matrix<uint32_t, 2, 4> uint32_t2x4; typedef matrix<uint32_t, 2, 3> uint32_t2x3; typedef matrix<uint32_t, 2, 2> uint32_t2x2;;
typedef matrix<uint64_t, 4, 4> uint64_t4x4; typedef matrix<uint64_t, 4, 3> uint64_t4x3; typedef matrix<uint64_t, 4, 2> uint64_t4x2; typedef matrix<uint64_t, 3, 4> uint64_t3x4; typedef matrix<uint64_t, 3, 3> uint64_t3x3; typedef matrix<uint64_t, 3, 2> uint64_t3x2; typedef matrix<uint64_t, 2, 4> uint64_t2x4; typedef matrix<uint64_t, 2, 3> uint64_t2x3; typedef matrix<uint64_t, 2, 2> uint64_t2x2;;
typedef matrix<float16_t, 4, 4> float16_t4x4; typedef matrix<float16_t, 4, 3> float16_t4x3; typedef matrix<float16_t, 4, 2> float16_t4x2; typedef matrix<float16_t, 3, 4> float16_t3x4; typedef matrix<float16_t, 3, 3> float16_t3x3; typedef matrix<float16_t, 3, 2> float16_t3x2; typedef matrix<float16_t, 2, 4> float16_t2x4; typedef matrix<float16_t, 2, 3> float16_t2x3; typedef matrix<float16_t, 2, 2> float16_t2x2;;
typedef matrix<float32_t, 4, 4> float32_t4x4; typedef matrix<float32_t, 4, 3> float32_t4x3; typedef matrix<float32_t, 4, 2> float32_t4x2; typedef matrix<float32_t, 3, 4> float32_t3x4; typedef matrix<float32_t, 3, 3> float32_t3x3; typedef matrix<float32_t, 3, 2> float32_t3x2; typedef matrix<float32_t, 2, 4> float32_t2x4; typedef matrix<float32_t, 2, 3> float32_t2x3; typedef matrix<float32_t, 2, 2> float32_t2x2;;
typedef matrix<float64_t, 4, 4> float64_t4x4; typedef matrix<float64_t, 4, 3> float64_t4x3; typedef matrix<float64_t, 4, 2> float64_t4x2; typedef matrix<float64_t, 3, 4> float64_t3x4; typedef matrix<float64_t, 3, 3> float64_t3x3; typedef matrix<float64_t, 3, 2> float64_t3x2; typedef matrix<float64_t, 2, 4> float64_t2x4; typedef matrix<float64_t, 2, 3> float64_t2x3; typedef matrix<float64_t, 2, 2> float64_t2x2;;

}

#line 89 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/matrix.hlsl"
}

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// C++ headers

#line 16 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Include only concept stuff that does not rely on type_traits
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/impl/base.hlsl"
// Copyright (C) 2023-2024 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 19 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Since HLSL currently doesnt allow type aliases we declare them as seperate structs thus they are (WORKAROUND)s
/*
 // helper class
 template<class T, T v> struct integral_constant; (DONE)
 
 template<bool B>
 using bool_constant = integral_constant<bool, B>; (WORKDAROUND)
 using true_type = bool_constant<true>; (WORKDAROUND)
 using false_type = bool_constant<false>; (WORKDAROUND)
 
 // primary type categories
 template<class T> struct is_void; (DONE)
 template<class T> struct is_null_pointer; (NOT-APPLICABLE)
 template<class T> struct is_integral; (DONE)
 template<class T> struct is_floating_point; (DONE)
 template<class T> struct is_array; (DONE)
 template<class T> struct is_pointer; (TODO)
 template<class T> struct is_lvalue_reference; (TODO)
 template<class T> struct is_rvalue_reference; (TODO)
 template<class T> struct is_member_object_pointer; (TODO)
 template<class T> struct is_member_function_pointer; (TODO)
 template<class T> struct is_enum; (NOT-APPLICABLE)
 template<class T> struct is_union; (NOT-APPLICABLE)
 template<class T> struct is_class; (NOT-APPLICABLE)
 template<class T> struct is_function; (NOT-APPLICABLE)
 
 // composite type categories
 template<class T> struct is_reference; (TODO)
 template<class T> struct is_arithmetic; (DONE)
 template<class T> struct is_fundamental; (DONE)

template<class T> struct is_object; (TODO)
 C++ spec defines object as:
 void is not an object
 int is object
 int& is not an object
 int* is object
 int*& is not an object
 cls is object
 cls& is not an object
 cls* is object
 int() is not an object
 int(*)() is object
 int(&)() is not an object
 basically !(is_reference || is_void || is_function)

template<class T> struct is_scalar; (DONE)
 template<class T> struct is_compound; (DONE)
 template<class T> struct is_member_pointer; (TODO)
 
 // type properties
 template<class T> struct is_const; (DONE)
 template<class T> struct is_volatile; (DONE)
 template<class T> struct is_trivial; (EVERYTHING IS)
 template<class T> struct is_trivially_copyable; (EVERYTHING IS)
 template<class T> struct is_standard_layout; (APPLICABLE BUT IMPOSSIBLE TO TEST WITHOUT REFLECTION)
 template<class T> struct is_empty; (DONE? sizeof(T) == 0)
 template<class T> struct is_polymorphic; (NOTHING IS)
 template<class T> struct is_abstract; (NOTHING IS)
 template<class T> struct is_final; (NOTHING IS until they add the final keyword)
 template<class T> struct is_aggregate; (DONE)
 
 template<class T> struct is_signed; (DONE)
 template<class T> struct is_unsigned; (DONE)
 template<class T> struct is_bounded_array(DONE);
 template<class T> struct is_unbounded_array(DONE);
 template<class T> struct is_scoped_enum; (NOT-APPLICABLE)

// type property queries
 template<class T> struct alignment_of; (SPECIALIZED FOR REGISTERED TYPES)
 template<class T> struct rank; (DONE)
 template<class T, unsigned I = 0> struct extent; (DONE)
 
 // type relations
 template<class T, class U> struct is_same; (DONE)
 template<class Base, class Derived> struct is_base_of; (TODO)
 template<class From, class To> struct is_convertible; (TODO)
 template<class From, class To> struct is_nothrow_convertible; (TODO: ALIAS OF is_convertible)
 template<class T, class U> struct is_layout_compatible; (TODO)
 template<class Base, class Derived> struct is_pointer_interconvertible_base_of; (NOT-APPLICABLE)
 
 NO FOLD EXPRESSIONS IN HLSL!
 template<class Fn, class... ArgTypes> struct is_invocable;
 template<class R, class Fn, class... ArgTypes> struct is_invocable_r;
 template<class Fn, class... ArgTypes> struct is_nothrow_invocable;
 template<class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
 
 // const-volatile modifications
 template<class T> struct remove_const; (DONE)
 template<class T> struct remove_volatile; (DONE)
 template<class T> struct remove_cv; (DONE)
 template<class T> struct add_const; (DONE)
 template<class T> struct add_volatile; (DONE)
 template<class T> struct add_cv; (DONE)

// reference modifications
 template<class T> struct remove_reference; (DONE BUT DONT USE)
 template<class T> struct add_lvalue_reference; (DONE BUT DONT USE)
 template<class T> struct add_rvalue_reference; (TODO)

// sign modifications
 template<class T> struct make_signed; (DONE)
 template<class T> struct make_unsigned; (DONE)
 
 // array modifications
 template<class T> struct remove_extent; (DONE)
 template<class T> struct remove_all_extents; (DONE)

// pointer modifications
 template<class T> struct remove_pointer; (NOT-POSSIBLE UNTIL PSUEDO PTRS ARE IMPLEMENTED)
 template<class T> struct add_pointer; (NOT-POSSIBLE UNTIL PSUEDO PTRS ARE IMPLEMENTED)

// other transformations
 template<class T> struct type_identity; (DONE)
 template<class T> struct remove_cvref; (DONE)
 template<class T> struct decay; (TODO)
 template<bool, class T = void> struct enable_if; (NOT-APPLICABLE)
 template<bool, class T, class F> struct conditional; (DONE)
 template<class... T> struct common_type; (NOT-APPLICABLE)
 template<class T, class U, template<class> class TQual, template<class> class UQual>
 struct basic_common_reference { }; (NOT-APPLICABLE)
 template<class... T> struct common_reference; (NOT-APPLICABLE)
 template<class T> struct underlying_type;
 template<class Fn, class... ArgTypes> struct invoke_result;
 template<class T> struct unwrap_reference; (TODO)
 template<class T> struct unwrap_ref_decay; (TODO)
 template<class...> using void_t = void; (VARIADICS NOT SUPPORTED USE `make_void` INSTEAD)

NO FOLD EXPRESSIONS IN HLSL!
 // logical operator traits
 template<class... B> struct conjunction;
 template<class... B> struct disjunction;
 template<class B> struct negation;
*/

namespace nbl
{
namespace hlsl
{
//
namespace impl
{
template<template<class> class Trait, class T>
struct base_type_forwarder : Trait<T> {};

template<template<class> class Trait, class T, uint16_t N>
struct base_type_forwarder<Trait,vector<T,N> > : Trait<T> {};

template<template<class> class Trait, class T, uint16_t N, uint16_t M>
struct base_type_forwarder<Trait,matrix<T,N,M> > : Trait<T> {};
}

//
template<class>
struct make_void { using type = void; };

#line 181 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
template<class T>
struct type_identity 
{
 using type = T;
};

namespace impl
{
template<class> struct remove_reference;
}

template<class T> struct remove_const : type_identity<T> {};
template<class T> struct remove_const<const T> : type_identity<T> {};

template<class T> struct remove_volatile : type_identity<T> {};
template<class T> struct remove_volatile<volatile T> : type_identity<T> {};

template<class T> struct remove_cv : type_identity<T> {};
template<class T> struct remove_cv<const T> : type_identity<T> {};
template<class T> struct remove_cv<volatile T> : type_identity<T> {};
template<class T> struct remove_cv<const volatile T> : type_identity<T> {};

template<class T> struct remove_cvref : remove_cv<typename impl::remove_reference<T>::type> {};

template<class T> struct add_const : type_identity<const T> {};
template<class T> struct add_volatile : type_identity<volatile T> {};
template<class T> struct add_cv : type_identity<const volatile T> {};

template<class T, T val>
struct integral_constant {
 const static T value = val;
 using value_type = T;
};

template<bool val>
struct bool_constant : integral_constant<bool, val> {};

struct true_type : bool_constant<true> {};
struct false_type : bool_constant<false> {};

template<bool C, class T, class F>
struct conditional : type_identity<T> {};

template<class T, class F>
struct conditional<false, T, F> : type_identity<F> {};

template<class A, class B>
struct is_same : bool_constant<false> {};

template<class A>
struct is_same<A,A> : bool_constant<true> {};

template<class T>
struct is_void : bool_constant<is_same<typename remove_cv<T>::type, void>::value> {};

template<class T>
struct is_bounded_array : bool_constant<false> {};

template<class T, uint32_t count>
struct is_bounded_array<T[count]> : bool_constant<true>{};

template<class T>
struct is_unbounded_array : bool_constant<false>{};

template<class T>
struct is_unbounded_array<T[]> : bool_constant<true>{};

template<class T>
struct is_array : bool_constant<is_bounded_array<T>::value || is_unbounded_array<T>::value> {};

namespace impl
{

// need this crutch because we can't make `#define typeid` work both on expression and types
template<typename T>
struct typeid_t;

template<typename T, T v>
struct function_info : type_identity<void> {};

template<class T>
struct is_unsigned : bool_constant<
 is_same<T, bool>::value ||
 is_same<T, uint16_t>::value ||
 is_same<T, uint32_t>::value ||
 is_same<T, uint64_t>::value
> {};

template<class T>
struct is_integral : bool_constant<
 is_same<T, bool>::value ||
 is_same<T, uint16_t>::value ||
 is_same<T, uint32_t>::value ||
 is_same<T, uint64_t>::value ||
 is_same<T, int16_t>::value ||
 is_same<T, int32_t>::value ||
 is_same<T, int64_t>::value
> {};

template<class T>
struct is_floating_point : bool_constant<
 is_same<T, half>::value ||
 is_same<T, float>::value ||
 is_same<T, double>::value
> {};

template<class T>
struct is_signed : bool_constant<
 is_same<T, int16_t>::value ||
 is_same<T, int32_t>::value ||
 is_same<T, int64_t>::value ||
 is_floating_point<T>::value
> {};

}

//! For inline SPIR-V
template<typename T>
struct is_vk_Literal : false_type {};
template<typename IC>
struct is_vk_Literal<vk::Literal<IC> > : true_type
{
 using type = IC;
};
template<typename T>
const static bool is_vk_Literal_v = is_vk_Literal<T>::value;

// DXC doesn't support variadics, matches need to be declared in reverse, most args to least (in case templates have defaults0

#line 314 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
template<typename T>
struct is_spirv_opaque_type : false_type {};
#line 318 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
template<uint32_t OpType ,typename T0 ,typename T1 ,typename T2> struct is_spirv_opaque_type<vk::SpirvOpaqueType<OpType ,T0 ,T1 ,T2> > : true_type {};
template<uint32_t OpType ,typename T0 ,typename T1> struct is_spirv_opaque_type<vk::SpirvOpaqueType<OpType ,T0 ,T1> > : true_type {};
template<uint32_t OpType ,typename T0> struct is_spirv_opaque_type<vk::SpirvOpaqueType<OpType ,T0> > : true_type {};
template<uint32_t OpType > struct is_spirv_opaque_type<vk::SpirvOpaqueType<OpType > > : true_type {};
template<class T>
const static bool is_spirv_opaque_type_v = is_spirv_opaque_type<T>::value;

template<typename T>
struct is_spirv_storable_type : false_type {};
#line 330 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
template<uint32_t OpType, uint32_t Size, uint32_t Alignment ,typename T0 ,typename T1 ,typename T2> struct is_spirv_storable_type<vk::SpirvType<OpType,Size,Alignment ,T0 ,T1 ,T2> > : true_type {};
template<uint32_t OpType, uint32_t Size, uint32_t Alignment ,typename T0 ,typename T1> struct is_spirv_storable_type<vk::SpirvType<OpType,Size,Alignment ,T0 ,T1> > : true_type {};
template<uint32_t OpType, uint32_t Size, uint32_t Alignment ,typename T0> struct is_spirv_storable_type<vk::SpirvType<OpType,Size,Alignment ,T0> > : true_type {};
template<uint32_t OpType, uint32_t Size, uint32_t Alignment > struct is_spirv_storable_type<vk::SpirvType<OpType,Size,Alignment > > : true_type {};
template<class T>
const static bool is_spirv_storable_type_v = is_spirv_storable_type<T>::value;

template<typename T>
struct is_spirv_type : bool_constant<is_spirv_opaque_type_v<T>||is_spirv_storable_type_v<T> > {};
template<class T>
const static bool is_spirv_type_v = is_spirv_type<T>::value;

template<class T> 
struct is_unsigned : impl::base_type_forwarder<impl::is_unsigned, typename remove_cv<T>::type> {};

template<class T> 
struct is_integral : impl::base_type_forwarder<impl::is_integral, typename remove_cv<T>::type> {};

template<class T> 
struct is_floating_point : impl::base_type_forwarder<impl::is_floating_point, typename remove_cv<T>::type> {};

template<class T>
struct is_signed : impl::base_type_forwarder<impl::is_signed, typename remove_cv<T>::type> {};

template<class T>
struct is_scalar : bool_constant<
 impl::is_integral<typename remove_cv<T>::type>::value || 
 impl::is_floating_point<typename remove_cv<T>::type>::value
> {};

template<class T>
struct is_const : bool_constant<false> {};

template<class T>
struct is_const<const T> : bool_constant<true> {};

template<class T>
struct is_volatile : bool_constant<false> {};

template<class T>
struct is_volatile<volatile T> : bool_constant<true> {};

template<class>
struct is_trivial : bool_constant<true> {};

template<class>
struct is_trivially_copyable : bool_constant<true> {};

// this implementation is fragile
template<class T>
struct is_empty : bool_constant<0==sizeof(T)> {};

template<class>
struct is_polymorphic : bool_constant<false> {};

template<class>
struct is_abstract : bool_constant<false> {};

template<class>
struct is_final : bool_constant<false> {};

template <class T>
struct is_fundamental : bool_constant<
 is_scalar<T>::value || 
 is_void<T>::value
> {};

template <class T>
struct is_compound : bool_constant<!is_fundamental<T>::value> {};

template <class T>
struct is_aggregate : is_compound<T> {};

template<class T>
struct rank : integral_constant<uint64_t, 0> { };

template<class T, uint64_t N>
struct rank<T[N]> : integral_constant<uint64_t, 1 + rank<T>::value> { };

template<class T>
struct rank<T[]> : integral_constant<uint64_t, 1 + rank<T>::value> { };

template<class T, uint32_t I = 0 ,typename __requires=void>
struct extent : integral_constant<uint64_t, 0> {};

template<class T, uint64_t N> 
struct extent<T[N], 0> : integral_constant<uint64_t, N> {};

template<class T, uint64_t N, uint32_t I> 
struct extent<T[N], I> : integral_constant<uint64_t,extent<T, I - 1>::value> {};

template<class T, uint32_t I> 
struct extent<T[], I> : integral_constant<uint64_t,extent<T, I - 1>::value> {};

template<bool B, class T = void>
struct enable_if {};
 
template<class T>
struct enable_if<true, T> : type_identity<T> {};

// DXC sometimes doesn't report sizeof properly
template<class T>
struct size_of
{
 const static uint64_t value = sizeof(T);
};

template<class T>
struct alignment_of;

// reference stuff needed for semantics

// not for "human consumption"
// dxc doesnt actually allow variables to be references
// every reference is treated as having 'restrict' qualifier
// https://godbolt.org/z/dsj99fY96
namespace impl
{

template<typename,class=void>
struct is_reference : bool_constant<true> { };

template<typename T>
struct is_reference<T,typename make_void<T[1]>::type> : bool_constant<false> { };

template<class T, bool = is_reference<T>::value>
struct add_reference_helper : type_identity<T> {};

template<class T>
struct add_reference_helper<T, false>
{
 static T member[1];
 using type = __decltype(member[0]);
};

template<class T>
struct add_lvalue_reference : add_reference_helper<T> {};

template<typename T>
T remove_reference_impl(T v)
{
 return v;
}

template<typename T, bool = is_reference<T>::value>
struct remove_reference_helper : type_identity<T> {};

template<typename T>
struct remove_reference_helper<T, true>
{
 static T member;
 using type = __decltype(remove_reference_impl(member));
};

template<typename T>
struct remove_reference : remove_reference_helper<T> {};

}

template<class T> struct remove_extent : type_identity<T> {};
template<class T, uint32_t I> struct remove_extent<T[I]> : type_identity<T> {};
template<class T> struct remove_extent<T[]> : type_identity<T> {};

template<typename T, int N>
struct remove_extent<vector<T, N> > : type_identity<T> {};
template<typename T, int N, int M>
struct remove_extent<matrix<T, N, M> > : type_identity<vector<T, N> > {};

template <class T>
struct remove_all_extents : type_identity<T> {};

template <class T, uint32_t I>
struct remove_all_extents<T[I]> : type_identity<typename remove_all_extents<T>::type> {};

template <class T>
struct remove_all_extents<T[]> : type_identity<typename remove_all_extents<T>::type> {};

namespace impl
{

template<uint32_t sz> struct int_type :
 conditional<8==sz, int64_t, typename conditional<4==sz, int32_t, int16_t>::type>{};

template<uint32_t sz> struct uint_type : 
 conditional<8==sz, uint64_t, typename conditional<4==sz, uint32_t, uint16_t>::type>{};
}

template<class T>
struct make_signed : impl::int_type<sizeof(T)>
{
 _Static_assert(is_integral<T>::value && !is_same<typename remove_cv<T>::type, bool>::value,
 "make_signed<T> requires that T shall be a (possibly cv-qualified) "
 "integral type or enumeration but not a bool type.");
};

template<class T>
struct make_unsigned : impl::uint_type<sizeof(T)>
{
 _Static_assert(is_integral<T>::value && !is_same<typename remove_cv<T>::type, bool>::value, 
 "make_unsigned<T> requires that T shall be a (possibly cv-qualified) "
 "integral type or enumeration but not a bool type.");
};

#line 659 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Template Types
template<bool B, class T = void>
using enable_if_t = typename enable_if<B,T>::type;
template<bool C, class T, class F>
using conditional_t = typename conditional<C,T,F>::type;

// Template Variables
template<class T, T val>
const static T integral_constant_v = integral_constant<T, val>::value;
template<typename A, typename B>
const static bool is_same_v = is_same<A, B>::value;
template<class T>
const static bool is_unsigned_v = is_unsigned<T>::value;
template<class T>
const static bool is_integral_v = is_integral<T>::value;
template<class T>
const static bool is_floating_point_v = is_floating_point<T>::value;
template<class T>
const static bool is_signed_v = is_signed<T>::value;
template<class T>
const static bool is_scalar_v = is_scalar<T>::value;
template<class T>
const static uint64_t size_of_v = size_of<T>::value;
template<class T>
const static uint32_t alignment_of_v = alignment_of<T>::value;
template<class T, uint32_t N = 0>
const static uint64_t extent_v = extent<T, N>::value;
template<typename T>
const static bool is_fundamental_v = is_fundamental<T>::value;

// Overlapping definitions
template<typename T>
using make_void_t = typename make_void<T>::type;

template<typename T>
using make_signed_t = typename make_signed<T>::type;

template<typename T>
using make_unsigned_t = typename make_unsigned<T>::type;

template<bool C, typename T, T A, T B>
struct conditional_value
{
 const static T value = C ? A : B;
};

template<class T>
struct is_vector : bool_constant<false> {};

template<class T>
struct is_matrix : bool_constant<false> {};

template<class T, uint32_t N>
struct is_vector<vector<T, N> > : bool_constant<true> {};

template<typename T>
const static bool is_vector_v = is_vector<T>::value;

#line 724 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
template<class T, uint32_t N, uint32_t M>
struct is_matrix<matrix<T, N, M> > : bool_constant<true> {};

template<class T>
const static bool is_matrix_v = is_matrix<T>::value;

template<typename T,bool=is_scalar<T>::value>
struct scalar_type
{
 using type = void;
};

template<typename T>
struct scalar_type<T,true>
{
 using type = T;
};

template<typename T, uint16_t N>
struct scalar_type<vector<T,N>,false>
{
 using type = T;
};

template<typename T, uint16_t N, uint16_t M>
struct scalar_type<matrix<T,N,M>,false>
{
 using type = T;
};

template<typename T>
using scalar_type_t = typename scalar_type<T>::type;

template<uint16_t bytesize>
struct integer_of_size
{
 using type = void;
};

#line 771 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
template<>
struct integer_of_size<2>
{
 using type = int16_t;
};
template<>
struct integer_of_size<4>
{
 using type = int32_t;
};
template<>
struct integer_of_size<8>
{
 using type = int64_t;
};
template<uint16_t bytesize>
using integer_of_size_t = typename integer_of_size<bytesize>::type;

template<uint16_t bytesize>
struct unsigned_integer_of_size
{
 using type = void;
};
#line 801 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
template<>
struct unsigned_integer_of_size<2>
{
 using type = uint16_t;
};
template<>
struct unsigned_integer_of_size<4>
{
 using type = uint32_t;
};
template<>
struct unsigned_integer_of_size<8>
{
 using type = uint64_t;
};
template<uint16_t bytesize>
using unsigned_integer_of_size_t = typename unsigned_integer_of_size<bytesize>::type;

template<uint16_t bytesize>
struct float_of_size
{
 using type = void;
};
template<>
struct float_of_size<2>
{
 using type = float16_t;
};
template<>
struct float_of_size<4>
{
 using type = float32_t;
};
template<>
struct float_of_size<8>
{
 using type = float64_t;
};
template<uint16_t bytesize>
using float_of_size_t = typename float_of_size<bytesize>::type;

template<typename T, int N>
struct extent<vector<T, N>, 0> : integral_constant<uint64_t, N> {};

template<typename T, int N, int M>
struct extent<matrix<T, N, M>, 0> : integral_constant<uint64_t, N> {};

template<typename T, int N, int M>
struct extent<matrix<T, N, M>, 1> : integral_constant<uint64_t, M> {};

}
}

// deal with typetraits, for now we rely on Clang/DXC internal __decltype(), if it breaks we revert to commit e4ab38ca227b15b2c79641c39161f1f922b779a3

#line 859 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// shoudl really return a std::type_info like struct or something, but no `constexpr` and unsure whether its possible to have a `const static SomeStruct` makes it hard to do...

// Found a bug in Boost.Wave, try to avoid multi-line macros https://github.com/boostorg/wave/issues/195

#line 872 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// TODO: find out how to do it such that we don't get duplicate definition if we use two function identifiers with same signature

// TODO: ideally we'd like to call NBL_REGISTER_FUN_TYPE under the hood, but we can't right now. Also we have a bigger problem, the passing of the function identifier as the second template parameter doesn't work :(
/*
template<> struct function_info<__decltype(fn),fn> { using type = __decltype(fn); static const uint32_t address = __COUNTER__; }; }}}}
*/

// builtins

#line 900 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t1 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t1 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t1 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t1 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t2x4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t2x4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t2x4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t2x4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t2x3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t2x3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t2x3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t2x3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t2x2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t2x2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t2x2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t2x2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t3x4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t3x4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t3x4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t3x4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t3x3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t3x3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t3x3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t3x3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t3x2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t3x2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t3x2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t3x2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t4x4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t4x4 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t4x4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t4x4 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t4x3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t4x3 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t4x3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t4x3 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int16_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int16_t4x2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<const int16_t4x2 > : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int16_t4x2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int16_t4x2 >::type> : integral_constant<uint32_t, sizeof(int16_t) > {}; }}
namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t1 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t1 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t1 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t1 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t2x4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t2x4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t2x4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t2x4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t2x3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t2x3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t2x3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t2x3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t2x2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t2x2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t2x2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t2x2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t3x4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t3x4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t3x4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t3x4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t3x3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t3x3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t3x3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t3x3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t3x2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t3x2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t3x2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t3x2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t4x4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t4x4 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t4x4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t4x4 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t4x3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t4x3 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t4x3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t4x3 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int32_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int32_t4x2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<const int32_t4x2 > : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int32_t4x2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int32_t4x2 >::type> : integral_constant<uint32_t, sizeof(int32_t) > {}; }}
namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t1 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t1 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t1 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t1 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t2x4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t2x4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t2x4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t2x4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t2x3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t2x3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t2x3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t2x3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t2x2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t2x2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t2x2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t2x2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t3x4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t3x4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t3x4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t3x4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t3x3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t3x3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t3x3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t3x3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t3x2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t3x2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t3x2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t3x2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t4x4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t4x4 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t4x4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t4x4 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t4x3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t4x3 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t4x3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t4x3 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<int64_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<int64_t4x2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<const int64_t4x2 > : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<int64_t4x2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const int64_t4x2 >::type> : integral_constant<uint32_t, sizeof(int64_t) > {}; }}

namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t1 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t1 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t1 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t1 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t2x4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t2x4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t2x4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t2x4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t2x3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t2x3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t2x3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t2x3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t2x2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t2x2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t2x2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t2x2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t3x4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t3x4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t3x4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t3x4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t3x3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t3x3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t3x3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t3x3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t3x2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t3x2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t3x2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t3x2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t4x4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t4x4 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t4x4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t4x4 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t4x3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t4x3 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t4x3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t4x3 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint16_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint16_t4x2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<const uint16_t4x2 > : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint16_t4x2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint16_t4x2 >::type> : integral_constant<uint32_t, sizeof(uint16_t) > {}; }}
namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t1 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t1 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t1 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t1 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t2x4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t2x4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t2x4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t2x4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t2x3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t2x3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t2x3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t2x3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t2x2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t2x2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t2x2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t2x2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t3x4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t3x4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t3x4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t3x4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t3x3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t3x3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t3x3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t3x3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t3x2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t3x2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t3x2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t3x2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t4x4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t4x4 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t4x4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t4x4 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t4x3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t4x3 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t4x3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t4x3 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint32_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint32_t4x2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<const uint32_t4x2 > : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint32_t4x2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint32_t4x2 >::type> : integral_constant<uint32_t, sizeof(uint32_t) > {}; }}
namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t1 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t1 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t1 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t1 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t2x4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t2x4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t2x4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t2x4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t2x3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t2x3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t2x3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t2x3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t2x2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t2x2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t2x2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t2x2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t3x4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t3x4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t3x4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t3x4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t3x3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t3x3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t3x3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t3x3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t3x2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t3x2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t3x2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t3x2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t4x4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t4x4 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t4x4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t4x4 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t4x3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t4x3 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t4x3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t4x3 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<uint64_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<uint64_t4x2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<const uint64_t4x2 > : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<uint64_t4x2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const uint64_t4x2 >::type> : integral_constant<uint32_t, sizeof(uint64_t) > {}; }}

namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool1 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool1 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool1 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool1 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool2x4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool2x4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool2x4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool2x4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool2x3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool2x3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool2x3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool2x3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool2x2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool2x2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool2x2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool2x2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool3x4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool3x4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool3x4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool3x4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool3x3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool3x3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool3x3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool3x3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool3x2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool3x2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool3x2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool3x2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool4x4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool4x4 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool4x4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool4x4 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool4x3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool4x3 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool4x3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool4x3 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<bool4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<bool4x2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<const bool4x2 > : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<bool4x2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const bool4x2 >::type> : integral_constant<uint32_t, sizeof(bool) > {}; }}

namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t1 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t1 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t1 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t1 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t2x4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t2x4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t2x4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t2x4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t2x3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t2x3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t2x3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t2x3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t2x2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t2x2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t2x2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t2x2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t3x4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t3x4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t3x4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t3x4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t3x3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t3x3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t3x3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t3x3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t3x2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t3x2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t3x2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t3x2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t4x4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t4x4 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t4x4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t4x4 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t4x3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t4x3 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t4x3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t4x3 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float16_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float16_t4x2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<const float16_t4x2 > : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float16_t4x2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float16_t4x2 >::type> : integral_constant<uint32_t, sizeof(float16_t) > {}; }}
namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t1 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t1 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t1 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t1 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t2x4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t2x4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t2x4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t2x4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t2x3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t2x3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t2x3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t2x3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t2x2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t2x2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t2x2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t2x2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t3x4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t3x4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t3x4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t3x4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t3x3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t3x3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t3x3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t3x3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t3x2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t3x2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t3x2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t3x2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t4x4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t4x4 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t4x4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t4x4 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t4x3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t4x3 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t4x3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t4x3 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float32_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float32_t4x2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<const float32_t4x2 > : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float32_t4x2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float32_t4x2 >::type> : integral_constant<uint32_t, sizeof(float32_t) > {}; }}
namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t1 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t1 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t1 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t1 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t1 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t2x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t2x4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t2x4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t2x4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t2x4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t2x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t2x3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t2x3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t2x3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t2x3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t2x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t2x2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t2x2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t2x2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t2x2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t3x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t3x4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t3x4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t3x4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t3x4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t3x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t3x3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t3x3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t3x3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t3x3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t3x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t3x2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t3x2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t3x2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t3x2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t4x4 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t4x4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t4x4 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t4x4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t4x4 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t4x3 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t4x3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t4x3 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t4x3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t4x3 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }} namespace nbl { namespace hlsl { namespace impl { template<> struct typeid_t<float64_t4x2 > : integral_constant<uint32_t,__COUNTER__> {}; } template<> struct alignment_of<float64_t4x2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<const float64_t4x2 > : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<float64_t4x2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; template<> struct alignment_of<typename impl::add_lvalue_reference<const float64_t4x2 >::type> : integral_constant<uint32_t, sizeof(float64_t) > {}; }}

#line 5 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/vector_utils/vector_traits.hlsl"
namespace nbl
{
namespace hlsl
{

// The whole purpose of this file is to enable the creation of partial specializations of the vector_traits for 
// custom types without introducing circular dependencies.

template<typename T>
struct vector_traits
{
 using scalar_type = T;
 const static uint32_t Dimension = 1u;
 const static bool IsVector = false;
};

// i choose to implement it this way because of this DXC bug: https://github.com/microsoft/DirectXShaderCom0piler/issues/7007
#line 31 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/vector_utils/vector_traits.hlsl"
template<typename T> struct vector_traits<vector<T, 2> >{ using scalar_type = T; const static uint32_t Dimension = 2; const static bool IsVector = true;};
template<typename T> struct vector_traits<vector<T, 3> >{ using scalar_type = T; const static uint32_t Dimension = 3; const static bool IsVector = true;};
template<typename T> struct vector_traits<vector<T, 4> >{ using scalar_type = T; const static uint32_t Dimension = 4; const static bool IsVector = true;};

}
}

#line 6 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/array_accessors.hlsl"
namespace nbl
{
namespace hlsl
{
template<typename ArrayType, typename ComponentType, typename I = uint32_t>
struct array_get
{
 ComponentType operator()(const in ArrayType arr, const I ix) 
 {
 return arr[ix];
 }
};

template<typename ArrayType, typename ComponentType, typename I = uint32_t>
struct array_set
{
 void operator()([[vk::ext_reference]] inout ArrayType arr, I index, ComponentType val) 
 {
 arr[index] = val;
 }
};
}
}

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/matrix_utils/matrix_traits.hlsl"
namespace nbl
{
namespace hlsl
{

template<typename T>
struct matrix_traits
{
 using scalar_type = T;
 using row_type = void;
 using transposed_type = void;
 const static uint32_t RowCount = 1;
 const static uint32_t ColumnCount = 1;
 const static bool Square = false;
 const static bool IsMatrix = false;
};

// i choose to implement it this way because of this DXC bug: https://github.com/microsoft/DirectXShaderCompiler/issues/7007

#line 38 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/matrix_utils/matrix_traits.hlsl"
template<typename T> struct matrix_traits<matrix<T, 1, 2> > { using scalar_type = T; using row_type = vector<T, 2>; using transposed_type = matrix<T, 2, 1>; const static uint32_t RowCount = 1; const static uint32_t ColumnCount = 2; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 1, 3> > { using scalar_type = T; using row_type = vector<T, 3>; using transposed_type = matrix<T, 3, 1>; const static uint32_t RowCount = 1; const static uint32_t ColumnCount = 3; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 1, 4> > { using scalar_type = T; using row_type = vector<T, 4>; using transposed_type = matrix<T, 4, 1>; const static uint32_t RowCount = 1; const static uint32_t ColumnCount = 4; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 2, 1> > { using scalar_type = T; using row_type = vector<T, 1>; using transposed_type = matrix<T, 1, 2>; const static uint32_t RowCount = 2; const static uint32_t ColumnCount = 1; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 2, 2> > { using scalar_type = T; using row_type = vector<T, 2>; using transposed_type = matrix<T, 2, 2>; const static uint32_t RowCount = 2; const static uint32_t ColumnCount = 2; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 2, 3> > { using scalar_type = T; using row_type = vector<T, 3>; using transposed_type = matrix<T, 3, 2>; const static uint32_t RowCount = 2; const static uint32_t ColumnCount = 3; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 2, 4> > { using scalar_type = T; using row_type = vector<T, 4>; using transposed_type = matrix<T, 4, 2>; const static uint32_t RowCount = 2; const static uint32_t ColumnCount = 4; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 3, 1> > { using scalar_type = T; using row_type = vector<T, 1>; using transposed_type = matrix<T, 1, 3>; const static uint32_t RowCount = 3; const static uint32_t ColumnCount = 1; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 3, 2> > { using scalar_type = T; using row_type = vector<T, 2>; using transposed_type = matrix<T, 2, 3>; const static uint32_t RowCount = 3; const static uint32_t ColumnCount = 2; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 3, 3> > { using scalar_type = T; using row_type = vector<T, 3>; using transposed_type = matrix<T, 3, 3>; const static uint32_t RowCount = 3; const static uint32_t ColumnCount = 3; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 3, 4> > { using scalar_type = T; using row_type = vector<T, 4>; using transposed_type = matrix<T, 4, 3>; const static uint32_t RowCount = 3; const static uint32_t ColumnCount = 4; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 4, 1> > { using scalar_type = T; using row_type = vector<T, 1>; using transposed_type = matrix<T, 1, 4>; const static uint32_t RowCount = 4; const static uint32_t ColumnCount = 1; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 4, 2> > { using scalar_type = T; using row_type = vector<T, 2>; using transposed_type = matrix<T, 2, 4>; const static uint32_t RowCount = 4; const static uint32_t ColumnCount = 2; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 4, 3> > { using scalar_type = T; using row_type = vector<T, 3>; using transposed_type = matrix<T, 3, 4>; const static uint32_t RowCount = 4; const static uint32_t ColumnCount = 3; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };
template<typename T> struct matrix_traits<matrix<T, 4, 4> > { using scalar_type = T; using row_type = vector<T, 4>; using transposed_type = matrix<T, 4, 4>; const static uint32_t RowCount = 4; const static uint32_t ColumnCount = 4; const static bool Square = RowCount == ColumnCount; const static bool IsMatrix = true; };

// TODO: when this bug: https://github.com/microsoft/DirectXShaderCompiler/issues/7007 is fixed, uncomment and delete template specializations
/*template<typename T, uint32_t N, uint32_t M>
struct matrix_traits<matrix<T,N,M> >
{
 using scalar_type = T;
 NBL_CONSTEXPR_STATIC_INLINE uint32_t RowCount = ROW_COUNT;
 NBL_CONSTEXPR_STATIC_INLINE uint32_t ColumnCount = COLUMN_COUNT;
 NBL_CONSTEXPR_STATIC_INLINE bool Square = RowCount == ColumnCount;
};
*/

}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
// Copyright (C) 2023-2024 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/utility.hlsl"
// Copyright (C) 2024 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 11 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/utility.hlsl"
// for now we only implement declval
namespace nbl
{
namespace hlsl
{
template<typename T>
const static bool always_true = true;

#line 28 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/utility.hlsl"
namespace experimental
{

template<class T>
T declval() {}

}

}
}

#line 14 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
namespace nbl
{
namespace hlsl
{
namespace concepts
{
// common implementation juice

#line 31 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
//
#line 34 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
//

//! Now diverge

#line 77 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
// for struct definitions, use instead of closing `>` on the primary template parameter list

// NOTE: C++20 requires and C++11 enable_if have to be in different places! ITS OF UTTMOST IMPORTANCE YOUR REQUIRE CLAUSES ARE IDENTICAL FOR BOTH MACROS
// put just after the closing `>` on the partial template specialization `template` declaration e.g. `template<typename U, typename V, typename T> NBL_PARTIAL_REQ_TOP(SomeCond)

// put just before closing `>` on the partial template specialization Type args, e.g. `MyStruct<U,V,T NBL_PARTIAL_REQ_BOT(SomeCond)>

// condition, use instead of the closing `>` of a function template

//
#line 92 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
//

//
#line 98 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
//

//
#line 107 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
//

#line 115 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
// TODO: counterparts of all the other concepts

}
}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/output_structs.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/core.hlsl"
// Copyright (C) 2024-2025 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/core.hlsl"
namespace nbl
{
namespace hlsl
{
namespace concepts
{

template<typename T, typename U>
const static bool same_as = is_same_v<T, U>;

template<typename T>
const static bool Integral = nbl::hlsl::is_integral_v<T>;

template<typename T>
const static bool SignedIntegral = nbl::hlsl::is_signed_v<T> && nbl::hlsl::is_integral_v<T>;

template<typename T>
const static bool UnsignedIntegral = !nbl::hlsl::is_signed_v<T> && ::nbl::hlsl::is_integral_v<T>;

template<typename T>
const static bool FloatingPoint = nbl::hlsl::is_floating_point_v<T>;

template<typename T>
const static bool Boolean = nbl::hlsl::is_same_v<T, bool> || (nbl::hlsl::is_vector_v<T> && nbl::hlsl::is_same_v<typename vector_traits<T>::scalar_type, bool>);

template <typename T>
const static bool Scalar = nbl::hlsl::is_scalar_v<T>;

template<typename T>
const static bool IntegralScalar = nbl::hlsl::is_integral_v<T> && nbl::hlsl::is_scalar_v<T>;

template<typename T>
const static bool SignedIntegralScalar = nbl::hlsl::is_signed_v<T> && nbl::hlsl::is_integral_v<T> && nbl::hlsl::is_scalar_v<T>;

template<typename T>
const static bool UnsignedIntegralScalar = !nbl::hlsl::is_signed_v<T> && ::nbl::hlsl::is_integral_v<T> && nbl::hlsl::is_scalar_v<T>;

template<typename T>
const static bool FloatingPointScalar = nbl::hlsl::is_floating_point_v<T> && nbl::hlsl::is_scalar_v<T>;

template<typename T>
const static bool BooleanScalar = concepts::Boolean<T> && nbl::hlsl::is_scalar_v<T>;

// TODO: implement when hlsl::is_base_of is done
//#define NBL_CONCEPT_NAME DerivedFrom
// ...

// TODO: implement when hlsl::is_converible is done
//#define NBL_CONCEPT_NAME ConvertibleTo
// ...

// TODO?
//#define NBL_CONCEPT_NAME AssignableFrom

// TODO?
//template <typename T, typename U>
//concept common_with = std::common_with<T, U>;

namespace impl
{
template<typename T>
struct is_emulating_floating_point_scalar
{
	const static bool value = FloatingPointScalar<T>;
};

template<typename T>
struct is_emulating_integral_scalar
{
	const static bool value = IntegralScalar<T>;
};
}

//! Floating point types are native floating point types or types that imitate native floating point types (for example emulated_float64_t)
template<typename T>
const static bool FloatingPointLikeScalar = impl::is_emulating_floating_point_scalar<T>::value;

//! Integral-like types are native integral types or types that imitate native integral types (for example emulated_uint64_t)
template<typename T>
const static bool IntegralLikeScalar = impl::is_emulating_integral_scalar<T>::value;

}
}
}

#line 9 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/output_structs.hlsl"
namespace nbl
{
namespace hlsl
{
namespace spirv
{

template<typename T ,typename __requires=void>
struct AddCarryOutput;
template<typename T ,typename __requires=void>
struct SubBorrowOutput;

template<typename T> 
struct AddCarryOutput<T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegral<T>),void> >
{
	T result;
	T carry;
};

template<typename T> 
struct SubBorrowOutput<T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegral<T>),void> >
{
	T result;
	T borrow;
};

}
}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/3rdparty/dxc/dxc/external/SPIRV-Headers/include/spirv/unified1/spirv.hpp"
// Copyright (c) 2014-2024 The Khronos Group Inc.
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and/or associated documentation files (the "Materials"),
// to deal in the Materials without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Materials, and to permit persons to whom the
// Materials are furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Materials.
// 
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
// 
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
// IN THE MATERIALS.

// This header is automatically generated by the same tool that creates
// the Binary Section of the SPIR-V specification.

// Enumeration tokens for SPIR-V, in various styles:
// C, C++, C++11, JSON, Lua, Python, C#, D, Beef
// 
// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
// - C# will use enum classes in the Specification class located in the "Spv" namespace,
// e.g.: Spv.Specification.SourceLanguage.GLSL
// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
// - Beef will use enum classes in the Specification class located in the "Spv" namespace,
// e.g.: Spv.Specification.SourceLanguage.GLSL
// 
// Some tokens act like mask values, which can be OR'd together,
// while others are mutually exclusive. The mask-like ones have
// "Mask" in their name, and a parallel enum that has the shift
// amount (1 << x) for each corresponding enumerant.

#line 50 "C:/Users/fjlet/Desktop/Nabla/3rdparty/dxc/dxc/external/SPIRV-Headers/include/spirv/unified1/spirv.hpp"
namespace spv {

typedef unsigned int Id;

#line 57 "C:/Users/fjlet/Desktop/Nabla/3rdparty/dxc/dxc/external/SPIRV-Headers/include/spirv/unified1/spirv.hpp"
static const unsigned int MagicNumber = 0x07230203;
static const unsigned int Version = 0x00010600;
static const unsigned int Revision = 1;
static const unsigned int OpCodeMask = 0xffff;
static const unsigned int WordCountShift = 16;

enum SourceLanguage {
    SourceLanguageUnknown = 0,
    SourceLanguageESSL = 1,
    SourceLanguageGLSL = 2,
    SourceLanguageOpenCL_C = 3,
    SourceLanguageOpenCL_CPP = 4,
    SourceLanguageHLSL = 5,
    SourceLanguageCPP_for_OpenCL = 6,
    SourceLanguageSYCL = 7,
    SourceLanguageHERO_C = 8,
    SourceLanguageNZSL = 9,
    SourceLanguageWGSL = 10,
    SourceLanguageSlang = 11,
    SourceLanguageZig = 12,
    SourceLanguageRust = 13,
    SourceLanguageMax = 0x7fffffff,
};

enum ExecutionModel {
    ExecutionModelVertex = 0,
    ExecutionModelTessellationControl = 1,
    ExecutionModelTessellationEvaluation = 2,
    ExecutionModelGeometry = 3,
    ExecutionModelFragment = 4,
    ExecutionModelGLCompute = 5,
    ExecutionModelKernel = 6,
    ExecutionModelTaskNV = 5267,
    ExecutionModelMeshNV = 5268,
    ExecutionModelRayGenerationKHR = 5313,
    ExecutionModelRayGenerationNV = 5313,
    ExecutionModelIntersectionKHR = 5314,
    ExecutionModelIntersectionNV = 5314,
    ExecutionModelAnyHitKHR = 5315,
    ExecutionModelAnyHitNV = 5315,
    ExecutionModelClosestHitKHR = 5316,
    ExecutionModelClosestHitNV = 5316,
    ExecutionModelMissKHR = 5317,
    ExecutionModelMissNV = 5317,
    ExecutionModelCallableKHR = 5318,
    ExecutionModelCallableNV = 5318,
    ExecutionModelTaskEXT = 5364,
    ExecutionModelMeshEXT = 5365,
    ExecutionModelMax = 0x7fffffff,
};

enum AddressingModel {
    AddressingModelLogical = 0,
    AddressingModelPhysical32 = 1,
    AddressingModelPhysical64 = 2,
    AddressingModelPhysicalStorageBuffer64 = 5348,
    AddressingModelPhysicalStorageBuffer64EXT = 5348,
    AddressingModelMax = 0x7fffffff,
};

enum MemoryModel {
    MemoryModelSimple = 0,
    MemoryModelGLSL450 = 1,
    MemoryModelOpenCL = 2,
    MemoryModelVulkan = 3,
    MemoryModelVulkanKHR = 3,
    MemoryModelMax = 0x7fffffff,
};

enum ExecutionMode {
    ExecutionModeInvocations = 0,
    ExecutionModeSpacingEqual = 1,
    ExecutionModeSpacingFractionalEven = 2,
    ExecutionModeSpacingFractionalOdd = 3,
    ExecutionModeVertexOrderCw = 4,
    ExecutionModeVertexOrderCcw = 5,
    ExecutionModePixelCenterInteger = 6,
    ExecutionModeOriginUpperLeft = 7,
    ExecutionModeOriginLowerLeft = 8,
    ExecutionModeEarlyFragmentTests = 9,
    ExecutionModePointMode = 10,
    ExecutionModeXfb = 11,
    ExecutionModeDepthReplacing = 12,
    ExecutionModeDepthGreater = 14,
    ExecutionModeDepthLess = 15,
    ExecutionModeDepthUnchanged = 16,
    ExecutionModeLocalSize = 17,
    ExecutionModeLocalSizeHint = 18,
    ExecutionModeInputPoints = 19,
    ExecutionModeInputLines = 20,
    ExecutionModeInputLinesAdjacency = 21,
    ExecutionModeTriangles = 22,
    ExecutionModeInputTrianglesAdjacency = 23,
    ExecutionModeQuads = 24,
    ExecutionModeIsolines = 25,
    ExecutionModeOutputVertices = 26,
    ExecutionModeOutputPoints = 27,
    ExecutionModeOutputLineStrip = 28,
    ExecutionModeOutputTriangleStrip = 29,
    ExecutionModeVecTypeHint = 30,
    ExecutionModeContractionOff = 31,
    ExecutionModeInitializer = 33,
    ExecutionModeFinalizer = 34,
    ExecutionModeSubgroupSize = 35,
    ExecutionModeSubgroupsPerWorkgroup = 36,
    ExecutionModeSubgroupsPerWorkgroupId = 37,
    ExecutionModeLocalSizeId = 38,
    ExecutionModeLocalSizeHintId = 39,
    ExecutionModeNonCoherentColorAttachmentReadEXT = 4169,
    ExecutionModeNonCoherentDepthAttachmentReadEXT = 4170,
    ExecutionModeNonCoherentStencilAttachmentReadEXT = 4171,
    ExecutionModeSubgroupUniformControlFlowKHR = 4421,
    ExecutionModePostDepthCoverage = 4446,
    ExecutionModeDenormPreserve = 4459,
    ExecutionModeDenormFlushToZero = 4460,
    ExecutionModeSignedZeroInfNanPreserve = 4461,
    ExecutionModeRoundingModeRTE = 4462,
    ExecutionModeRoundingModeRTZ = 4463,
    ExecutionModeEarlyAndLateFragmentTestsAMD = 5017,
    ExecutionModeStencilRefReplacingEXT = 5027,
    ExecutionModeCoalescingAMDX = 5069,
    ExecutionModeIsApiEntryAMDX = 5070,
    ExecutionModeMaxNodeRecursionAMDX = 5071,
    ExecutionModeStaticNumWorkgroupsAMDX = 5072,
    ExecutionModeShaderIndexAMDX = 5073,
    ExecutionModeMaxNumWorkgroupsAMDX = 5077,
    ExecutionModeStencilRefUnchangedFrontAMD = 5079,
    ExecutionModeStencilRefGreaterFrontAMD = 5080,
    ExecutionModeStencilRefLessFrontAMD = 5081,
    ExecutionModeStencilRefUnchangedBackAMD = 5082,
    ExecutionModeStencilRefGreaterBackAMD = 5083,
    ExecutionModeStencilRefLessBackAMD = 5084,
    ExecutionModeQuadDerivativesKHR = 5088,
    ExecutionModeRequireFullQuadsKHR = 5089,
    ExecutionModeSharesInputWithAMDX = 5102,
    ExecutionModeOutputLinesEXT = 5269,
    ExecutionModeOutputLinesNV = 5269,
    ExecutionModeOutputPrimitivesEXT = 5270,
    ExecutionModeOutputPrimitivesNV = 5270,
    ExecutionModeDerivativeGroupQuadsKHR = 5289,
    ExecutionModeDerivativeGroupQuadsNV = 5289,
    ExecutionModeDerivativeGroupLinearKHR = 5290,
    ExecutionModeDerivativeGroupLinearNV = 5290,
    ExecutionModeOutputTrianglesEXT = 5298,
    ExecutionModeOutputTrianglesNV = 5298,
    ExecutionModePixelInterlockOrderedEXT = 5366,
    ExecutionModePixelInterlockUnorderedEXT = 5367,
    ExecutionModeSampleInterlockOrderedEXT = 5368,
    ExecutionModeSampleInterlockUnorderedEXT = 5369,
    ExecutionModeShadingRateInterlockOrderedEXT = 5370,
    ExecutionModeShadingRateInterlockUnorderedEXT = 5371,
    ExecutionModeSharedLocalMemorySizeINTEL = 5618,
    ExecutionModeRoundingModeRTPINTEL = 5620,
    ExecutionModeRoundingModeRTNINTEL = 5621,
    ExecutionModeFloatingPointModeALTINTEL = 5622,
    ExecutionModeFloatingPointModeIEEEINTEL = 5623,
    ExecutionModeMaxWorkgroupSizeINTEL = 5893,
    ExecutionModeMaxWorkDimINTEL = 5894,
    ExecutionModeNoGlobalOffsetINTEL = 5895,
    ExecutionModeNumSIMDWorkitemsINTEL = 5896,
    ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
    ExecutionModeMaximallyReconvergesKHR = 6023,
    ExecutionModeFPFastMathDefault = 6028,
    ExecutionModeStreamingInterfaceINTEL = 6154,
    ExecutionModeRegisterMapInterfaceINTEL = 6160,
    ExecutionModeNamedBarrierCountINTEL = 6417,
    ExecutionModeMaximumRegistersINTEL = 6461,
    ExecutionModeMaximumRegistersIdINTEL = 6462,
    ExecutionModeNamedMaximumRegistersINTEL = 6463,
    ExecutionModeMax = 0x7fffffff,
};

enum StorageClass {
    StorageClassUniformConstant = 0,
    StorageClassInput = 1,
    StorageClassUniform = 2,
    StorageClassOutput = 3,
    StorageClassWorkgroup = 4,
    StorageClassCrossWorkgroup = 5,
    StorageClassPrivate = 6,
    StorageClassFunction = 7,
    StorageClassGeneric = 8,
    StorageClassPushConstant = 9,
    StorageClassAtomicCounter = 10,
    StorageClassImage = 11,
    StorageClassStorageBuffer = 12,
    StorageClassTileImageEXT = 4172,
    StorageClassNodePayloadAMDX = 5068,
    StorageClassCallableDataKHR = 5328,
    StorageClassCallableDataNV = 5328,
    StorageClassIncomingCallableDataKHR = 5329,
    StorageClassIncomingCallableDataNV = 5329,
    StorageClassRayPayloadKHR = 5338,
    StorageClassRayPayloadNV = 5338,
    StorageClassHitAttributeKHR = 5339,
    StorageClassHitAttributeNV = 5339,
    StorageClassIncomingRayPayloadKHR = 5342,
    StorageClassIncomingRayPayloadNV = 5342,
    StorageClassShaderRecordBufferKHR = 5343,
    StorageClassShaderRecordBufferNV = 5343,
    StorageClassPhysicalStorageBuffer = 5349,
    StorageClassPhysicalStorageBufferEXT = 5349,
    StorageClassHitObjectAttributeNV = 5385,
    StorageClassTaskPayloadWorkgroupEXT = 5402,
    StorageClassCodeSectionINTEL = 5605,
    StorageClassDeviceOnlyINTEL = 5936,
    StorageClassHostOnlyINTEL = 5937,
    StorageClassMax = 0x7fffffff,
};

enum Dim {
    Dim1D = 0,
    Dim2D = 1,
    Dim3D = 2,
    DimCube = 3,
    DimRect = 4,
    DimBuffer = 5,
    DimSubpassData = 6,
    DimTileImageDataEXT = 4173,
    DimMax = 0x7fffffff,
};

enum SamplerAddressingMode {
    SamplerAddressingModeNone = 0,
    SamplerAddressingModeClampToEdge = 1,
    SamplerAddressingModeClamp = 2,
    SamplerAddressingModeRepeat = 3,
    SamplerAddressingModeRepeatMirrored = 4,
    SamplerAddressingModeMax = 0x7fffffff,
};

enum SamplerFilterMode {
    SamplerFilterModeNearest = 0,
    SamplerFilterModeLinear = 1,
    SamplerFilterModeMax = 0x7fffffff,
};

enum ImageFormat {
    ImageFormatUnknown = 0,
    ImageFormatRgba32f = 1,
    ImageFormatRgba16f = 2,
    ImageFormatR32f = 3,
    ImageFormatRgba8 = 4,
    ImageFormatRgba8Snorm = 5,
    ImageFormatRg32f = 6,
    ImageFormatRg16f = 7,
    ImageFormatR11fG11fB10f = 8,
    ImageFormatR16f = 9,
    ImageFormatRgba16 = 10,
    ImageFormatRgb10A2 = 11,
    ImageFormatRg16 = 12,
    ImageFormatRg8 = 13,
    ImageFormatR16 = 14,
    ImageFormatR8 = 15,
    ImageFormatRgba16Snorm = 16,
    ImageFormatRg16Snorm = 17,
    ImageFormatRg8Snorm = 18,
    ImageFormatR16Snorm = 19,
    ImageFormatR8Snorm = 20,
    ImageFormatRgba32i = 21,
    ImageFormatRgba16i = 22,
    ImageFormatRgba8i = 23,
    ImageFormatR32i = 24,
    ImageFormatRg32i = 25,
    ImageFormatRg16i = 26,
    ImageFormatRg8i = 27,
    ImageFormatR16i = 28,
    ImageFormatR8i = 29,
    ImageFormatRgba32ui = 30,
    ImageFormatRgba16ui = 31,
    ImageFormatRgba8ui = 32,
    ImageFormatR32ui = 33,
    ImageFormatRgb10a2ui = 34,
    ImageFormatRg32ui = 35,
    ImageFormatRg16ui = 36,
    ImageFormatRg8ui = 37,
    ImageFormatR16ui = 38,
    ImageFormatR8ui = 39,
    ImageFormatR64ui = 40,
    ImageFormatR64i = 41,
    ImageFormatMax = 0x7fffffff,
};

enum ImageChannelOrder {
    ImageChannelOrderR = 0,
    ImageChannelOrderA = 1,
    ImageChannelOrderRG = 2,
    ImageChannelOrderRA = 3,
    ImageChannelOrderRGB = 4,
    ImageChannelOrderRGBA = 5,
    ImageChannelOrderBGRA = 6,
    ImageChannelOrderARGB = 7,
    ImageChannelOrderIntensity = 8,
    ImageChannelOrderLuminance = 9,
    ImageChannelOrderRx = 10,
    ImageChannelOrderRGx = 11,
    ImageChannelOrderRGBx = 12,
    ImageChannelOrderDepth = 13,
    ImageChannelOrderDepthStencil = 14,
    ImageChannelOrdersRGB = 15,
    ImageChannelOrdersRGBx = 16,
    ImageChannelOrdersRGBA = 17,
    ImageChannelOrdersBGRA = 18,
    ImageChannelOrderABGR = 19,
    ImageChannelOrderMax = 0x7fffffff,
};

enum ImageChannelDataType {
    ImageChannelDataTypeSnormInt8 = 0,
    ImageChannelDataTypeSnormInt16 = 1,
    ImageChannelDataTypeUnormInt8 = 2,
    ImageChannelDataTypeUnormInt16 = 3,
    ImageChannelDataTypeUnormShort565 = 4,
    ImageChannelDataTypeUnormShort555 = 5,
    ImageChannelDataTypeUnormInt101010 = 6,
    ImageChannelDataTypeSignedInt8 = 7,
    ImageChannelDataTypeSignedInt16 = 8,
    ImageChannelDataTypeSignedInt32 = 9,
    ImageChannelDataTypeUnsignedInt8 = 10,
    ImageChannelDataTypeUnsignedInt16 = 11,
    ImageChannelDataTypeUnsignedInt32 = 12,
    ImageChannelDataTypeHalfFloat = 13,
    ImageChannelDataTypeFloat = 14,
    ImageChannelDataTypeUnormInt24 = 15,
    ImageChannelDataTypeUnormInt101010_2 = 16,
    ImageChannelDataTypeUnsignedIntRaw10EXT = 19,
    ImageChannelDataTypeUnsignedIntRaw12EXT = 20,
    ImageChannelDataTypeUnormInt2_101010EXT = 21,
    ImageChannelDataTypeMax = 0x7fffffff,
};

enum ImageOperandsShift {
    ImageOperandsBiasShift = 0,
    ImageOperandsLodShift = 1,
    ImageOperandsGradShift = 2,
    ImageOperandsConstOffsetShift = 3,
    ImageOperandsOffsetShift = 4,
    ImageOperandsConstOffsetsShift = 5,
    ImageOperandsSampleShift = 6,
    ImageOperandsMinLodShift = 7,
    ImageOperandsMakeTexelAvailableShift = 8,
    ImageOperandsMakeTexelAvailableKHRShift = 8,
    ImageOperandsMakeTexelVisibleShift = 9,
    ImageOperandsMakeTexelVisibleKHRShift = 9,
    ImageOperandsNonPrivateTexelShift = 10,
    ImageOperandsNonPrivateTexelKHRShift = 10,
    ImageOperandsVolatileTexelShift = 11,
    ImageOperandsVolatileTexelKHRShift = 11,
    ImageOperandsSignExtendShift = 12,
    ImageOperandsZeroExtendShift = 13,
    ImageOperandsNontemporalShift = 14,
    ImageOperandsOffsetsShift = 16,
    ImageOperandsMax = 0x7fffffff,
};

enum ImageOperandsMask {
    ImageOperandsMaskNone = 0,
    ImageOperandsBiasMask = 0x00000001,
    ImageOperandsLodMask = 0x00000002,
    ImageOperandsGradMask = 0x00000004,
    ImageOperandsConstOffsetMask = 0x00000008,
    ImageOperandsOffsetMask = 0x00000010,
    ImageOperandsConstOffsetsMask = 0x00000020,
    ImageOperandsSampleMask = 0x00000040,
    ImageOperandsMinLodMask = 0x00000080,
    ImageOperandsMakeTexelAvailableMask = 0x00000100,
    ImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
    ImageOperandsMakeTexelVisibleMask = 0x00000200,
    ImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
    ImageOperandsNonPrivateTexelMask = 0x00000400,
    ImageOperandsNonPrivateTexelKHRMask = 0x00000400,
    ImageOperandsVolatileTexelMask = 0x00000800,
    ImageOperandsVolatileTexelKHRMask = 0x00000800,
    ImageOperandsSignExtendMask = 0x00001000,
    ImageOperandsZeroExtendMask = 0x00002000,
    ImageOperandsNontemporalMask = 0x00004000,
    ImageOperandsOffsetsMask = 0x00010000,
};

enum FPFastMathModeShift {
    FPFastMathModeNotNaNShift = 0,
    FPFastMathModeNotInfShift = 1,
    FPFastMathModeNSZShift = 2,
    FPFastMathModeAllowRecipShift = 3,
    FPFastMathModeFastShift = 4,
    FPFastMathModeAllowContractShift = 16,
    FPFastMathModeAllowContractFastINTELShift = 16,
    FPFastMathModeAllowReassocShift = 17,
    FPFastMathModeAllowReassocINTELShift = 17,
    FPFastMathModeAllowTransformShift = 18,
    FPFastMathModeMax = 0x7fffffff,
};

enum FPFastMathModeMask {
    FPFastMathModeMaskNone = 0,
    FPFastMathModeNotNaNMask = 0x00000001,
    FPFastMathModeNotInfMask = 0x00000002,
    FPFastMathModeNSZMask = 0x00000004,
    FPFastMathModeAllowRecipMask = 0x00000008,
    FPFastMathModeFastMask = 0x00000010,
    FPFastMathModeAllowContractMask = 0x00010000,
    FPFastMathModeAllowContractFastINTELMask = 0x00010000,
    FPFastMathModeAllowReassocMask = 0x00020000,
    FPFastMathModeAllowReassocINTELMask = 0x00020000,
    FPFastMathModeAllowTransformMask = 0x00040000,
};

enum FPRoundingMode {
    FPRoundingModeRTE = 0,
    FPRoundingModeRTZ = 1,
    FPRoundingModeRTP = 2,
    FPRoundingModeRTN = 3,
    FPRoundingModeMax = 0x7fffffff,
};

enum LinkageType {
    LinkageTypeExport = 0,
    LinkageTypeImport = 1,
    LinkageTypeLinkOnceODR = 2,
    LinkageTypeMax = 0x7fffffff,
};

enum AccessQualifier {
    AccessQualifierReadOnly = 0,
    AccessQualifierWriteOnly = 1,
    AccessQualifierReadWrite = 2,
    AccessQualifierMax = 0x7fffffff,
};

enum FunctionParameterAttribute {
    FunctionParameterAttributeZext = 0,
    FunctionParameterAttributeSext = 1,
    FunctionParameterAttributeByVal = 2,
    FunctionParameterAttributeSret = 3,
    FunctionParameterAttributeNoAlias = 4,
    FunctionParameterAttributeNoCapture = 5,
    FunctionParameterAttributeNoWrite = 6,
    FunctionParameterAttributeNoReadWrite = 7,
    FunctionParameterAttributeRuntimeAlignedINTEL = 5940,
    FunctionParameterAttributeMax = 0x7fffffff,
};

enum Decoration {
    DecorationRelaxedPrecision = 0,
    DecorationSpecId = 1,
    DecorationBlock = 2,
    DecorationBufferBlock = 3,
    DecorationRowMajor = 4,
    DecorationColMajor = 5,
    DecorationArrayStride = 6,
    DecorationMatrixStride = 7,
    DecorationGLSLShared = 8,
    DecorationGLSLPacked = 9,
    DecorationCPacked = 10,
    DecorationBuiltIn = 11,
    DecorationNoPerspective = 13,
    DecorationFlat = 14,
    DecorationPatch = 15,
    DecorationCentroid = 16,
    DecorationSample = 17,
    DecorationInvariant = 18,
    DecorationRestrict = 19,
    DecorationAliased = 20,
    DecorationVolatile = 21,
    DecorationConstant = 22,
    DecorationCoherent = 23,
    DecorationNonWritable = 24,
    DecorationNonReadable = 25,
    DecorationUniform = 26,
    DecorationUniformId = 27,
    DecorationSaturatedConversion = 28,
    DecorationStream = 29,
    DecorationLocation = 30,
    DecorationComponent = 31,
    DecorationIndex = 32,
    DecorationBinding = 33,
    DecorationDescriptorSet = 34,
    DecorationOffset = 35,
    DecorationXfbBuffer = 36,
    DecorationXfbStride = 37,
    DecorationFuncParamAttr = 38,
    DecorationFPRoundingMode = 39,
    DecorationFPFastMathMode = 40,
    DecorationLinkageAttributes = 41,
    DecorationNoContraction = 42,
    DecorationInputAttachmentIndex = 43,
    DecorationAlignment = 44,
    DecorationMaxByteOffset = 45,
    DecorationAlignmentId = 46,
    DecorationMaxByteOffsetId = 47,
    DecorationNoSignedWrap = 4469,
    DecorationNoUnsignedWrap = 4470,
    DecorationWeightTextureQCOM = 4487,
    DecorationBlockMatchTextureQCOM = 4488,
    DecorationBlockMatchSamplerQCOM = 4499,
    DecorationExplicitInterpAMD = 4999,
    DecorationNodeSharesPayloadLimitsWithAMDX = 5019,
    DecorationNodeMaxPayloadsAMDX = 5020,
    DecorationTrackFinishWritingAMDX = 5078,
    DecorationPayloadNodeNameAMDX = 5091,
    DecorationPayloadNodeBaseIndexAMDX = 5098,
    DecorationPayloadNodeSparseArrayAMDX = 5099,
    DecorationPayloadNodeArraySizeAMDX = 5100,
    DecorationPayloadDispatchIndirectAMDX = 5105,
    DecorationOverrideCoverageNV = 5248,
    DecorationPassthroughNV = 5250,
    DecorationViewportRelativeNV = 5252,
    DecorationSecondaryViewportRelativeNV = 5256,
    DecorationPerPrimitiveEXT = 5271,
    DecorationPerPrimitiveNV = 5271,
    DecorationPerViewNV = 5272,
    DecorationPerTaskNV = 5273,
    DecorationPerVertexKHR = 5285,
    DecorationPerVertexNV = 5285,
    DecorationNonUniform = 5300,
    DecorationNonUniformEXT = 5300,
    DecorationRestrictPointer = 5355,
    DecorationRestrictPointerEXT = 5355,
    DecorationAliasedPointer = 5356,
    DecorationAliasedPointerEXT = 5356,
    DecorationHitObjectShaderRecordBufferNV = 5386,
    DecorationBindlessSamplerNV = 5398,
    DecorationBindlessImageNV = 5399,
    DecorationBoundSamplerNV = 5400,
    DecorationBoundImageNV = 5401,
    DecorationSIMTCallINTEL = 5599,
    DecorationReferencedIndirectlyINTEL = 5602,
    DecorationClobberINTEL = 5607,
    DecorationSideEffectsINTEL = 5608,
    DecorationVectorComputeVariableINTEL = 5624,
    DecorationFuncParamIOKindINTEL = 5625,
    DecorationVectorComputeFunctionINTEL = 5626,
    DecorationStackCallINTEL = 5627,
    DecorationGlobalVariableOffsetINTEL = 5628,
    DecorationCounterBuffer = 5634,
    DecorationHlslCounterBufferGOOGLE = 5634,
    DecorationHlslSemanticGOOGLE = 5635,
    DecorationUserSemantic = 5635,
    DecorationUserTypeGOOGLE = 5636,
    DecorationFunctionRoundingModeINTEL = 5822,
    DecorationFunctionDenormModeINTEL = 5823,
    DecorationRegisterINTEL = 5825,
    DecorationMemoryINTEL = 5826,
    DecorationNumbanksINTEL = 5827,
    DecorationBankwidthINTEL = 5828,
    DecorationMaxPrivateCopiesINTEL = 5829,
    DecorationSinglepumpINTEL = 5830,
    DecorationDoublepumpINTEL = 5831,
    DecorationMaxReplicatesINTEL = 5832,
    DecorationSimpleDualPortINTEL = 5833,
    DecorationMergeINTEL = 5834,
    DecorationBankBitsINTEL = 5835,
    DecorationForcePow2DepthINTEL = 5836,
    DecorationStridesizeINTEL = 5883,
    DecorationWordsizeINTEL = 5884,
    DecorationTrueDualPortINTEL = 5885,
    DecorationBurstCoalesceINTEL = 5899,
    DecorationCacheSizeINTEL = 5900,
    DecorationDontStaticallyCoalesceINTEL = 5901,
    DecorationPrefetchINTEL = 5902,
    DecorationStallEnableINTEL = 5905,
    DecorationFuseLoopsInFunctionINTEL = 5907,
    DecorationMathOpDSPModeINTEL = 5909,
    DecorationAliasScopeINTEL = 5914,
    DecorationNoAliasINTEL = 5915,
    DecorationInitiationIntervalINTEL = 5917,
    DecorationMaxConcurrencyINTEL = 5918,
    DecorationPipelineEnableINTEL = 5919,
    DecorationBufferLocationINTEL = 5921,
    DecorationIOPipeStorageINTEL = 5944,
    DecorationFunctionFloatingPointModeINTEL = 6080,
    DecorationSingleElementVectorINTEL = 6085,
    DecorationVectorComputeCallableFunctionINTEL = 6087,
    DecorationMediaBlockIOINTEL = 6140,
    DecorationStallFreeINTEL = 6151,
    DecorationFPMaxErrorDecorationINTEL = 6170,
    DecorationLatencyControlLabelINTEL = 6172,
    DecorationLatencyControlConstraintINTEL = 6173,
    DecorationConduitKernelArgumentINTEL = 6175,
    DecorationRegisterMapKernelArgumentINTEL = 6176,
    DecorationMMHostInterfaceAddressWidthINTEL = 6177,
    DecorationMMHostInterfaceDataWidthINTEL = 6178,
    DecorationMMHostInterfaceLatencyINTEL = 6179,
    DecorationMMHostInterfaceReadWriteModeINTEL = 6180,
    DecorationMMHostInterfaceMaxBurstINTEL = 6181,
    DecorationMMHostInterfaceWaitRequestINTEL = 6182,
    DecorationStableKernelArgumentINTEL = 6183,
    DecorationHostAccessINTEL = 6188,
    DecorationInitModeINTEL = 6190,
    DecorationImplementInRegisterMapINTEL = 6191,
    DecorationCacheControlLoadINTEL = 6442,
    DecorationCacheControlStoreINTEL = 6443,
    DecorationMax = 0x7fffffff,
};

enum BuiltIn {
    BuiltInPosition = 0,
    BuiltInPointSize = 1,
    BuiltInClipDistance = 3,
    BuiltInCullDistance = 4,
    BuiltInVertexId = 5,
    BuiltInInstanceId = 6,
    BuiltInPrimitiveId = 7,
    BuiltInInvocationId = 8,
    BuiltInLayer = 9,
    BuiltInViewportIndex = 10,
    BuiltInTessLevelOuter = 11,
    BuiltInTessLevelInner = 12,
    BuiltInTessCoord = 13,
    BuiltInPatchVertices = 14,
    BuiltInFragCoord = 15,
    BuiltInPointCoord = 16,
    BuiltInFrontFacing = 17,
    BuiltInSampleId = 18,
    BuiltInSamplePosition = 19,
    BuiltInSampleMask = 20,
    BuiltInFragDepth = 22,
    BuiltInHelperInvocation = 23,
    BuiltInNumWorkgroups = 24,
    BuiltInWorkgroupSize = 25,
    BuiltInWorkgroupId = 26,
    BuiltInLocalInvocationId = 27,
    BuiltInGlobalInvocationId = 28,
    BuiltInLocalInvocationIndex = 29,
    BuiltInWorkDim = 30,
    BuiltInGlobalSize = 31,
    BuiltInEnqueuedWorkgroupSize = 32,
    BuiltInGlobalOffset = 33,
    BuiltInGlobalLinearId = 34,
    BuiltInSubgroupSize = 36,
    BuiltInSubgroupMaxSize = 37,
    BuiltInNumSubgroups = 38,
    BuiltInNumEnqueuedSubgroups = 39,
    BuiltInSubgroupId = 40,
    BuiltInSubgroupLocalInvocationId = 41,
    BuiltInVertexIndex = 42,
    BuiltInInstanceIndex = 43,
    BuiltInCoreIDARM = 4160,
    BuiltInCoreCountARM = 4161,
    BuiltInCoreMaxIDARM = 4162,
    BuiltInWarpIDARM = 4163,
    BuiltInWarpMaxIDARM = 4164,
    BuiltInSubgroupEqMask = 4416,
    BuiltInSubgroupEqMaskKHR = 4416,
    BuiltInSubgroupGeMask = 4417,
    BuiltInSubgroupGeMaskKHR = 4417,
    BuiltInSubgroupGtMask = 4418,
    BuiltInSubgroupGtMaskKHR = 4418,
    BuiltInSubgroupLeMask = 4419,
    BuiltInSubgroupLeMaskKHR = 4419,
    BuiltInSubgroupLtMask = 4420,
    BuiltInSubgroupLtMaskKHR = 4420,
    BuiltInBaseVertex = 4424,
    BuiltInBaseInstance = 4425,
    BuiltInDrawIndex = 4426,
    BuiltInPrimitiveShadingRateKHR = 4432,
    BuiltInDeviceIndex = 4438,
    BuiltInViewIndex = 4440,
    BuiltInShadingRateKHR = 4444,
    BuiltInBaryCoordNoPerspAMD = 4992,
    BuiltInBaryCoordNoPerspCentroidAMD = 4993,
    BuiltInBaryCoordNoPerspSampleAMD = 4994,
    BuiltInBaryCoordSmoothAMD = 4995,
    BuiltInBaryCoordSmoothCentroidAMD = 4996,
    BuiltInBaryCoordSmoothSampleAMD = 4997,
    BuiltInBaryCoordPullModelAMD = 4998,
    BuiltInFragStencilRefEXT = 5014,
    BuiltInRemainingRecursionLevelsAMDX = 5021,
    BuiltInShaderIndexAMDX = 5073,
    BuiltInViewportMaskNV = 5253,
    BuiltInSecondaryPositionNV = 5257,
    BuiltInSecondaryViewportMaskNV = 5258,
    BuiltInPositionPerViewNV = 5261,
    BuiltInViewportMaskPerViewNV = 5262,
    BuiltInFullyCoveredEXT = 5264,
    BuiltInTaskCountNV = 5274,
    BuiltInPrimitiveCountNV = 5275,
    BuiltInPrimitiveIndicesNV = 5276,
    BuiltInClipDistancePerViewNV = 5277,
    BuiltInCullDistancePerViewNV = 5278,
    BuiltInLayerPerViewNV = 5279,
    BuiltInMeshViewCountNV = 5280,
    BuiltInMeshViewIndicesNV = 5281,
    BuiltInBaryCoordKHR = 5286,
    BuiltInBaryCoordNV = 5286,
    BuiltInBaryCoordNoPerspKHR = 5287,
    BuiltInBaryCoordNoPerspNV = 5287,
    BuiltInFragSizeEXT = 5292,
    BuiltInFragmentSizeNV = 5292,
    BuiltInFragInvocationCountEXT = 5293,
    BuiltInInvocationsPerPixelNV = 5293,
    BuiltInPrimitivePointIndicesEXT = 5294,
    BuiltInPrimitiveLineIndicesEXT = 5295,
    BuiltInPrimitiveTriangleIndicesEXT = 5296,
    BuiltInCullPrimitiveEXT = 5299,
    BuiltInLaunchIdKHR = 5319,
    BuiltInLaunchIdNV = 5319,
    BuiltInLaunchSizeKHR = 5320,
    BuiltInLaunchSizeNV = 5320,
    BuiltInWorldRayOriginKHR = 5321,
    BuiltInWorldRayOriginNV = 5321,
    BuiltInWorldRayDirectionKHR = 5322,
    BuiltInWorldRayDirectionNV = 5322,
    BuiltInObjectRayOriginKHR = 5323,
    BuiltInObjectRayOriginNV = 5323,
    BuiltInObjectRayDirectionKHR = 5324,
    BuiltInObjectRayDirectionNV = 5324,
    BuiltInRayTminKHR = 5325,
    BuiltInRayTminNV = 5325,
    BuiltInRayTmaxKHR = 5326,
    BuiltInRayTmaxNV = 5326,
    BuiltInInstanceCustomIndexKHR = 5327,
    BuiltInInstanceCustomIndexNV = 5327,
    BuiltInObjectToWorldKHR = 5330,
    BuiltInObjectToWorldNV = 5330,
    BuiltInWorldToObjectKHR = 5331,
    BuiltInWorldToObjectNV = 5331,
    BuiltInHitTNV = 5332,
    BuiltInHitKindKHR = 5333,
    BuiltInHitKindNV = 5333,
    BuiltInCurrentRayTimeNV = 5334,
    BuiltInHitTriangleVertexPositionsKHR = 5335,
    BuiltInHitMicroTriangleVertexPositionsNV = 5337,
    BuiltInHitMicroTriangleVertexBarycentricsNV = 5344,
    BuiltInIncomingRayFlagsKHR = 5351,
    BuiltInIncomingRayFlagsNV = 5351,
    BuiltInRayGeometryIndexKHR = 5352,
    BuiltInHitIsSphereNV = 5359,
    BuiltInHitIsLSSNV = 5360,
    BuiltInHitSpherePositionNV = 5361,
    BuiltInWarpsPerSMNV = 5374,
    BuiltInSMCountNV = 5375,
    BuiltInWarpIDNV = 5376,
    BuiltInSMIDNV = 5377,
    BuiltInHitLSSPositionsNV = 5396,
    BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
    BuiltInHitKindBackFacingMicroTriangleNV = 5406,
    BuiltInHitSphereRadiusNV = 5420,
    BuiltInHitLSSRadiiNV = 5421,
    BuiltInClusterIDNV = 5436,
    BuiltInCullMaskKHR = 6021,
    BuiltInMax = 0x7fffffff,
};

enum SelectionControlShift {
    SelectionControlFlattenShift = 0,
    SelectionControlDontFlattenShift = 1,
    SelectionControlMax = 0x7fffffff,
};

enum SelectionControlMask {
    SelectionControlMaskNone = 0,
    SelectionControlFlattenMask = 0x00000001,
    SelectionControlDontFlattenMask = 0x00000002,
};

enum LoopControlShift {
    LoopControlUnrollShift = 0,
    LoopControlDontUnrollShift = 1,
    LoopControlDependencyInfiniteShift = 2,
    LoopControlDependencyLengthShift = 3,
    LoopControlMinIterationsShift = 4,
    LoopControlMaxIterationsShift = 5,
    LoopControlIterationMultipleShift = 6,
    LoopControlPeelCountShift = 7,
    LoopControlPartialCountShift = 8,
    LoopControlInitiationIntervalINTELShift = 16,
    LoopControlMaxConcurrencyINTELShift = 17,
    LoopControlDependencyArrayINTELShift = 18,
    LoopControlPipelineEnableINTELShift = 19,
    LoopControlLoopCoalesceINTELShift = 20,
    LoopControlMaxInterleavingINTELShift = 21,
    LoopControlSpeculatedIterationsINTELShift = 22,
    LoopControlNoFusionINTELShift = 23,
    LoopControlLoopCountINTELShift = 24,
    LoopControlMaxReinvocationDelayINTELShift = 25,
    LoopControlMax = 0x7fffffff,
};

enum LoopControlMask {
    LoopControlMaskNone = 0,
    LoopControlUnrollMask = 0x00000001,
    LoopControlDontUnrollMask = 0x00000002,
    LoopControlDependencyInfiniteMask = 0x00000004,
    LoopControlDependencyLengthMask = 0x00000008,
    LoopControlMinIterationsMask = 0x00000010,
    LoopControlMaxIterationsMask = 0x00000020,
    LoopControlIterationMultipleMask = 0x00000040,
    LoopControlPeelCountMask = 0x00000080,
    LoopControlPartialCountMask = 0x00000100,
    LoopControlInitiationIntervalINTELMask = 0x00010000,
    LoopControlMaxConcurrencyINTELMask = 0x00020000,
    LoopControlDependencyArrayINTELMask = 0x00040000,
    LoopControlPipelineEnableINTELMask = 0x00080000,
    LoopControlLoopCoalesceINTELMask = 0x00100000,
    LoopControlMaxInterleavingINTELMask = 0x00200000,
    LoopControlSpeculatedIterationsINTELMask = 0x00400000,
    LoopControlNoFusionINTELMask = 0x00800000,
    LoopControlLoopCountINTELMask = 0x01000000,
    LoopControlMaxReinvocationDelayINTELMask = 0x02000000,
};

enum FunctionControlShift {
    FunctionControlInlineShift = 0,
    FunctionControlDontInlineShift = 1,
    FunctionControlPureShift = 2,
    FunctionControlConstShift = 3,
    FunctionControlOptNoneEXTShift = 16,
    FunctionControlOptNoneINTELShift = 16,
    FunctionControlMax = 0x7fffffff,
};

enum FunctionControlMask {
    FunctionControlMaskNone = 0,
    FunctionControlInlineMask = 0x00000001,
    FunctionControlDontInlineMask = 0x00000002,
    FunctionControlPureMask = 0x00000004,
    FunctionControlConstMask = 0x00000008,
    FunctionControlOptNoneEXTMask = 0x00010000,
    FunctionControlOptNoneINTELMask = 0x00010000,
};

enum MemorySemanticsShift {
    MemorySemanticsAcquireShift = 1,
    MemorySemanticsReleaseShift = 2,
    MemorySemanticsAcquireReleaseShift = 3,
    MemorySemanticsSequentiallyConsistentShift = 4,
    MemorySemanticsUniformMemoryShift = 6,
    MemorySemanticsSubgroupMemoryShift = 7,
    MemorySemanticsWorkgroupMemoryShift = 8,
    MemorySemanticsCrossWorkgroupMemoryShift = 9,
    MemorySemanticsAtomicCounterMemoryShift = 10,
    MemorySemanticsImageMemoryShift = 11,
    MemorySemanticsOutputMemoryShift = 12,
    MemorySemanticsOutputMemoryKHRShift = 12,
    MemorySemanticsMakeAvailableShift = 13,
    MemorySemanticsMakeAvailableKHRShift = 13,
    MemorySemanticsMakeVisibleShift = 14,
    MemorySemanticsMakeVisibleKHRShift = 14,
    MemorySemanticsVolatileShift = 15,
    MemorySemanticsMax = 0x7fffffff,
};

enum MemorySemanticsMask {
    MemorySemanticsMaskNone = 0,
    MemorySemanticsAcquireMask = 0x00000002,
    MemorySemanticsReleaseMask = 0x00000004,
    MemorySemanticsAcquireReleaseMask = 0x00000008,
    MemorySemanticsSequentiallyConsistentMask = 0x00000010,
    MemorySemanticsUniformMemoryMask = 0x00000040,
    MemorySemanticsSubgroupMemoryMask = 0x00000080,
    MemorySemanticsWorkgroupMemoryMask = 0x00000100,
    MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
    MemorySemanticsAtomicCounterMemoryMask = 0x00000400,
    MemorySemanticsImageMemoryMask = 0x00000800,
    MemorySemanticsOutputMemoryMask = 0x00001000,
    MemorySemanticsOutputMemoryKHRMask = 0x00001000,
    MemorySemanticsMakeAvailableMask = 0x00002000,
    MemorySemanticsMakeAvailableKHRMask = 0x00002000,
    MemorySemanticsMakeVisibleMask = 0x00004000,
    MemorySemanticsMakeVisibleKHRMask = 0x00004000,
    MemorySemanticsVolatileMask = 0x00008000,
};

enum MemoryAccessShift {
    MemoryAccessVolatileShift = 0,
    MemoryAccessAlignedShift = 1,
    MemoryAccessNontemporalShift = 2,
    MemoryAccessMakePointerAvailableShift = 3,
    MemoryAccessMakePointerAvailableKHRShift = 3,
    MemoryAccessMakePointerVisibleShift = 4,
    MemoryAccessMakePointerVisibleKHRShift = 4,
    MemoryAccessNonPrivatePointerShift = 5,
    MemoryAccessNonPrivatePointerKHRShift = 5,
    MemoryAccessAliasScopeINTELMaskShift = 16,
    MemoryAccessNoAliasINTELMaskShift = 17,
    MemoryAccessMax = 0x7fffffff,
};

enum MemoryAccessMask {
    MemoryAccessMaskNone = 0,
    MemoryAccessVolatileMask = 0x00000001,
    MemoryAccessAlignedMask = 0x00000002,
    MemoryAccessNontemporalMask = 0x00000004,
    MemoryAccessMakePointerAvailableMask = 0x00000008,
    MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
    MemoryAccessMakePointerVisibleMask = 0x00000010,
    MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
    MemoryAccessNonPrivatePointerMask = 0x00000020,
    MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
    MemoryAccessAliasScopeINTELMaskMask = 0x00010000,
    MemoryAccessNoAliasINTELMaskMask = 0x00020000,
};

enum Scope {
    ScopeCrossDevice = 0,
    ScopeDevice = 1,
    ScopeWorkgroup = 2,
    ScopeSubgroup = 3,
    ScopeInvocation = 4,
    ScopeQueueFamily = 5,
    ScopeQueueFamilyKHR = 5,
    ScopeShaderCallKHR = 6,
    ScopeMax = 0x7fffffff,
};

enum GroupOperation {
    GroupOperationReduce = 0,
    GroupOperationInclusiveScan = 1,
    GroupOperationExclusiveScan = 2,
    GroupOperationClusteredReduce = 3,
    GroupOperationPartitionedReduceNV = 6,
    GroupOperationPartitionedInclusiveScanNV = 7,
    GroupOperationPartitionedExclusiveScanNV = 8,
    GroupOperationMax = 0x7fffffff,
};

enum KernelEnqueueFlags {
    KernelEnqueueFlagsNoWait = 0,
    KernelEnqueueFlagsWaitKernel = 1,
    KernelEnqueueFlagsWaitWorkGroup = 2,
    KernelEnqueueFlagsMax = 0x7fffffff,
};

enum KernelProfilingInfoShift {
    KernelProfilingInfoCmdExecTimeShift = 0,
    KernelProfilingInfoMax = 0x7fffffff,
};

enum KernelProfilingInfoMask {
    KernelProfilingInfoMaskNone = 0,
    KernelProfilingInfoCmdExecTimeMask = 0x00000001,
};

enum Capability {
    CapabilityMatrix = 0,
    CapabilityShader = 1,
    CapabilityGeometry = 2,
    CapabilityTessellation = 3,
    CapabilityAddresses = 4,
    CapabilityLinkage = 5,
    CapabilityKernel = 6,
    CapabilityVector16 = 7,
    CapabilityFloat16Buffer = 8,
    CapabilityFloat16 = 9,
    CapabilityFloat64 = 10,
    CapabilityInt64 = 11,
    CapabilityInt64Atomics = 12,
    CapabilityImageBasic = 13,
    CapabilityImageReadWrite = 14,
    CapabilityImageMipmap = 15,
    CapabilityPipes = 17,
    CapabilityGroups = 18,
    CapabilityDeviceEnqueue = 19,
    CapabilityLiteralSampler = 20,
    CapabilityAtomicStorage = 21,
    CapabilityInt16 = 22,
    CapabilityTessellationPointSize = 23,
    CapabilityGeometryPointSize = 24,
    CapabilityImageGatherExtended = 25,
    CapabilityStorageImageMultisample = 27,
    CapabilityUniformBufferArrayDynamicIndexing = 28,
    CapabilitySampledImageArrayDynamicIndexing = 29,
    CapabilityStorageBufferArrayDynamicIndexing = 30,
    CapabilityStorageImageArrayDynamicIndexing = 31,
    CapabilityClipDistance = 32,
    CapabilityCullDistance = 33,
    CapabilityImageCubeArray = 34,
    CapabilitySampleRateShading = 35,
    CapabilityImageRect = 36,
    CapabilitySampledRect = 37,
    CapabilityGenericPointer = 38,
    CapabilityInt8 = 39,
    CapabilityInputAttachment = 40,
    CapabilitySparseResidency = 41,
    CapabilityMinLod = 42,
    CapabilitySampled1D = 43,
    CapabilityImage1D = 44,
    CapabilitySampledCubeArray = 45,
    CapabilitySampledBuffer = 46,
    CapabilityImageBuffer = 47,
    CapabilityImageMSArray = 48,
    CapabilityStorageImageExtendedFormats = 49,
    CapabilityImageQuery = 50,
    CapabilityDerivativeControl = 51,
    CapabilityInterpolationFunction = 52,
    CapabilityTransformFeedback = 53,
    CapabilityGeometryStreams = 54,
    CapabilityStorageImageReadWithoutFormat = 55,
    CapabilityStorageImageWriteWithoutFormat = 56,
    CapabilityMultiViewport = 57,
    CapabilitySubgroupDispatch = 58,
    CapabilityNamedBarrier = 59,
    CapabilityPipeStorage = 60,
    CapabilityGroupNonUniform = 61,
    CapabilityGroupNonUniformVote = 62,
    CapabilityGroupNonUniformArithmetic = 63,
    CapabilityGroupNonUniformBallot = 64,
    CapabilityGroupNonUniformShuffle = 65,
    CapabilityGroupNonUniformShuffleRelative = 66,
    CapabilityGroupNonUniformClustered = 67,
    CapabilityGroupNonUniformQuad = 68,
    CapabilityShaderLayer = 69,
    CapabilityShaderViewportIndex = 70,
    CapabilityUniformDecoration = 71,
    CapabilityCoreBuiltinsARM = 4165,
    CapabilityTileImageColorReadAccessEXT = 4166,
    CapabilityTileImageDepthReadAccessEXT = 4167,
    CapabilityTileImageStencilReadAccessEXT = 4168,
    CapabilityCooperativeMatrixLayoutsARM = 4201,
    CapabilityFragmentShadingRateKHR = 4422,
    CapabilitySubgroupBallotKHR = 4423,
    CapabilityDrawParameters = 4427,
    CapabilityWorkgroupMemoryExplicitLayoutKHR = 4428,
    CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
    CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
    CapabilitySubgroupVoteKHR = 4431,
    CapabilityStorageBuffer16BitAccess = 4433,
    CapabilityStorageUniformBufferBlock16 = 4433,
    CapabilityStorageUniform16 = 4434,
    CapabilityUniformAndStorageBuffer16BitAccess = 4434,
    CapabilityStoragePushConstant16 = 4435,
    CapabilityStorageInputOutput16 = 4436,
    CapabilityDeviceGroup = 4437,
    CapabilityMultiView = 4439,
    CapabilityVariablePointersStorageBuffer = 4441,
    CapabilityVariablePointers = 4442,
    CapabilityAtomicStorageOps = 4445,
    CapabilitySampleMaskPostDepthCoverage = 4447,
    CapabilityStorageBuffer8BitAccess = 4448,
    CapabilityUniformAndStorageBuffer8BitAccess = 4449,
    CapabilityStoragePushConstant8 = 4450,
    CapabilityDenormPreserve = 4464,
    CapabilityDenormFlushToZero = 4465,
    CapabilitySignedZeroInfNanPreserve = 4466,
    CapabilityRoundingModeRTE = 4467,
    CapabilityRoundingModeRTZ = 4468,
    CapabilityRayQueryProvisionalKHR = 4471,
    CapabilityRayQueryKHR = 4472,
    CapabilityUntypedPointersKHR = 4473,
    CapabilityRayTraversalPrimitiveCullingKHR = 4478,
    CapabilityRayTracingKHR = 4479,
    CapabilityTextureSampleWeightedQCOM = 4484,
    CapabilityTextureBoxFilterQCOM = 4485,
    CapabilityTextureBlockMatchQCOM = 4486,
    CapabilityTextureBlockMatch2QCOM = 4498,
    CapabilityFloat16ImageAMD = 5008,
    CapabilityImageGatherBiasLodAMD = 5009,
    CapabilityFragmentMaskAMD = 5010,
    CapabilityStencilExportEXT = 5013,
    CapabilityImageReadWriteLodAMD = 5015,
    CapabilityInt64ImageEXT = 5016,
    CapabilityShaderClockKHR = 5055,
    CapabilityShaderEnqueueAMDX = 5067,
    CapabilityQuadControlKHR = 5087,
    CapabilitySampleMaskOverrideCoverageNV = 5249,
    CapabilityGeometryShaderPassthroughNV = 5251,
    CapabilityShaderViewportIndexLayerEXT = 5254,
    CapabilityShaderViewportIndexLayerNV = 5254,
    CapabilityShaderViewportMaskNV = 5255,
    CapabilityShaderStereoViewNV = 5259,
    CapabilityPerViewAttributesNV = 5260,
    CapabilityFragmentFullyCoveredEXT = 5265,
    CapabilityMeshShadingNV = 5266,
    CapabilityImageFootprintNV = 5282,
    CapabilityMeshShadingEXT = 5283,
    CapabilityFragmentBarycentricKHR = 5284,
    CapabilityFragmentBarycentricNV = 5284,
    CapabilityComputeDerivativeGroupQuadsKHR = 5288,
    CapabilityComputeDerivativeGroupQuadsNV = 5288,
    CapabilityFragmentDensityEXT = 5291,
    CapabilityShadingRateNV = 5291,
    CapabilityGroupNonUniformPartitionedNV = 5297,
    CapabilityShaderNonUniform = 5301,
    CapabilityShaderNonUniformEXT = 5301,
    CapabilityRuntimeDescriptorArray = 5302,
    CapabilityRuntimeDescriptorArrayEXT = 5302,
    CapabilityInputAttachmentArrayDynamicIndexing = 5303,
    CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
    CapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
    CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
    CapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
    CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
    CapabilityUniformBufferArrayNonUniformIndexing = 5306,
    CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
    CapabilitySampledImageArrayNonUniformIndexing = 5307,
    CapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
    CapabilityStorageBufferArrayNonUniformIndexing = 5308,
    CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
    CapabilityStorageImageArrayNonUniformIndexing = 5309,
    CapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
    CapabilityInputAttachmentArrayNonUniformIndexing = 5310,
    CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
    CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
    CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
    CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
    CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
    CapabilityRayTracingPositionFetchKHR = 5336,
    CapabilityRayTracingNV = 5340,
    CapabilityRayTracingMotionBlurNV = 5341,
    CapabilityVulkanMemoryModel = 5345,
    CapabilityVulkanMemoryModelKHR = 5345,
    CapabilityVulkanMemoryModelDeviceScope = 5346,
    CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
    CapabilityPhysicalStorageBufferAddresses = 5347,
    CapabilityPhysicalStorageBufferAddressesEXT = 5347,
    CapabilityComputeDerivativeGroupLinearKHR = 5350,
    CapabilityComputeDerivativeGroupLinearNV = 5350,
    CapabilityRayTracingProvisionalKHR = 5353,
    CapabilityCooperativeMatrixNV = 5357,
    CapabilityFragmentShaderSampleInterlockEXT = 5363,
    CapabilityFragmentShaderShadingRateInterlockEXT = 5372,
    CapabilityShaderSMBuiltinsNV = 5373,
    CapabilityFragmentShaderPixelInterlockEXT = 5378,
    CapabilityDemoteToHelperInvocation = 5379,
    CapabilityDemoteToHelperInvocationEXT = 5379,
    CapabilityDisplacementMicromapNV = 5380,
    CapabilityRayTracingOpacityMicromapEXT = 5381,
    CapabilityShaderInvocationReorderNV = 5383,
    CapabilityBindlessTextureNV = 5390,
    CapabilityRayQueryPositionFetchKHR = 5391,
    CapabilityCooperativeVectorNV = 5394,
    CapabilityAtomicFloat16VectorNV = 5404,
    CapabilityRayTracingDisplacementMicromapNV = 5409,
    CapabilityRawAccessChainsNV = 5414,
    CapabilityRayTracingSpheresGeometryNV = 5418,
    CapabilityRayTracingLinearSweptSpheresGeometryNV = 5419,
    CapabilityCooperativeMatrixReductionsNV = 5430,
    CapabilityCooperativeMatrixConversionsNV = 5431,
    CapabilityCooperativeMatrixPerElementOperationsNV = 5432,
    CapabilityCooperativeMatrixTensorAddressingNV = 5433,
    CapabilityCooperativeMatrixBlockLoadsNV = 5434,
    CapabilityCooperativeVectorTrainingNV = 5435,
    CapabilityRayTracingClusterAccelerationStructureNV = 5437,
    CapabilityTensorAddressingNV = 5439,
    CapabilitySubgroupShuffleINTEL = 5568,
    CapabilitySubgroupBufferBlockIOINTEL = 5569,
    CapabilitySubgroupImageBlockIOINTEL = 5570,
    CapabilitySubgroupImageMediaBlockIOINTEL = 5579,
    CapabilityRoundToInfinityINTEL = 5582,
    CapabilityFloatingPointModeINTEL = 5583,
    CapabilityIntegerFunctions2INTEL = 5584,
    CapabilityFunctionPointersINTEL = 5603,
    CapabilityIndirectReferencesINTEL = 5604,
    CapabilityAsmINTEL = 5606,
    CapabilityAtomicFloat32MinMaxEXT = 5612,
    CapabilityAtomicFloat64MinMaxEXT = 5613,
    CapabilityAtomicFloat16MinMaxEXT = 5616,
    CapabilityVectorComputeINTEL = 5617,
    CapabilityVectorAnyINTEL = 5619,
    CapabilityExpectAssumeKHR = 5629,
    CapabilitySubgroupAvcMotionEstimationINTEL = 5696,
    CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
    CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
    CapabilityVariableLengthArrayINTEL = 5817,
    CapabilityFunctionFloatControlINTEL = 5821,
    CapabilityFPGAMemoryAttributesINTEL = 5824,
    CapabilityFPFastMathModeINTEL = 5837,
    CapabilityArbitraryPrecisionIntegersINTEL = 5844,
    CapabilityArbitraryPrecisionFloatingPointINTEL = 5845,
    CapabilityUnstructuredLoopControlsINTEL = 5886,
    CapabilityFPGALoopControlsINTEL = 5888,
    CapabilityKernelAttributesINTEL = 5892,
    CapabilityFPGAKernelAttributesINTEL = 5897,
    CapabilityFPGAMemoryAccessesINTEL = 5898,
    CapabilityFPGAClusterAttributesINTEL = 5904,
    CapabilityLoopFuseINTEL = 5906,
    CapabilityFPGADSPControlINTEL = 5908,
    CapabilityMemoryAccessAliasingINTEL = 5910,
    CapabilityFPGAInvocationPipeliningAttributesINTEL = 5916,
    CapabilityFPGABufferLocationINTEL = 5920,
    CapabilityArbitraryPrecisionFixedPointINTEL = 5922,
    CapabilityUSMStorageClassesINTEL = 5935,
    CapabilityRuntimeAlignedAttributeINTEL = 5939,
    CapabilityIOPipesINTEL = 5943,
    CapabilityBlockingPipesINTEL = 5945,
    CapabilityFPGARegINTEL = 5948,
    CapabilityDotProductInputAll = 6016,
    CapabilityDotProductInputAllKHR = 6016,
    CapabilityDotProductInput4x8Bit = 6017,
    CapabilityDotProductInput4x8BitKHR = 6017,
    CapabilityDotProductInput4x8BitPacked = 6018,
    CapabilityDotProductInput4x8BitPackedKHR = 6018,
    CapabilityDotProduct = 6019,
    CapabilityDotProductKHR = 6019,
    CapabilityRayCullMaskKHR = 6020,
    CapabilityCooperativeMatrixKHR = 6022,
    CapabilityReplicatedCompositesEXT = 6024,
    CapabilityBitInstructions = 6025,
    CapabilityGroupNonUniformRotateKHR = 6026,
    CapabilityFloatControls2 = 6029,
    CapabilityAtomicFloat32AddEXT = 6033,
    CapabilityAtomicFloat64AddEXT = 6034,
    CapabilityLongCompositesINTEL = 6089,
    CapabilityOptNoneEXT = 6094,
    CapabilityOptNoneINTEL = 6094,
    CapabilityAtomicFloat16AddEXT = 6095,
    CapabilityDebugInfoModuleINTEL = 6114,
    CapabilityBFloat16ConversionINTEL = 6115,
    CapabilitySplitBarrierINTEL = 6141,
    CapabilityArithmeticFenceEXT = 6144,
    CapabilityFPGAClusterAttributesV2INTEL = 6150,
    CapabilityFPGAKernelAttributesv2INTEL = 6161,
    CapabilityFPMaxErrorINTEL = 6169,
    CapabilityFPGALatencyControlINTEL = 6171,
    CapabilityFPGAArgumentInterfacesINTEL = 6174,
    CapabilityGlobalVariableHostAccessINTEL = 6187,
    CapabilityGlobalVariableFPGADecorationsINTEL = 6189,
    CapabilitySubgroupBufferPrefetchINTEL = 6220,
    CapabilitySubgroup2DBlockIOINTEL = 6228,
    CapabilitySubgroup2DBlockTransformINTEL = 6229,
    CapabilitySubgroup2DBlockTransposeINTEL = 6230,
    CapabilitySubgroupMatrixMultiplyAccumulateINTEL = 6236,
    CapabilityGroupUniformArithmeticKHR = 6400,
    CapabilityMaskedGatherScatterINTEL = 6427,
    CapabilityCacheControlsINTEL = 6441,
    CapabilityRegisterLimitsINTEL = 6460,
    CapabilityMax = 0x7fffffff,
};

enum RayFlagsShift {
    RayFlagsOpaqueKHRShift = 0,
    RayFlagsNoOpaqueKHRShift = 1,
    RayFlagsTerminateOnFirstHitKHRShift = 2,
    RayFlagsSkipClosestHitShaderKHRShift = 3,
    RayFlagsCullBackFacingTrianglesKHRShift = 4,
    RayFlagsCullFrontFacingTrianglesKHRShift = 5,
    RayFlagsCullOpaqueKHRShift = 6,
    RayFlagsCullNoOpaqueKHRShift = 7,
    RayFlagsSkipBuiltinPrimitivesNVShift = 8,
    RayFlagsSkipTrianglesKHRShift = 8,
    RayFlagsSkipAABBsKHRShift = 9,
    RayFlagsForceOpacityMicromap2StateEXTShift = 10,
    RayFlagsMax = 0x7fffffff,
};

enum RayFlagsMask {
    RayFlagsMaskNone = 0,
    RayFlagsOpaqueKHRMask = 0x00000001,
    RayFlagsNoOpaqueKHRMask = 0x00000002,
    RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
    RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
    RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
    RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
    RayFlagsCullOpaqueKHRMask = 0x00000040,
    RayFlagsCullNoOpaqueKHRMask = 0x00000080,
    RayFlagsSkipBuiltinPrimitivesNVMask = 0x00000100,
    RayFlagsSkipTrianglesKHRMask = 0x00000100,
    RayFlagsSkipAABBsKHRMask = 0x00000200,
    RayFlagsForceOpacityMicromap2StateEXTMask = 0x00000400,
};

enum RayQueryIntersection {
    RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
    RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
    RayQueryIntersectionMax = 0x7fffffff,
};

enum RayQueryCommittedIntersectionType {
    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
    RayQueryCommittedIntersectionTypeMax = 0x7fffffff,
};

enum RayQueryCandidateIntersectionType {
    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
    RayQueryCandidateIntersectionTypeMax = 0x7fffffff,
};

enum FragmentShadingRateShift {
    FragmentShadingRateVertical2PixelsShift = 0,
    FragmentShadingRateVertical4PixelsShift = 1,
    FragmentShadingRateHorizontal2PixelsShift = 2,
    FragmentShadingRateHorizontal4PixelsShift = 3,
    FragmentShadingRateMax = 0x7fffffff,
};

enum FragmentShadingRateMask {
    FragmentShadingRateMaskNone = 0,
    FragmentShadingRateVertical2PixelsMask = 0x00000001,
    FragmentShadingRateVertical4PixelsMask = 0x00000002,
    FragmentShadingRateHorizontal2PixelsMask = 0x00000004,
    FragmentShadingRateHorizontal4PixelsMask = 0x00000008,
};

enum FPDenormMode {
    FPDenormModePreserve = 0,
    FPDenormModeFlushToZero = 1,
    FPDenormModeMax = 0x7fffffff,
};

enum FPOperationMode {
    FPOperationModeIEEE = 0,
    FPOperationModeALT = 1,
    FPOperationModeMax = 0x7fffffff,
};

enum QuantizationModes {
    QuantizationModesTRN = 0,
    QuantizationModesTRN_ZERO = 1,
    QuantizationModesRND = 2,
    QuantizationModesRND_ZERO = 3,
    QuantizationModesRND_INF = 4,
    QuantizationModesRND_MIN_INF = 5,
    QuantizationModesRND_CONV = 6,
    QuantizationModesRND_CONV_ODD = 7,
    QuantizationModesMax = 0x7fffffff,
};

enum OverflowModes {
    OverflowModesWRAP = 0,
    OverflowModesSAT = 1,
    OverflowModesSAT_ZERO = 2,
    OverflowModesSAT_SYM = 3,
    OverflowModesMax = 0x7fffffff,
};

enum PackedVectorFormat {
    PackedVectorFormatPackedVectorFormat4x8Bit = 0,
    PackedVectorFormatPackedVectorFormat4x8BitKHR = 0,
    PackedVectorFormatMax = 0x7fffffff,
};

enum CooperativeMatrixOperandsShift {
    CooperativeMatrixOperandsMatrixASignedComponentsKHRShift = 0,
    CooperativeMatrixOperandsMatrixBSignedComponentsKHRShift = 1,
    CooperativeMatrixOperandsMatrixCSignedComponentsKHRShift = 2,
    CooperativeMatrixOperandsMatrixResultSignedComponentsKHRShift = 3,
    CooperativeMatrixOperandsSaturatingAccumulationKHRShift = 4,
    CooperativeMatrixOperandsMax = 0x7fffffff,
};

enum CooperativeMatrixOperandsMask {
    CooperativeMatrixOperandsMaskNone = 0,
    CooperativeMatrixOperandsMatrixASignedComponentsKHRMask = 0x00000001,
    CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask = 0x00000002,
    CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask = 0x00000004,
    CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask = 0x00000008,
    CooperativeMatrixOperandsSaturatingAccumulationKHRMask = 0x00000010,
};

enum CooperativeMatrixLayout {
    CooperativeMatrixLayoutRowMajorKHR = 0,
    CooperativeMatrixLayoutColumnMajorKHR = 1,
    CooperativeMatrixLayoutRowBlockedInterleavedARM = 4202,
    CooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203,
    CooperativeMatrixLayoutMax = 0x7fffffff,
};

enum CooperativeMatrixUse {
    CooperativeMatrixUseMatrixAKHR = 0,
    CooperativeMatrixUseMatrixBKHR = 1,
    CooperativeMatrixUseMatrixAccumulatorKHR = 2,
    CooperativeMatrixUseMax = 0x7fffffff,
};

enum CooperativeMatrixReduceShift {
    CooperativeMatrixReduceRowShift = 0,
    CooperativeMatrixReduceColumnShift = 1,
    CooperativeMatrixReduce2x2Shift = 2,
    CooperativeMatrixReduceMax = 0x7fffffff,
};

enum CooperativeMatrixReduceMask {
    CooperativeMatrixReduceMaskNone = 0,
    CooperativeMatrixReduceRowMask = 0x00000001,
    CooperativeMatrixReduceColumnMask = 0x00000002,
    CooperativeMatrixReduce2x2Mask = 0x00000004,
};

enum TensorClampMode {
    TensorClampModeUndefined = 0,
    TensorClampModeConstant = 1,
    TensorClampModeClampToEdge = 2,
    TensorClampModeRepeat = 3,
    TensorClampModeRepeatMirrored = 4,
    TensorClampModeMax = 0x7fffffff,
};

enum TensorAddressingOperandsShift {
    TensorAddressingOperandsTensorViewShift = 0,
    TensorAddressingOperandsDecodeFuncShift = 1,
    TensorAddressingOperandsMax = 0x7fffffff,
};

enum TensorAddressingOperandsMask {
    TensorAddressingOperandsMaskNone = 0,
    TensorAddressingOperandsTensorViewMask = 0x00000001,
    TensorAddressingOperandsDecodeFuncMask = 0x00000002,
};

enum InitializationModeQualifier {
    InitializationModeQualifierInitOnDeviceReprogramINTEL = 0,
    InitializationModeQualifierInitOnDeviceResetINTEL = 1,
    InitializationModeQualifierMax = 0x7fffffff,
};

enum HostAccessQualifier {
    HostAccessQualifierNoneINTEL = 0,
    HostAccessQualifierReadINTEL = 1,
    HostAccessQualifierWriteINTEL = 2,
    HostAccessQualifierReadWriteINTEL = 3,
    HostAccessQualifierMax = 0x7fffffff,
};

enum LoadCacheControl {
    LoadCacheControlUncachedINTEL = 0,
    LoadCacheControlCachedINTEL = 1,
    LoadCacheControlStreamingINTEL = 2,
    LoadCacheControlInvalidateAfterReadINTEL = 3,
    LoadCacheControlConstCachedINTEL = 4,
    LoadCacheControlMax = 0x7fffffff,
};

enum StoreCacheControl {
    StoreCacheControlUncachedINTEL = 0,
    StoreCacheControlWriteThroughINTEL = 1,
    StoreCacheControlWriteBackINTEL = 2,
    StoreCacheControlStreamingINTEL = 3,
    StoreCacheControlMax = 0x7fffffff,
};

enum NamedMaximumNumberOfRegisters {
    NamedMaximumNumberOfRegistersAutoINTEL = 0,
    NamedMaximumNumberOfRegistersMax = 0x7fffffff,
};

enum MatrixMultiplyAccumulateOperandsShift {
    MatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELShift = 0,
    MatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELShift = 1,
    MatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELShift = 2,
    MatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELShift = 3,
    MatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELShift = 4,
    MatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELShift = 5,
    MatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELShift = 6,
    MatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELShift = 7,
    MatrixMultiplyAccumulateOperandsMatrixATF32INTELShift = 8,
    MatrixMultiplyAccumulateOperandsMatrixBTF32INTELShift = 9,
    MatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELShift = 10,
    MatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELShift = 11,
    MatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELShift = 12,
    MatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELShift = 13,
    MatrixMultiplyAccumulateOperandsMax = 0x7fffffff,
};

enum MatrixMultiplyAccumulateOperandsMask {
    MatrixMultiplyAccumulateOperandsMaskNone = 0,
    MatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELMask = 0x00000001,
    MatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELMask = 0x00000002,
    MatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELMask = 0x00000004,
    MatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELMask = 0x00000008,
    MatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELMask = 0x00000010,
    MatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELMask = 0x00000020,
    MatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELMask = 0x00000040,
    MatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELMask = 0x00000080,
    MatrixMultiplyAccumulateOperandsMatrixATF32INTELMask = 0x00000100,
    MatrixMultiplyAccumulateOperandsMatrixBTF32INTELMask = 0x00000200,
    MatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELMask = 0x00000400,
    MatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELMask = 0x00000800,
    MatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELMask = 0x00001000,
    MatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELMask = 0x00002000,
};

enum RawAccessChainOperandsShift {
    RawAccessChainOperandsRobustnessPerComponentNVShift = 0,
    RawAccessChainOperandsRobustnessPerElementNVShift = 1,
    RawAccessChainOperandsMax = 0x7fffffff,
};

enum RawAccessChainOperandsMask {
    RawAccessChainOperandsMaskNone = 0,
    RawAccessChainOperandsRobustnessPerComponentNVMask = 0x00000001,
    RawAccessChainOperandsRobustnessPerElementNVMask = 0x00000002,
};

enum FPEncoding {
    FPEncodingMax = 0x7fffffff,
};

enum CooperativeVectorMatrixLayout {
    CooperativeVectorMatrixLayoutRowMajorNV = 0,
    CooperativeVectorMatrixLayoutColumnMajorNV = 1,
    CooperativeVectorMatrixLayoutInferencingOptimalNV = 2,
    CooperativeVectorMatrixLayoutTrainingOptimalNV = 3,
    CooperativeVectorMatrixLayoutMax = 0x7fffffff,
};

enum ComponentType {
    ComponentTypeFloat16NV = 0,
    ComponentTypeFloat32NV = 1,
    ComponentTypeFloat64NV = 2,
    ComponentTypeSignedInt8NV = 3,
    ComponentTypeSignedInt16NV = 4,
    ComponentTypeSignedInt32NV = 5,
    ComponentTypeSignedInt64NV = 6,
    ComponentTypeUnsignedInt8NV = 7,
    ComponentTypeUnsignedInt16NV = 8,
    ComponentTypeUnsignedInt32NV = 9,
    ComponentTypeUnsignedInt64NV = 10,
    ComponentTypeSignedInt8PackedNV = 1000491000,
    ComponentTypeUnsignedInt8PackedNV = 1000491001,
    ComponentTypeFloatE4M3NV = 1000491002,
    ComponentTypeFloatE5M2NV = 1000491003,
    ComponentTypeMax = 0x7fffffff,
};

enum Op {
    OpNop = 0,
    OpUndef = 1,
    OpSourceContinued = 2,
    OpSource = 3,
    OpSourceExtension = 4,
    OpName = 5,
    OpMemberName = 6,
    OpString = 7,
    OpLine = 8,
    OpExtension = 10,
    OpExtInstImport = 11,
    OpExtInst = 12,
    OpMemoryModel = 14,
    OpEntryPoint = 15,
    OpExecutionMode = 16,
    OpCapability = 17,
    OpTypeVoid = 19,
    OpTypeBool = 20,
    OpTypeInt = 21,
    OpTypeFloat = 22,
    OpTypeVector = 23,
    OpTypeMatrix = 24,
    OpTypeImage = 25,
    OpTypeSampler = 26,
    OpTypeSampledImage = 27,
    OpTypeArray = 28,
    OpTypeRuntimeArray = 29,
    OpTypeStruct = 30,
    OpTypeOpaque = 31,
    OpTypePointer = 32,
    OpTypeFunction = 33,
    OpTypeEvent = 34,
    OpTypeDeviceEvent = 35,
    OpTypeReserveId = 36,
    OpTypeQueue = 37,
    OpTypePipe = 38,
    OpTypeForwardPointer = 39,
    OpConstantTrue = 41,
    OpConstantFalse = 42,
    OpConstant = 43,
    OpConstantComposite = 44,
    OpConstantSampler = 45,
    OpConstantNull = 46,
    OpSpecConstantTrue = 48,
    OpSpecConstantFalse = 49,
    OpSpecConstant = 50,
    OpSpecConstantComposite = 51,
    OpSpecConstantOp = 52,
    OpFunction = 54,
    OpFunctionParameter = 55,
    OpFunctionEnd = 56,
    OpFunctionCall = 57,
    OpVariable = 59,
    OpImageTexelPointer = 60,
    OpLoad = 61,
    OpStore = 62,
    OpCopyMemory = 63,
    OpCopyMemorySized = 64,
    OpAccessChain = 65,
    OpInBoundsAccessChain = 66,
    OpPtrAccessChain = 67,
    OpArrayLength = 68,
    OpGenericPtrMemSemantics = 69,
    OpInBoundsPtrAccessChain = 70,
    OpDecorate = 71,
    OpMemberDecorate = 72,
    OpDecorationGroup = 73,
    OpGroupDecorate = 74,
    OpGroupMemberDecorate = 75,
    OpVectorExtractDynamic = 77,
    OpVectorInsertDynamic = 78,
    OpVectorShuffle = 79,
    OpCompositeConstruct = 80,
    OpCompositeExtract = 81,
    OpCompositeInsert = 82,
    OpCopyObject = 83,
    OpTranspose = 84,
    OpSampledImage = 86,
    OpImageSampleImplicitLod = 87,
    OpImageSampleExplicitLod = 88,
    OpImageSampleDrefImplicitLod = 89,
    OpImageSampleDrefExplicitLod = 90,
    OpImageSampleProjImplicitLod = 91,
    OpImageSampleProjExplicitLod = 92,
    OpImageSampleProjDrefImplicitLod = 93,
    OpImageSampleProjDrefExplicitLod = 94,
    OpImageFetch = 95,
    OpImageGather = 96,
    OpImageDrefGather = 97,
    OpImageRead = 98,
    OpImageWrite = 99,
    OpImage = 100,
    OpImageQueryFormat = 101,
    OpImageQueryOrder = 102,
    OpImageQuerySizeLod = 103,
    OpImageQuerySize = 104,
    OpImageQueryLod = 105,
    OpImageQueryLevels = 106,
    OpImageQuerySamples = 107,
    OpConvertFToU = 109,
    OpConvertFToS = 110,
    OpConvertSToF = 111,
    OpConvertUToF = 112,
    OpUConvert = 113,
    OpSConvert = 114,
    OpFConvert = 115,
    OpQuantizeToF16 = 116,
    OpConvertPtrToU = 117,
    OpSatConvertSToU = 118,
    OpSatConvertUToS = 119,
    OpConvertUToPtr = 120,
    OpPtrCastToGeneric = 121,
    OpGenericCastToPtr = 122,
    OpGenericCastToPtrExplicit = 123,
    OpBitcast = 124,
    OpSNegate = 126,
    OpFNegate = 127,
    OpIAdd = 128,
    OpFAdd = 129,
    OpISub = 130,
    OpFSub = 131,
    OpIMul = 132,
    OpFMul = 133,
    OpUDiv = 134,
    OpSDiv = 135,
    OpFDiv = 136,
    OpUMod = 137,
    OpSRem = 138,
    OpSMod = 139,
    OpFRem = 140,
    OpFMod = 141,
    OpVectorTimesScalar = 142,
    OpMatrixTimesScalar = 143,
    OpVectorTimesMatrix = 144,
    OpMatrixTimesVector = 145,
    OpMatrixTimesMatrix = 146,
    OpOuterProduct = 147,
    OpDot = 148,
    OpIAddCarry = 149,
    OpISubBorrow = 150,
    OpUMulExtended = 151,
    OpSMulExtended = 152,
    OpAny = 154,
    OpAll = 155,
    OpIsNan = 156,
    OpIsInf = 157,
    OpIsFinite = 158,
    OpIsNormal = 159,
    OpSignBitSet = 160,
    OpLessOrGreater = 161,
    OpOrdered = 162,
    OpUnordered = 163,
    OpLogicalEqual = 164,
    OpLogicalNotEqual = 165,
    OpLogicalOr = 166,
    OpLogicalAnd = 167,
    OpLogicalNot = 168,
    OpSelect = 169,
    OpIEqual = 170,
    OpINotEqual = 171,
    OpUGreaterThan = 172,
    OpSGreaterThan = 173,
    OpUGreaterThanEqual = 174,
    OpSGreaterThanEqual = 175,
    OpULessThan = 176,
    OpSLessThan = 177,
    OpULessThanEqual = 178,
    OpSLessThanEqual = 179,
    OpFOrdEqual = 180,
    OpFUnordEqual = 181,
    OpFOrdNotEqual = 182,
    OpFUnordNotEqual = 183,
    OpFOrdLessThan = 184,
    OpFUnordLessThan = 185,
    OpFOrdGreaterThan = 186,
    OpFUnordGreaterThan = 187,
    OpFOrdLessThanEqual = 188,
    OpFUnordLessThanEqual = 189,
    OpFOrdGreaterThanEqual = 190,
    OpFUnordGreaterThanEqual = 191,
    OpShiftRightLogical = 194,
    OpShiftRightArithmetic = 195,
    OpShiftLeftLogical = 196,
    OpBitwiseOr = 197,
    OpBitwiseXor = 198,
    OpBitwiseAnd = 199,
    OpNot = 200,
    OpBitFieldInsert = 201,
    OpBitFieldSExtract = 202,
    OpBitFieldUExtract = 203,
    OpBitReverse = 204,
    OpBitCount = 205,
    OpDPdx = 207,
    OpDPdy = 208,
    OpFwidth = 209,
    OpDPdxFine = 210,
    OpDPdyFine = 211,
    OpFwidthFine = 212,
    OpDPdxCoarse = 213,
    OpDPdyCoarse = 214,
    OpFwidthCoarse = 215,
    OpEmitVertex = 218,
    OpEndPrimitive = 219,
    OpEmitStreamVertex = 220,
    OpEndStreamPrimitive = 221,
    OpControlBarrier = 224,
    OpMemoryBarrier = 225,
    OpAtomicLoad = 227,
    OpAtomicStore = 228,
    OpAtomicExchange = 229,
    OpAtomicCompareExchange = 230,
    OpAtomicCompareExchangeWeak = 231,
    OpAtomicIIncrement = 232,
    OpAtomicIDecrement = 233,
    OpAtomicIAdd = 234,
    OpAtomicISub = 235,
    OpAtomicSMin = 236,
    OpAtomicUMin = 237,
    OpAtomicSMax = 238,
    OpAtomicUMax = 239,
    OpAtomicAnd = 240,
    OpAtomicOr = 241,
    OpAtomicXor = 242,
    OpPhi = 245,
    OpLoopMerge = 246,
    OpSelectionMerge = 247,
    OpLabel = 248,
    OpBranch = 249,
    OpBranchConditional = 250,
    OpSwitch = 251,
    OpKill = 252,
    OpReturn = 253,
    OpReturnValue = 254,
    OpUnreachable = 255,
    OpLifetimeStart = 256,
    OpLifetimeStop = 257,
    OpGroupAsyncCopy = 259,
    OpGroupWaitEvents = 260,
    OpGroupAll = 261,
    OpGroupAny = 262,
    OpGroupBroadcast = 263,
    OpGroupIAdd = 264,
    OpGroupFAdd = 265,
    OpGroupFMin = 266,
    OpGroupUMin = 267,
    OpGroupSMin = 268,
    OpGroupFMax = 269,
    OpGroupUMax = 270,
    OpGroupSMax = 271,
    OpReadPipe = 274,
    OpWritePipe = 275,
    OpReservedReadPipe = 276,
    OpReservedWritePipe = 277,
    OpReserveReadPipePackets = 278,
    OpReserveWritePipePackets = 279,
    OpCommitReadPipe = 280,
    OpCommitWritePipe = 281,
    OpIsValidReserveId = 282,
    OpGetNumPipePackets = 283,
    OpGetMaxPipePackets = 284,
    OpGroupReserveReadPipePackets = 285,
    OpGroupReserveWritePipePackets = 286,
    OpGroupCommitReadPipe = 287,
    OpGroupCommitWritePipe = 288,
    OpEnqueueMarker = 291,
    OpEnqueueKernel = 292,
    OpGetKernelNDrangeSubGroupCount = 293,
    OpGetKernelNDrangeMaxSubGroupSize = 294,
    OpGetKernelWorkGroupSize = 295,
    OpGetKernelPreferredWorkGroupSizeMultiple = 296,
    OpRetainEvent = 297,
    OpReleaseEvent = 298,
    OpCreateUserEvent = 299,
    OpIsValidEvent = 300,
    OpSetUserEventStatus = 301,
    OpCaptureEventProfilingInfo = 302,
    OpGetDefaultQueue = 303,
    OpBuildNDRange = 304,
    OpImageSparseSampleImplicitLod = 305,
    OpImageSparseSampleExplicitLod = 306,
    OpImageSparseSampleDrefImplicitLod = 307,
    OpImageSparseSampleDrefExplicitLod = 308,
    OpImageSparseSampleProjImplicitLod = 309,
    OpImageSparseSampleProjExplicitLod = 310,
    OpImageSparseSampleProjDrefImplicitLod = 311,
    OpImageSparseSampleProjDrefExplicitLod = 312,
    OpImageSparseFetch = 313,
    OpImageSparseGather = 314,
    OpImageSparseDrefGather = 315,
    OpImageSparseTexelsResident = 316,
    OpNoLine = 317,
    OpAtomicFlagTestAndSet = 318,
    OpAtomicFlagClear = 319,
    OpImageSparseRead = 320,
    OpSizeOf = 321,
    OpTypePipeStorage = 322,
    OpConstantPipeStorage = 323,
    OpCreatePipeFromPipeStorage = 324,
    OpGetKernelLocalSizeForSubgroupCount = 325,
    OpGetKernelMaxNumSubgroups = 326,
    OpTypeNamedBarrier = 327,
    OpNamedBarrierInitialize = 328,
    OpMemoryNamedBarrier = 329,
    OpModuleProcessed = 330,
    OpExecutionModeId = 331,
    OpDecorateId = 332,
    OpGroupNonUniformElect = 333,
    OpGroupNonUniformAll = 334,
    OpGroupNonUniformAny = 335,
    OpGroupNonUniformAllEqual = 336,
    OpGroupNonUniformBroadcast = 337,
    OpGroupNonUniformBroadcastFirst = 338,
    OpGroupNonUniformBallot = 339,
    OpGroupNonUniformInverseBallot = 340,
    OpGroupNonUniformBallotBitExtract = 341,
    OpGroupNonUniformBallotBitCount = 342,
    OpGroupNonUniformBallotFindLSB = 343,
    OpGroupNonUniformBallotFindMSB = 344,
    OpGroupNonUniformShuffle = 345,
    OpGroupNonUniformShuffleXor = 346,
    OpGroupNonUniformShuffleUp = 347,
    OpGroupNonUniformShuffleDown = 348,
    OpGroupNonUniformIAdd = 349,
    OpGroupNonUniformFAdd = 350,
    OpGroupNonUniformIMul = 351,
    OpGroupNonUniformFMul = 352,
    OpGroupNonUniformSMin = 353,
    OpGroupNonUniformUMin = 354,
    OpGroupNonUniformFMin = 355,
    OpGroupNonUniformSMax = 356,
    OpGroupNonUniformUMax = 357,
    OpGroupNonUniformFMax = 358,
    OpGroupNonUniformBitwiseAnd = 359,
    OpGroupNonUniformBitwiseOr = 360,
    OpGroupNonUniformBitwiseXor = 361,
    OpGroupNonUniformLogicalAnd = 362,
    OpGroupNonUniformLogicalOr = 363,
    OpGroupNonUniformLogicalXor = 364,
    OpGroupNonUniformQuadBroadcast = 365,
    OpGroupNonUniformQuadSwap = 366,
    OpCopyLogical = 400,
    OpPtrEqual = 401,
    OpPtrNotEqual = 402,
    OpPtrDiff = 403,
    OpColorAttachmentReadEXT = 4160,
    OpDepthAttachmentReadEXT = 4161,
    OpStencilAttachmentReadEXT = 4162,
    OpTerminateInvocation = 4416,
    OpTypeUntypedPointerKHR = 4417,
    OpUntypedVariableKHR = 4418,
    OpUntypedAccessChainKHR = 4419,
    OpUntypedInBoundsAccessChainKHR = 4420,
    OpSubgroupBallotKHR = 4421,
    OpSubgroupFirstInvocationKHR = 4422,
    OpUntypedPtrAccessChainKHR = 4423,
    OpUntypedInBoundsPtrAccessChainKHR = 4424,
    OpUntypedArrayLengthKHR = 4425,
    OpUntypedPrefetchKHR = 4426,
    OpSubgroupAllKHR = 4428,
    OpSubgroupAnyKHR = 4429,
    OpSubgroupAllEqualKHR = 4430,
    OpGroupNonUniformRotateKHR = 4431,
    OpSubgroupReadInvocationKHR = 4432,
    OpExtInstWithForwardRefsKHR = 4433,
    OpTraceRayKHR = 4445,
    OpExecuteCallableKHR = 4446,
    OpConvertUToAccelerationStructureKHR = 4447,
    OpIgnoreIntersectionKHR = 4448,
    OpTerminateRayKHR = 4449,
    OpSDot = 4450,
    OpSDotKHR = 4450,
    OpUDot = 4451,
    OpUDotKHR = 4451,
    OpSUDot = 4452,
    OpSUDotKHR = 4452,
    OpSDotAccSat = 4453,
    OpSDotAccSatKHR = 4453,
    OpUDotAccSat = 4454,
    OpUDotAccSatKHR = 4454,
    OpSUDotAccSat = 4455,
    OpSUDotAccSatKHR = 4455,
    OpTypeCooperativeMatrixKHR = 4456,
    OpCooperativeMatrixLoadKHR = 4457,
    OpCooperativeMatrixStoreKHR = 4458,
    OpCooperativeMatrixMulAddKHR = 4459,
    OpCooperativeMatrixLengthKHR = 4460,
    OpConstantCompositeReplicateEXT = 4461,
    OpSpecConstantCompositeReplicateEXT = 4462,
    OpCompositeConstructReplicateEXT = 4463,
    OpTypeRayQueryKHR = 4472,
    OpRayQueryInitializeKHR = 4473,
    OpRayQueryTerminateKHR = 4474,
    OpRayQueryGenerateIntersectionKHR = 4475,
    OpRayQueryConfirmIntersectionKHR = 4476,
    OpRayQueryProceedKHR = 4477,
    OpRayQueryGetIntersectionTypeKHR = 4479,
    OpImageSampleWeightedQCOM = 4480,
    OpImageBoxFilterQCOM = 4481,
    OpImageBlockMatchSSDQCOM = 4482,
    OpImageBlockMatchSADQCOM = 4483,
    OpImageBlockMatchWindowSSDQCOM = 4500,
    OpImageBlockMatchWindowSADQCOM = 4501,
    OpImageBlockMatchGatherSSDQCOM = 4502,
    OpImageBlockMatchGatherSADQCOM = 4503,
    OpGroupIAddNonUniformAMD = 5000,
    OpGroupFAddNonUniformAMD = 5001,
    OpGroupFMinNonUniformAMD = 5002,
    OpGroupUMinNonUniformAMD = 5003,
    OpGroupSMinNonUniformAMD = 5004,
    OpGroupFMaxNonUniformAMD = 5005,
    OpGroupUMaxNonUniformAMD = 5006,
    OpGroupSMaxNonUniformAMD = 5007,
    OpFragmentMaskFetchAMD = 5011,
    OpFragmentFetchAMD = 5012,
    OpReadClockKHR = 5056,
    OpAllocateNodePayloadsAMDX = 5074,
    OpEnqueueNodePayloadsAMDX = 5075,
    OpTypeNodePayloadArrayAMDX = 5076,
    OpFinishWritingNodePayloadAMDX = 5078,
    OpNodePayloadArrayLengthAMDX = 5090,
    OpIsNodePayloadValidAMDX = 5101,
    OpConstantStringAMDX = 5103,
    OpSpecConstantStringAMDX = 5104,
    OpGroupNonUniformQuadAllKHR = 5110,
    OpGroupNonUniformQuadAnyKHR = 5111,
    OpHitObjectRecordHitMotionNV = 5249,
    OpHitObjectRecordHitWithIndexMotionNV = 5250,
    OpHitObjectRecordMissMotionNV = 5251,
    OpHitObjectGetWorldToObjectNV = 5252,
    OpHitObjectGetObjectToWorldNV = 5253,
    OpHitObjectGetObjectRayDirectionNV = 5254,
    OpHitObjectGetObjectRayOriginNV = 5255,
    OpHitObjectTraceRayMotionNV = 5256,
    OpHitObjectGetShaderRecordBufferHandleNV = 5257,
    OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
    OpHitObjectRecordEmptyNV = 5259,
    OpHitObjectTraceRayNV = 5260,
    OpHitObjectRecordHitNV = 5261,
    OpHitObjectRecordHitWithIndexNV = 5262,
    OpHitObjectRecordMissNV = 5263,
    OpHitObjectExecuteShaderNV = 5264,
    OpHitObjectGetCurrentTimeNV = 5265,
    OpHitObjectGetAttributesNV = 5266,
    OpHitObjectGetHitKindNV = 5267,
    OpHitObjectGetPrimitiveIndexNV = 5268,
    OpHitObjectGetGeometryIndexNV = 5269,
    OpHitObjectGetInstanceIdNV = 5270,
    OpHitObjectGetInstanceCustomIndexNV = 5271,
    OpHitObjectGetWorldRayDirectionNV = 5272,
    OpHitObjectGetWorldRayOriginNV = 5273,
    OpHitObjectGetRayTMaxNV = 5274,
    OpHitObjectGetRayTMinNV = 5275,
    OpHitObjectIsEmptyNV = 5276,
    OpHitObjectIsHitNV = 5277,
    OpHitObjectIsMissNV = 5278,
    OpReorderThreadWithHitObjectNV = 5279,
    OpReorderThreadWithHintNV = 5280,
    OpTypeHitObjectNV = 5281,
    OpImageSampleFootprintNV = 5283,
    OpTypeCooperativeVectorNV = 5288,
    OpCooperativeVectorMatrixMulNV = 5289,
    OpCooperativeVectorOuterProductAccumulateNV = 5290,
    OpCooperativeVectorReduceSumAccumulateNV = 5291,
    OpCooperativeVectorMatrixMulAddNV = 5292,
    OpCooperativeMatrixConvertNV = 5293,
    OpEmitMeshTasksEXT = 5294,
    OpSetMeshOutputsEXT = 5295,
    OpGroupNonUniformPartitionNV = 5296,
    OpWritePackedPrimitiveIndices4x8NV = 5299,
    OpFetchMicroTriangleVertexPositionNV = 5300,
    OpFetchMicroTriangleVertexBarycentricNV = 5301,
    OpCooperativeVectorLoadNV = 5302,
    OpCooperativeVectorStoreNV = 5303,
    OpReportIntersectionKHR = 5334,
    OpReportIntersectionNV = 5334,
    OpIgnoreIntersectionNV = 5335,
    OpTerminateRayNV = 5336,
    OpTraceNV = 5337,
    OpTraceMotionNV = 5338,
    OpTraceRayMotionNV = 5339,
    OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
    OpTypeAccelerationStructureKHR = 5341,
    OpTypeAccelerationStructureNV = 5341,
    OpExecuteCallableNV = 5344,
    OpRayQueryGetClusterIdNV = 5345,
    OpHitObjectGetClusterIdNV = 5346,
    OpTypeCooperativeMatrixNV = 5358,
    OpCooperativeMatrixLoadNV = 5359,
    OpCooperativeMatrixStoreNV = 5360,
    OpCooperativeMatrixMulAddNV = 5361,
    OpCooperativeMatrixLengthNV = 5362,
    OpBeginInvocationInterlockEXT = 5364,
    OpEndInvocationInterlockEXT = 5365,
    OpCooperativeMatrixReduceNV = 5366,
    OpCooperativeMatrixLoadTensorNV = 5367,
    OpCooperativeMatrixStoreTensorNV = 5368,
    OpCooperativeMatrixPerElementOpNV = 5369,
    OpTypeTensorLayoutNV = 5370,
    OpTypeTensorViewNV = 5371,
    OpCreateTensorLayoutNV = 5372,
    OpTensorLayoutSetDimensionNV = 5373,
    OpTensorLayoutSetStrideNV = 5374,
    OpTensorLayoutSliceNV = 5375,
    OpTensorLayoutSetClampValueNV = 5376,
    OpCreateTensorViewNV = 5377,
    OpTensorViewSetDimensionNV = 5378,
    OpTensorViewSetStrideNV = 5379,
    OpDemoteToHelperInvocation = 5380,
    OpDemoteToHelperInvocationEXT = 5380,
    OpIsHelperInvocationEXT = 5381,
    OpTensorViewSetClipNV = 5382,
    OpTensorLayoutSetBlockSizeNV = 5384,
    OpCooperativeMatrixTransposeNV = 5390,
    OpConvertUToImageNV = 5391,
    OpConvertUToSamplerNV = 5392,
    OpConvertImageToUNV = 5393,
    OpConvertSamplerToUNV = 5394,
    OpConvertUToSampledImageNV = 5395,
    OpConvertSampledImageToUNV = 5396,
    OpSamplerImageAddressingModeNV = 5397,
    OpRawAccessChainNV = 5398,
    OpRayQueryGetIntersectionSpherePositionNV = 5427,
    OpRayQueryGetIntersectionSphereRadiusNV = 5428,
    OpRayQueryGetIntersectionLSSPositionsNV = 5429,
    OpRayQueryGetIntersectionLSSRadiiNV = 5430,
    OpRayQueryGetIntersectionLSSHitValueNV = 5431,
    OpHitObjectGetSpherePositionNV = 5432,
    OpHitObjectGetSphereRadiusNV = 5433,
    OpHitObjectGetLSSPositionsNV = 5434,
    OpHitObjectGetLSSRadiiNV = 5435,
    OpHitObjectIsSphereHitNV = 5436,
    OpHitObjectIsLSSHitNV = 5437,
    OpRayQueryIsSphereHitNV = 5438,
    OpRayQueryIsLSSHitNV = 5439,
    OpSubgroupShuffleINTEL = 5571,
    OpSubgroupShuffleDownINTEL = 5572,
    OpSubgroupShuffleUpINTEL = 5573,
    OpSubgroupShuffleXorINTEL = 5574,
    OpSubgroupBlockReadINTEL = 5575,
    OpSubgroupBlockWriteINTEL = 5576,
    OpSubgroupImageBlockReadINTEL = 5577,
    OpSubgroupImageBlockWriteINTEL = 5578,
    OpSubgroupImageMediaBlockReadINTEL = 5580,
    OpSubgroupImageMediaBlockWriteINTEL = 5581,
    OpUCountLeadingZerosINTEL = 5585,
    OpUCountTrailingZerosINTEL = 5586,
    OpAbsISubINTEL = 5587,
    OpAbsUSubINTEL = 5588,
    OpIAddSatINTEL = 5589,
    OpUAddSatINTEL = 5590,
    OpIAverageINTEL = 5591,
    OpUAverageINTEL = 5592,
    OpIAverageRoundedINTEL = 5593,
    OpUAverageRoundedINTEL = 5594,
    OpISubSatINTEL = 5595,
    OpUSubSatINTEL = 5596,
    OpIMul32x16INTEL = 5597,
    OpUMul32x16INTEL = 5598,
    OpConstantFunctionPointerINTEL = 5600,
    OpFunctionPointerCallINTEL = 5601,
    OpAsmTargetINTEL = 5609,
    OpAsmINTEL = 5610,
    OpAsmCallINTEL = 5611,
    OpAtomicFMinEXT = 5614,
    OpAtomicFMaxEXT = 5615,
    OpAssumeTrueKHR = 5630,
    OpExpectKHR = 5631,
    OpDecorateString = 5632,
    OpDecorateStringGOOGLE = 5632,
    OpMemberDecorateString = 5633,
    OpMemberDecorateStringGOOGLE = 5633,
    OpVmeImageINTEL = 5699,
    OpTypeVmeImageINTEL = 5700,
    OpTypeAvcImePayloadINTEL = 5701,
    OpTypeAvcRefPayloadINTEL = 5702,
    OpTypeAvcSicPayloadINTEL = 5703,
    OpTypeAvcMcePayloadINTEL = 5704,
    OpTypeAvcMceResultINTEL = 5705,
    OpTypeAvcImeResultINTEL = 5706,
    OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
    OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
    OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
    OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
    OpTypeAvcRefResultINTEL = 5711,
    OpTypeAvcSicResultINTEL = 5712,
    OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
    OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
    OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
    OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
    OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
    OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
    OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
    OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
    OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
    OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
    OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
    OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
    OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
    OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
    OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
    OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
    OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
    OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
    OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
    OpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
    OpSubgroupAvcMceConvertToImeResultINTEL = 5733,
    OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
    OpSubgroupAvcMceConvertToRefResultINTEL = 5735,
    OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
    OpSubgroupAvcMceConvertToSicResultINTEL = 5737,
    OpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
    OpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
    OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
    OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
    OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
    OpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
    OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
    OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
    OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
    OpSubgroupAvcImeInitializeINTEL = 5747,
    OpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
    OpSubgroupAvcImeSetDualReferenceINTEL = 5749,
    OpSubgroupAvcImeRefWindowSizeINTEL = 5750,
    OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
    OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
    OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
    OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
    OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
    OpSubgroupAvcImeSetWeightedSadINTEL = 5756,
    OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
    OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
    OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
    OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
    OpSubgroupAvcImeConvertToMceResultINTEL = 5765,
    OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
    OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
    OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
    OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
    OpSubgroupAvcImeGetBorderReachedINTEL = 5776,
    OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
    OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
    OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
    OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
    OpSubgroupAvcFmeInitializeINTEL = 5781,
    OpSubgroupAvcBmeInitializeINTEL = 5782,
    OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
    OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
    OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
    OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
    OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
    OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
    OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
    OpSubgroupAvcRefConvertToMceResultINTEL = 5790,
    OpSubgroupAvcSicInitializeINTEL = 5791,
    OpSubgroupAvcSicConfigureSkcINTEL = 5792,
    OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
    OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
    OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
    OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
    OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
    OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
    OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
    OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
    OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
    OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
    OpSubgroupAvcSicEvaluateIpeINTEL = 5803,
    OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
    OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
    OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
    OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
    OpSubgroupAvcSicConvertToMceResultINTEL = 5808,
    OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
    OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
    OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
    OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
    OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
    OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
    OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
    OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
    OpVariableLengthArrayINTEL = 5818,
    OpSaveMemoryINTEL = 5819,
    OpRestoreMemoryINTEL = 5820,
    OpArbitraryFloatSinCosPiINTEL = 5840,
    OpArbitraryFloatCastINTEL = 5841,
    OpArbitraryFloatCastFromIntINTEL = 5842,
    OpArbitraryFloatCastToIntINTEL = 5843,
    OpArbitraryFloatAddINTEL = 5846,
    OpArbitraryFloatSubINTEL = 5847,
    OpArbitraryFloatMulINTEL = 5848,
    OpArbitraryFloatDivINTEL = 5849,
    OpArbitraryFloatGTINTEL = 5850,
    OpArbitraryFloatGEINTEL = 5851,
    OpArbitraryFloatLTINTEL = 5852,
    OpArbitraryFloatLEINTEL = 5853,
    OpArbitraryFloatEQINTEL = 5854,
    OpArbitraryFloatRecipINTEL = 5855,
    OpArbitraryFloatRSqrtINTEL = 5856,
    OpArbitraryFloatCbrtINTEL = 5857,
    OpArbitraryFloatHypotINTEL = 5858,
    OpArbitraryFloatSqrtINTEL = 5859,
    OpArbitraryFloatLogINTEL = 5860,
    OpArbitraryFloatLog2INTEL = 5861,
    OpArbitraryFloatLog10INTEL = 5862,
    OpArbitraryFloatLog1pINTEL = 5863,
    OpArbitraryFloatExpINTEL = 5864,
    OpArbitraryFloatExp2INTEL = 5865,
    OpArbitraryFloatExp10INTEL = 5866,
    OpArbitraryFloatExpm1INTEL = 5867,
    OpArbitraryFloatSinINTEL = 5868,
    OpArbitraryFloatCosINTEL = 5869,
    OpArbitraryFloatSinCosINTEL = 5870,
    OpArbitraryFloatSinPiINTEL = 5871,
    OpArbitraryFloatCosPiINTEL = 5872,
    OpArbitraryFloatASinINTEL = 5873,
    OpArbitraryFloatASinPiINTEL = 5874,
    OpArbitraryFloatACosINTEL = 5875,
    OpArbitraryFloatACosPiINTEL = 5876,
    OpArbitraryFloatATanINTEL = 5877,
    OpArbitraryFloatATanPiINTEL = 5878,
    OpArbitraryFloatATan2INTEL = 5879,
    OpArbitraryFloatPowINTEL = 5880,
    OpArbitraryFloatPowRINTEL = 5881,
    OpArbitraryFloatPowNINTEL = 5882,
    OpLoopControlINTEL = 5887,
    OpAliasDomainDeclINTEL = 5911,
    OpAliasScopeDeclINTEL = 5912,
    OpAliasScopeListDeclINTEL = 5913,
    OpFixedSqrtINTEL = 5923,
    OpFixedRecipINTEL = 5924,
    OpFixedRsqrtINTEL = 5925,
    OpFixedSinINTEL = 5926,
    OpFixedCosINTEL = 5927,
    OpFixedSinCosINTEL = 5928,
    OpFixedSinPiINTEL = 5929,
    OpFixedCosPiINTEL = 5930,
    OpFixedSinCosPiINTEL = 5931,
    OpFixedLogINTEL = 5932,
    OpFixedExpINTEL = 5933,
    OpPtrCastToCrossWorkgroupINTEL = 5934,
    OpCrossWorkgroupCastToPtrINTEL = 5938,
    OpReadPipeBlockingINTEL = 5946,
    OpWritePipeBlockingINTEL = 5947,
    OpFPGARegINTEL = 5949,
    OpRayQueryGetRayTMinKHR = 6016,
    OpRayQueryGetRayFlagsKHR = 6017,
    OpRayQueryGetIntersectionTKHR = 6018,
    OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
    OpRayQueryGetIntersectionInstanceIdKHR = 6020,
    OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
    OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
    OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
    OpRayQueryGetIntersectionBarycentricsKHR = 6024,
    OpRayQueryGetIntersectionFrontFaceKHR = 6025,
    OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
    OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
    OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
    OpRayQueryGetWorldRayDirectionKHR = 6029,
    OpRayQueryGetWorldRayOriginKHR = 6030,
    OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
    OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
    OpAtomicFAddEXT = 6035,
    OpTypeBufferSurfaceINTEL = 6086,
    OpTypeStructContinuedINTEL = 6090,
    OpConstantCompositeContinuedINTEL = 6091,
    OpSpecConstantCompositeContinuedINTEL = 6092,
    OpCompositeConstructContinuedINTEL = 6096,
    OpConvertFToBF16INTEL = 6116,
    OpConvertBF16ToFINTEL = 6117,
    OpControlBarrierArriveINTEL = 6142,
    OpControlBarrierWaitINTEL = 6143,
    OpArithmeticFenceEXT = 6145,
    OpSubgroupBlockPrefetchINTEL = 6221,
    OpSubgroup2DBlockLoadINTEL = 6231,
    OpSubgroup2DBlockLoadTransformINTEL = 6232,
    OpSubgroup2DBlockLoadTransposeINTEL = 6233,
    OpSubgroup2DBlockPrefetchINTEL = 6234,
    OpSubgroup2DBlockStoreINTEL = 6235,
    OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
    OpGroupIMulKHR = 6401,
    OpGroupFMulKHR = 6402,
    OpGroupBitwiseAndKHR = 6403,
    OpGroupBitwiseOrKHR = 6404,
    OpGroupBitwiseXorKHR = 6405,
    OpGroupLogicalAndKHR = 6406,
    OpGroupLogicalOrKHR = 6407,
    OpGroupLogicalXorKHR = 6408,
    OpMaskedGatherINTEL = 6428,
    OpMaskedScatterINTEL = 6429,
    OpMax = 0x7fffffff,
};

#line 5153 "C:/Users/fjlet/Desktop/Nabla/3rdparty/dxc/dxc/external/SPIRV-Headers/include/spirv/unified1/spirv.hpp"
}  // end namespace spv

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts.hlsl"
// Copyright (C) 2023-2024 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/vector.hlsl"
// Copyright (C) 2024-2025 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 13 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/vector.hlsl"
namespace nbl
{
namespace hlsl
{
namespace concepts
{

//! Concept for native vectors.
template<typename T>
const static bool Vector = is_vector<T>::value;
template<typename T>
const static bool FloatingPointVector = concepts::Vector<T> && concepts::FloatingPointScalar<typename vector_traits<T>::scalar_type>;
template<typename T>
const static bool IntVector = concepts::Vector<T> && (is_integral_v<typename vector_traits<T>::scalar_type>);
template<typename T>
const static bool SignedIntVector = concepts::Vector<T> && concepts::SignedIntegralScalar<typename vector_traits<T>::scalar_type>;

//! Concept for native vectors and vector like structs.
template<typename T>
const static bool Vectorial = vector_traits<T>::IsVector;

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/__end.hlsl"
// Copyright (C) 2023-2024 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 36 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/vector.hlsl"
template<typename T>
const static bool FloatingPointVectorial = concepts::Vectorial<T> && concepts::FloatingPointScalar<typename vector_traits<T>::scalar_type>;
template<typename T>
const static bool FloatingPointLikeVectorial = concepts::Vectorial<T> && concepts::FloatingPointLikeScalar<typename vector_traits<T>::scalar_type>;
template<typename T>
const static bool IntVectorial = concepts::Vectorial<T> && (is_integral_v<typename vector_traits<T>::scalar_type>);
template<typename T>
const static bool IntegralLikeVectorial = concepts::Vectorial<T> && concepts::IntegralLikeScalar<typename vector_traits<T>::scalar_type>;
template<typename T>
const static bool SignedIntVectorial = concepts::Vectorial<T> && concepts::SignedIntegralScalar<typename vector_traits<T>::scalar_type>;

}

template<typename Vectorial>

struct extent<Vectorial, 0 ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<Vectorial>),void> > : integral_constant<uint64_t, vector_traits<Vectorial>::Dimension> {};

}
}

#line 17 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
namespace nbl 
{
namespace hlsl
{

#line 57 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
// 1.6 core caps and their old extensions

namespace spirv
{
//! General
[[vk::ext_builtin_input(spv::BuiltInHelperInvocation)]]
static const bool HelperInvocation;

//! Vertex Inputs
[[vk::ext_builtin_input(spv::BuiltInVertexIndex)]]
static const uint32_t VertexIndex;
[[vk::ext_builtin_input(spv::BuiltInInstanceIndex)]]
static const uint32_t InstanceIndex;

//! Vertex and friends
[[vk::ext_builtin_output(spv::BuiltInPosition)]]
static float32_t4 Position;

//! Compute Shader Builtins
[[vk::ext_builtin_input(spv::BuiltInNumWorkgroups)]]
static const uint32_t3 NumWorkGroups;
// TODO: Doesn't work, find out why and file issue on DXC!
//[[vk::ext_builtin_input(spv::BuiltInWorkgroupSize)]]
//static const uint32_t3 WorkgroupSize;
[[vk::ext_builtin_input(spv::BuiltInWorkgroupId)]]
static const uint32_t3 WorkgroupId;
[[vk::ext_builtin_input(spv::BuiltInLocalInvocationId)]]
static const uint32_t3 LocalInvocationId;
[[vk::ext_builtin_input(spv::BuiltInGlobalInvocationId)]]
static const uint32_t3 GlobalInvocationId;
[[vk::ext_builtin_input(spv::BuiltInLocalInvocationIndex)]]
static const uint32_t LocalInvocationIndex;

//! General Types
template<uint32_t StorageClass, typename T>
using pointer_t = vk::SpirvOpaqueType<spv::OpTypePointer,vk::Literal<vk::integral_constant<uint32_t,StorageClass> >,T>;

template<typename T>
struct is_pointer : false_type {};
template<typename I, I StorageClass, typename TT>
struct is_pointer<vk::SpirvOpaqueType<spv::OpTypePointer,vk::Literal<vk::integral_constant<I,StorageClass> >,TT> > : is_integral {};
template<uint32_t Size, uint32_t Alignment, typename I, I StorageClass, typename TT>
struct is_pointer<vk::SpirvType<spv::OpTypePointer,Size,Alignment,vk::Literal<vk::integral_constant<I,StorageClass> >,TT> > : is_integral {};
template<class T>
const static bool is_pointer_v = is_pointer<T>::value;

template<typename T>
using bda_pointer_t [[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] [[vk::ext_extension("SPV_KHR_physical_storage_buffer")]] = vk::SpirvType<spv::OpTypePointer, sizeof(uint64_t),alignment_of_v<uint64_t>, vk::Literal<vk::integral_constant<uint32_t, spv::StorageClassPhysicalStorageBuffer> >, T>;

template<typename T>
struct is_bda_pointer : false_type {};
template<typename I, typename TT>
struct is_pointer<vk::SpirvType<spv::OpTypePointer,sizeof(uint64_t),alignment_of_v<uint64_t>,vk::Literal<vk::integral_constant<I, spv::StorageClassPhysicalStorageBuffer> >, TT> > : is_integral {};
template<class T>
const static bool is_bda_pointer_v = is_bda_pointer<T>::value;

//! General Operations

//! Miscellaneous Instructions
template<typename T>
[[vk::ext_instruction(spv::OpUndef)]]
T undef();

//
template<typename M, typename T>
[[vk::ext_instruction(spv::OpAccessChain)]]
bda_pointer_t<M> accessChain(bda_pointer_t<T> v, int32_t index);
template<typename M, uint32_t StorageClass, typename T>
[[vk::ext_instruction(spv::OpAccessChain)]]
pointer_t<StorageClass,M> accessChain(pointer_t<StorageClass,T> v, int32_t index);

// The holy operation that makes addrof possible
template<typename T, typename U>
[[vk::ext_instruction(spv::OpCopyObject)]]
T copyObject(U v);

// unfortunately without reflection we can't validate that objects "logically match" in a concept
template<typename T, typename U>
[[vk::ext_instruction(spv::OpCopyLogical)]]
enable_if_t<!is_same_v<T,U>,T> copyLogical([[vk::ext_reference]] U v);
template<typename T, typename Ptr_U>
[[vk::ext_instruction(spv::OpCopyLogical)]]
enable_if_t<is_pointer_v<Ptr_U>/* && !is_same_v<T,U>*/,T> copyLogical(Ptr_U v);

// Here's the thing with atomics, it's not only the data type that dictates whether you can do an atomic or not.
// It's the storage class that has the most effect (shared vs storage vs image) and we can't check that easily
template<typename T> // integers operate on 2s complement so same op for signed and unsigned
[[vk::ext_instruction(spv::OpAtomicIAdd)]]
enable_if_t<is_same_v<T,uint32_t> || is_same_v<T,int32_t>, T> atomicIAdd([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicIAdd)]]
enable_if_t<is_pointer_v<Ptr_T> && (is_same_v<T,uint32_t> || is_same_v<T,int32_t>), T> atomicIAdd(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T> // integers operate on 2s complement so same op for signed and unsigned
[[vk::ext_capability(spv::CapabilityInt64Atomics)]]
[[vk::ext_instruction(spv::OpAtomicIAdd)]]
enable_if_t<is_same_v<T,uint64_t> || is_same_v<T,int64_t>, T> atomicIAdd([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_capability(spv::CapabilityInt64Atomics)]]
[[vk::ext_instruction(spv::OpAtomicIAdd)]]
enable_if_t<is_pointer_v<Ptr_T> && (is_same_v<T,uint64_t> || is_same_v<T,int64_t>), T> atomicIAdd(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T> // integers operate on 2s complement so same op for signed and unsigned
[[vk::ext_instruction(spv::OpAtomicISub)]]
enable_if_t<is_same_v<T,uint32_t> || is_same_v<T,int32_t>, T> atomicISub([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicISub)]]
enable_if_t<is_pointer_v<Ptr_T> && (is_same_v<T,uint32_t> || is_same_v<T,int32_t>), T> atomicISub(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T> // integers operate on 2s complement so same op for signed and unsigned
[[vk::ext_capability(spv::CapabilityInt64Atomics)]]
[[vk::ext_instruction(spv::OpAtomicISub)]]
enable_if_t<is_same_v<T,uint64_t> || is_same_v<T,int64_t>, T> atomicISub([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_capability(spv::CapabilityInt64Atomics)]]
[[vk::ext_instruction(spv::OpAtomicISub)]]
enable_if_t<is_pointer_v<Ptr_T> && (is_same_v<T,uint64_t> || is_same_v<T,int64_t>), T> atomicISub(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T>
[[vk::ext_instruction(spv::OpAtomicAnd)]]
enable_if_t<is_same_v<T,uint32_t> || is_same_v<T,int32_t>, T> atomicAnd([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicAnd)]]
enable_if_t<is_pointer_v<Ptr_T> && (is_same_v<T,uint32_t> || is_same_v<T,int32_t>), T> atomicAnd(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T>
[[vk::ext_instruction(spv::OpAtomicOr)]]
enable_if_t<is_same_v<T,uint32_t> || is_same_v<T,int32_t>, T> atomicOr([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicOr)]]
enable_if_t<is_pointer_v<Ptr_T> && (is_same_v<T,uint32_t> || is_same_v<T,int32_t>), T> atomicOr(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T>
[[vk::ext_instruction(spv::OpAtomicXor)]]
enable_if_t<is_same_v<T,uint32_t> || is_same_v<T,int32_t>, T> atomicXor([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicXor)]]
enable_if_t<is_pointer_v<Ptr_T> && (is_same_v<T,uint32_t> || is_same_v<T,int32_t>), T> atomicXor(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename Signed>
[[vk::ext_instruction( spv::OpAtomicSMin )]]
enable_if_t<is_same_v<Signed,int32_t>, Signed> atomicSMin([[vk::ext_reference]] int32_t ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value);

template<typename Signed, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicSMin)]]
enable_if_t<is_pointer_v<Ptr_T> && is_same_v<Signed,int32_t>, Signed> atomicSMin(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value);

template<typename Unsigned>
[[vk::ext_instruction( spv::OpAtomicUMin )]]
enable_if_t<is_same_v<Unsigned,uint32_t>, Unsigned> atomicUMin([[vk::ext_reference]] Unsigned ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value);

template<typename Unsigned, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicUMin)]]
enable_if_t<is_pointer_v<Ptr_T> && is_same_v<Unsigned,uint32_t>, Unsigned> atomicUMin(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value);

template<typename Signed>
[[vk::ext_instruction( spv::OpAtomicSMax )]]
enable_if_t<is_same_v<Signed,int32_t>, Signed> atomicSMax([[vk::ext_reference]] Signed ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value);

template<typename Signed, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicSMax)]]
enable_if_t<is_pointer_v<Ptr_T> && is_same_v<Signed,int32_t>, Signed> atomicSMax(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value);

template<typename Unsigned>
[[vk::ext_instruction( spv::OpAtomicUMax )]]
enable_if_t<is_same_v<Unsigned,uint32_t>, Unsigned> atomicUMax([[vk::ext_reference]] uint32_t ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value);

template<typename Unsigned, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicUMax)]]
enable_if_t<is_pointer_v<Ptr_T> && is_same_v<Unsigned,uint32_t>, Unsigned> atomicUMax(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value);

template<typename T>
[[vk::ext_instruction(spv::OpAtomicExchange)]]
T atomicExchange([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicExchange)]]
enable_if_t<is_pointer_v<Ptr_T>, T> atomicExchange(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);

template<typename T>
[[vk::ext_instruction(spv::OpAtomicCompareExchange)]]
T atomicCompareExchange([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memSemanticsEqual, uint32_t memSemanticsUnequal, T value, T comparator);

template<typename T, typename Ptr_T> // DXC Workaround
[[vk::ext_instruction(spv::OpAtomicCompareExchange)]]
enable_if_t<is_pointer_v<Ptr_T>, T> atomicCompareExchange(Ptr_T ptr, uint32_t memoryScope, uint32_t memSemanticsEqual, uint32_t memSemanticsUnequal, T value, T comparator);

template<typename T, uint32_t alignment>
[[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] [[vk::ext_extension("SPV_KHR_physical_storage_buffer")]]
[[vk::ext_instruction(spv::OpLoad)]]
T load(bda_pointer_t<T> pointer, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment);

template<typename T, typename P>
[[vk::ext_instruction(spv::OpLoad)]]
enable_if_t<is_pointer_v,T> load(P pointer);

template<typename T, uint32_t alignment>
[[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] [[vk::ext_extension("SPV_KHR_physical_storage_buffer")]]
[[vk::ext_instruction(spv::OpStore)]]
void store(bda_pointer_t<T> pointer, T obj, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment);

template<typename T, typename P>
[[vk::ext_instruction(spv::OpStore)]]
enable_if_t<is_pointer_v,void> store(P pointer, T obj);

// Memory Semantics link here: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#Memory_Semantics_-id-

// https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_memory_semantics_id
// By providing memory semantics None we do both control and memory barrier as is done in GLSL

[[vk::ext_instruction( spv::OpControlBarrier )]]
void controlBarrier(uint32_t executionScope, uint32_t memoryScope, uint32_t memorySemantics);

[[vk::ext_instruction( spv::OpMemoryBarrier )]]
void memoryBarrier(uint32_t memoryScope, uint32_t memorySemantics);

// Add specializations if you need to emit a `ext_capability` (this means that the instruction needs to forward through an `impl::` struct and so on)
// TODO: better constraints, one should only be able to cast fundamental types, etc. https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpBitcast
#line 292 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
template<class T, class U>
[[vk::ext_instruction(spv::OpBitcast)]]
T bitcast(U);

template<typename Integral>
[[vk::ext_instruction( spv::OpBitFieldUExtract )]]
enable_if_t<is_integral_v<Integral>, Integral> bitFieldUExtract( Integral val, uint32_t offsetBits, uint32_t numBits );

template<typename Integral>
[[vk::ext_instruction( spv::OpBitFieldSExtract )]]
enable_if_t<is_integral_v<Integral>, Integral> bitFieldSExtract( Integral val, uint32_t offsetBits, uint32_t numBits );

template<typename Integral>
[[vk::ext_instruction( spv::OpBitFieldInsert )]]
enable_if_t<is_integral_v<Integral>, Integral> bitFieldInsert( Integral base, Integral insert, uint32_t offset, uint32_t count );

template<typename Integral>
[[vk::ext_instruction( spv::OpBitReverse )]]
enable_if_t<is_integral_v<Integral>, Integral> bitReverse( Integral base );

template<typename T ,::nbl::hlsl::enable_if_t<(is_floating_point_v<T> && is_scalar_v<T>),bool> = true>
[[vk::ext_instruction( spv::OpIsNan )]]
bool isNan(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(is_floating_point_v<T> && is_scalar_v<T>),bool> = true>
[[vk::ext_instruction( spv::OpIsInf )]]
bool isInf(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(is_floating_point_v<T> && is_vector_v<T>),bool> = true>
[[vk::ext_instruction(spv::OpIsNan)]]
vector<bool, vector_traits<T>::Dimension> isNan(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(is_floating_point_v<T> && is_vector_v<T>),bool> = true>
[[vk::ext_instruction(spv::OpIsInf)]]
vector<bool, vector_traits<T>::Dimension> isInf(T val);

template<typename Matrix>
[[vk::ext_instruction( spv::OpTranspose )]]
Matrix transpose(Matrix mat);

template<typename Integral>
[[vk::ext_instruction(spv::OpBitCount)]]
enable_if_t<is_integral_v<Integral>, Integral> bitCount(Integral mat);

template<typename BooleanVector>
[[vk::ext_instruction(spv::OpAll)]]
enable_if_t<is_vector_v<BooleanVector> && is_same_v<typename vector_traits<BooleanVector>::scalar_type, bool>, BooleanVector> all(BooleanVector vec);

template<typename BooleanVector>
[[vk::ext_instruction(spv::OpAny)]]
enable_if_t<is_vector_v<BooleanVector>&& is_same_v<typename vector_traits<BooleanVector>::scalar_type, bool>, BooleanVector> any(BooleanVector vec);

// If Condition is a vector, ResultType must be a vector with the same number of components. Using (p -> q) = (~p v q)
template<typename Condition, typename ResultType ,::nbl::hlsl::enable_if_t<(concepts::Boolean<Condition> && (! concepts::Vector<Condition> || (concepts::Vector<ResultType> && (extent_v<Condition> == extent_v<ResultType>)))),bool> = true>
[[vk::ext_instruction(spv::OpSelect)]]
ResultType select(Condition condition, ResultType object1, ResultType object2);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegral<T>),bool> = true>
[[vk::ext_instruction(spv::OpIAddCarry)]]
AddCarryOutput<T> addCarry(T operand1, T operand2);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegral<T>),bool> = true>
[[vk::ext_instruction(spv::OpISubBorrow)]]
SubBorrowOutput<T> subBorrow(T operand1, T operand2);

}

}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/output_structs.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 11 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/output_structs.hlsl"
namespace nbl
{
namespace hlsl
{

template<typename T ,typename __requires=void>
struct ModfOutput;

template<typename T> 
struct ModfOutput<T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPoint<T>),void> >
{
	T fractionalPart;
	T wholeNumberPart;
};

template<typename T ,typename __requires=void>
struct FrexpOutput;

template<typename T> 
struct FrexpOutput<T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointScalar<T>),void> >
{
	T significand;
	int exponent;
};

template<typename T> 
struct FrexpOutput<T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVector<T>),void> >
{
	T significand;
	vector<int, vector_traits<T>::Dimension> exponent;
};

}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/3rdparty/dxc/dxc/external/SPIRV-Headers/include/spirv/unified1/GLSL.std.450.h"
/*
** Copyright (c) 2014-2024 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and/or associated documentation files (the "Materials"),
** to deal in the Materials without restriction, including without limitation
** the rights to use, copy, modify, merge, publish, distribute, sublicense,
** and/or sell copies of the Materials, and to permit persons to whom the
** Materials are furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in
** all copies or substantial portions of the Materials.
**
** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
** IN THE MATERIALS.
*/

#line 30 "C:/Users/fjlet/Desktop/Nabla/3rdparty/dxc/dxc/external/SPIRV-Headers/include/spirv/unified1/GLSL.std.450.h"
static const int GLSLstd450Version = 100;
static const int GLSLstd450Revision = 3;

enum GLSLstd450 {
    GLSLstd450Bad = 0,              // Don't use

GLSLstd450Round = 1,
    GLSLstd450RoundEven = 2,
    GLSLstd450Trunc = 3,
    GLSLstd450FAbs = 4,
    GLSLstd450SAbs = 5,
    GLSLstd450FSign = 6,
    GLSLstd450SSign = 7,
    GLSLstd450Floor = 8,
    GLSLstd450Ceil = 9,
    GLSLstd450Fract = 10,

GLSLstd450Radians = 11,
    GLSLstd450Degrees = 12,
    GLSLstd450Sin = 13,
    GLSLstd450Cos = 14,
    GLSLstd450Tan = 15,
    GLSLstd450Asin = 16,
    GLSLstd450Acos = 17,
    GLSLstd450Atan = 18,
    GLSLstd450Sinh = 19,
    GLSLstd450Cosh = 20,
    GLSLstd450Tanh = 21,
    GLSLstd450Asinh = 22,
    GLSLstd450Acosh = 23,
    GLSLstd450Atanh = 24,
    GLSLstd450Atan2 = 25,

GLSLstd450Pow = 26,
    GLSLstd450Exp = 27,
    GLSLstd450Log = 28,
    GLSLstd450Exp2 = 29,
    GLSLstd450Log2 = 30,
    GLSLstd450Sqrt = 31,
    GLSLstd450InverseSqrt = 32,

GLSLstd450Determinant = 33,
    GLSLstd450MatrixInverse = 34,

GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
    GLSLstd450ModfStruct = 36,      // no OpVariable operand
    GLSLstd450FMin = 37,
    GLSLstd450UMin = 38,
    GLSLstd450SMin = 39,
    GLSLstd450FMax = 40,
    GLSLstd450UMax = 41,
    GLSLstd450SMax = 42,
    GLSLstd450FClamp = 43,
    GLSLstd450UClamp = 44,
    GLSLstd450SClamp = 45,
    GLSLstd450FMix = 46,
    GLSLstd450IMix = 47,            // Reserved
    GLSLstd450Step = 48,
    GLSLstd450SmoothStep = 49,

GLSLstd450Fma = 50,
    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
    GLSLstd450Ldexp = 53,

GLSLstd450PackSnorm4x8 = 54,
    GLSLstd450PackUnorm4x8 = 55,
    GLSLstd450PackSnorm2x16 = 56,
    GLSLstd450PackUnorm2x16 = 57,
    GLSLstd450PackHalf2x16 = 58,
    GLSLstd450PackDouble2x32 = 59,
    GLSLstd450UnpackSnorm2x16 = 60,
    GLSLstd450UnpackUnorm2x16 = 61,
    GLSLstd450UnpackHalf2x16 = 62,
    GLSLstd450UnpackSnorm4x8 = 63,
    GLSLstd450UnpackUnorm4x8 = 64,
    GLSLstd450UnpackDouble2x32 = 65,

GLSLstd450Length = 66,
    GLSLstd450Distance = 67,
    GLSLstd450Cross = 68,
    GLSLstd450Normalize = 69,
    GLSLstd450FaceForward = 70,
    GLSLstd450Reflect = 71,
    GLSLstd450Refract = 72,

GLSLstd450FindILsb = 73,
    GLSLstd450FindSMsb = 74,
    GLSLstd450FindUMsb = 75,

GLSLstd450InterpolateAtCentroid = 76,
    GLSLstd450InterpolateAtSample = 77,
    GLSLstd450InterpolateAtOffset = 78,

GLSLstd450NMin = 79,
    GLSLstd450NMax = 80,
    GLSLstd450NClamp = 81,

GLSLstd450Count
};

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/glsl.std.450.hlsl"
namespace nbl
{
namespace hlsl
{
namespace spirv
{

namespace concepts
{
// scalar or vector whose component type is floating-point.
template<typename T>
const static bool FloatingPointVectorOrScalar = is_floating_point_v<T> && (!is_matrix_v<T>);
// scalar or vector whose component type is 16-bit or 32-bit floating-point.
template<typename T>
const static bool FloatingPointVectorOrScalar32or16BitSize = FloatingPointVectorOrScalar<T> && (sizeof(typename vector_traits<T>::scalar_type) == 4 || sizeof(typename vector_traits<T>::scalar_type) == 2);
//is interpreted as signed
//integer scalar or integer vector types
template<typename T>
const static bool IntegralVectorOrScalar = is_integral_v<T> && is_signed_v<T> && !is_matrix_v<T>;
//interpreted as unsigned
//integer scalar or integer vector types
template<typename T>
const static bool UnsignedIntegralVectorOrScalar = is_integral_v<T> && is_unsigned_v<T> && !is_matrix_v<T>;
//be signed integer scalar or signed integer vector types
//This instruction is currently limited to 32 - bit width components.
template<typename T>
const static bool IntegralVectorOrScalar32BitSize = IntegralVectorOrScalar<T> && (sizeof(typename vector_traits<T>::scalar_type) == 4);
//be unsigned integer scalar or unsigned integer vector types
//This instruction is currently limited to 32 - bit width components.
template<typename T>
const static bool UnsignedIntegralVectorOrScalar32BitSize = UnsignedIntegralVectorOrScalar<T> && (sizeof(typename vector_traits<T>::scalar_type) == 4);
}

// Find MSB and LSB restricted to 32-bit width component types https://registry.khronos.org/SPIR-V/specs/unified1/GLSL.std.450.html
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::IntegralVectorOrScalar32BitSize<T> || concepts::UnsignedIntegralVectorOrScalar32BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450FindILsb, "GLSL.std.450")]]
conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t> findILsb(T value);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::IntegralVectorOrScalar32BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450FindSMsb, "GLSL.std.450")]]
conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t> findSMsb(T value);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegralVectorOrScalar32BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450FindUMsb, "GLSL.std.450")]]
conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t> findUMsb(T value);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Pow, "GLSL.std.450")]]
T pow(T lhs, T rhs);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Exp, "GLSL.std.450")]]
T exp(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Exp2, "GLSL.std.450")]]
T exp2(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Log, "GLSL.std.450")]]
T log(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Log2, "GLSL.std.450")]]
T log2(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Sqrt, "GLSL.std.450")]]
T sqrt(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450InverseSqrt, "GLSL.std.450")]]
T inverseSqrt(T val);
 
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Floor, "GLSL.std.450")]]
T floor(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T> && is_vector_v<T> && (vector_traits<T>::Dimension == 3)),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Cross, "GLSL.std.450")]]
T cross(const in T lhs, const in T rhs);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450FMix, "GLSL.std.450")]]
T fMix(T x, T y, T a);

template<typename SquareMatrix ,::nbl::hlsl::enable_if_t<(matrix_traits<SquareMatrix>::Square),bool> = true>
[[vk::ext_instruction(GLSLstd450::GLSLstd450Determinant, "GLSL.std.450")]]
typename matrix_traits<SquareMatrix>::scalar_type determinant(const in SquareMatrix mat);

template<typename SquareMatrix ,::nbl::hlsl::enable_if_t<(matrix_traits<SquareMatrix>::Square),bool> = true>
[[vk::ext_instruction(GLSLstd450MatrixInverse, "GLSL.std.450")]]
SquareMatrix matrixInverse(const in SquareMatrix mat);

[[vk::ext_instruction(GLSLstd450UnpackSnorm2x16, "GLSL.std.450")]]
float32_t2 unpackSnorm2x16(uint32_t p);

[[vk::ext_instruction(GLSLstd450UnpackSnorm4x8, "GLSL.std.450")]]
float32_t4 unpackSnorm4x8(uint32_t p);

[[vk::ext_instruction(GLSLstd450UnpackUnorm4x8, "GLSL.std.450")]]
float32_t4 unpackUnorm4x8(uint32_t p);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Length, "GLSL.std.450")]]
typename vector_traits<T>::scalar_type length(T vec);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Normalize, "GLSL.std.450")]]
T normalize(T vec);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450FClamp, "GLSL.std.450")]]
T fClamp(T val, T _min, T _max);
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450UClamp, "GLSL.std.450")]]
T uClamp(T val, T _min, T _max);
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::IntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450SClamp, "GLSL.std.450")]]
T sClamp(T val, T _min, T _max);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450FMin, "GLSL.std.450")]]
T fMin(T a, T b);
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450UMin, "GLSL.std.450")]]
T uMin(T a, T b);
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::IntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450SMin, "GLSL.std.450")]]
T sMin(T a, T b);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450FMax, "GLSL.std.450")]]
T fMax(T a, T b);
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450UMax, "GLSL.std.450")]]
T uMax(T a, T b);
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::IntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450SMax, "GLSL.std.450")]]
T sMax(T a, T b);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450FAbs, "GLSL.std.450")]]
T fAbs(T val);
template<typename T ,::nbl::hlsl::enable_if_t<(concepts::IntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450SAbs, "GLSL.std.450")]]
T sAbs(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Sin, "GLSL.std.450")]]
T sin(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Cos, "GLSL.std.450")]]
T cos(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Acos, "GLSL.std.450")]]
T acos(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Tan, "GLSL.std.450")]]
T tan(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Asin, "GLSL.std.450")]]
T asin(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Atan, "GLSL.std.450")]]
T atan(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Sinh, "GLSL.std.450")]]
T sinh(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Cosh, "GLSL.std.450")]]
T cosh(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Tanh, "GLSL.std.450")]]
T tanh(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Asinh, "GLSL.std.450")]]
T asinh(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Acosh, "GLSL.std.450")]]
T acosh(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Atanh, "GLSL.std.450")]]
T atanh(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Atan2, "GLSL.std.450")]]
T atan2(T y, T x);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Fract, "GLSL.std.450")]]
T fract(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Round, "GLSL.std.450")]]
T round(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450RoundEven, "GLSL.std.450")]]
T roundEven(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Trunc, "GLSL.std.450")]]
T trunc(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Ceil, "GLSL.std.450")]]
T ceil(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Fma, "GLSL.std.450")]]
T fma(T x, T y, T z);

template<typename T, typename U ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T> && (concepts::IntegralVectorOrScalar || concepts::UnsignedIntegralVectorOrScalar) && (vector_traits<T>::Dimension == vector_traits::Dimension)),bool> = true>
#line 239 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/glsl.std.450.hlsl"
[[vk::ext_instruction(GLSLstd450Ldexp, "GLSL.std.450")]]
T ldexp(T arg, U exp);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450FSign, "GLSL.std.450")]]
T fSign(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::IntegralVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450SSign, "GLSL.std.450")]]
T sSign(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Radians, "GLSL.std.450")]]
T radians(T degrees);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar32or16BitSize<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Degrees, "GLSL.std.450")]]
T degrees(T radians);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Step, "GLSL.std.450")]]
T step(T edge, T x);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450SmoothStep, "GLSL.std.450")]]
T smoothStep(T edge0, T edge1, T x);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450FaceForward, "GLSL.std.450")]]
T faceForward(T N, T I, T Nref);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Reflect, "GLSL.std.450")]]
T reflect(T I, T N);

template<typename T, typename U ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450Refract, "GLSL.std.450")]]
T refract(T I, T N, U Nref);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450ModfStruct, "GLSL.std.450")]]
ModfOutput<T> modfStruct(T val);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450FrexpStruct, "GLSL.std.450")]]
FrexpOutput<T> frexpStruct(T val);

[[vk::ext_instruction(GLSLstd450PackSnorm4x8, "GLSL.std.450")]]
int32_t packSnorm4x8(float32_t4 vec);

[[vk::ext_instruction(GLSLstd450PackUnorm4x8, "GLSL.std.450")]]
int32_t packUnorm4x8(float32_t4 vec);

[[vk::ext_instruction(GLSLstd450PackSnorm2x16, "GLSL.std.450")]]
int32_t packSnorm2x16(float32_t2 vec);

[[vk::ext_instruction(GLSLstd450PackUnorm2x16, "GLSL.std.450")]]
int32_t packUnorm2x16(float32_t2 vec);

[[vk::ext_instruction(GLSLstd450PackHalf2x16, "GLSL.std.450")]]
int32_t packHalf2x16(float32_t2 vec);

[[vk::ext_instruction(GLSLstd450PackDouble2x32, "GLSL.std.450")]]
float64_t packDouble2x32(int32_t2 vec);

[[vk::ext_instruction(GLSLstd450UnpackSnorm2x16, "GLSL.std.450")]]
float32_t2 unpackSnorm2x16(int32_t vec);

[[vk::ext_instruction(GLSLstd450UnpackUnorm2x16, "GLSL.std.450")]]
float32_t2 unpackUnorm2x16(int32_t vec);

[[vk::ext_instruction(GLSLstd450UnpackHalf2x16, "GLSL.std.450")]]
float32_t2 unpackHalf2x16(int32_t vec);

[[vk::ext_instruction(GLSLstd450UnpackSnorm4x8, "GLSL.std.450")]]
float32_t4 unpackSnorm4x8(int32_t vec);

[[vk::ext_instruction(GLSLstd450UnpackUnorm4x8, "GLSL.std.450")]]
float32_t4 unpackUnorm4x8(int32_t vec);

[[vk::ext_instruction(GLSLstd450UnpackDouble2x32, "GLSL.std.450")]]
int32_t2 unpackDouble2x32(float64_t vec);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450NMax, "GLSL.std.450")]]
T nMax(T a, T b);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450NMin, "GLSL.std.450")]]
T nMin(T a, T b);

template<typename T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVectorOrScalar<T>),bool> = true>
[[vk::ext_instruction(GLSLstd450NClamp, "GLSL.std.450")]]
T nClamp(T val, T _min, T _max);

}
}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/glsl_compat/core.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/glsl_compat/core.hlsl"
namespace nbl 
{
namespace hlsl
{
namespace glsl
{

#line 41 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/glsl_compat/core.hlsl"
/**
* Generic SPIR-V
*/

// Fun fact: ideally atomics should detect the address space of `ptr` and narrow down the sync-scope properly
// https://github.com/microsoft/DirectXShaderCompiler/issues/6508
// Would need own meta-type/tagged-type to implement, without & and fancy operator overloads... not posssible
// TODO: we can template on `StorageClass` instead of Ptr_T then resolve the memory scope and semantics properly
template<typename T>
T atomicAdd([[vk::ext_reference]] inout T ptr, T value)
{
 return spirv::atomicIAdd<T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T, typename Ptr_T> // DXC Workaround
enable_if_t<spirv::is_pointer_v<Ptr_T>, T> atomicAdd(Ptr_T ptr, T value)
{
 return spirv::atomicIAdd<T, Ptr_T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T>
T atomicSub([[vk::ext_reference]] inout T ptr, T value)
{
 return spirv::atomicISub<T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T, typename Ptr_T> // DXC Workaround
enable_if_t<spirv::is_pointer_v<Ptr_T>, T> atomicSub(Ptr_T ptr, T value)
{
 return spirv::atomicISub<T, Ptr_T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T>
T atomicAnd([[vk::ext_reference]] inout T ptr, T value)
{
 return spirv::atomicAnd<T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T, typename Ptr_T> // DXC Workaround
enable_if_t<spirv::is_pointer_v<Ptr_T>, T> atomicAnd(Ptr_T ptr, T value)
{
 return spirv::atomicAnd<T, Ptr_T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T>
T atomicOr([[vk::ext_reference]] inout T ptr, T value)
{
 return spirv::atomicOr<T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T, typename Ptr_T> // DXC Workaround
enable_if_t<spirv::is_pointer_v<Ptr_T>, T> atomicOr(Ptr_T ptr, T value)
{
 return spirv::atomicOr<T, Ptr_T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T>
T atomicXor([[vk::ext_reference]] inout T ptr, T value)
{
 return spirv::atomicXor<T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T, typename Ptr_T> // DXC Workaround
enable_if_t<spirv::is_pointer_v<Ptr_T>, T> atomicXor(Ptr_T ptr, T value)
{
 return spirv::atomicXor<T, Ptr_T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
/* TODO: @Hazardu struct dispatchers like for `bitfieldExtract`
template<typename T>
T atomicMin(NBL_REF_ARG(T) ptr, T value)
{
}
template<typename T>
T atomicMax(NBL_REF_ARG(T) ptr, T value)
{
}
*/
template<typename T>
T atomicExchange([[vk::ext_reference]] inout T ptr, T value)
{
 return spirv::atomicExchange<T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T, typename Ptr_T> // DXC Workaround
enable_if_t<spirv::is_pointer_v<Ptr_T>, T> atomicExchange(Ptr_T ptr, T value)
{
 return spirv::atomicExchange<T, Ptr_T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, value);
}
template<typename T>
T atomicCompSwap([[vk::ext_reference]] inout T ptr, T comparator, T value)
{
 return spirv::atomicCompareExchange<T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, spv::MemorySemanticsMaskNone, value, comparator);
}
template<typename T, typename Ptr_T> // DXC Workaround
enable_if_t<spirv::is_pointer_v<Ptr_T>, T> atomicCompSwap(Ptr_T ptr, T comparator, T value)
{
 return spirv::atomicCompareExchange<T, Ptr_T>(ptr, spv::ScopeDevice, spv::MemorySemanticsMaskNone, spv::MemorySemanticsMaskNone, value, comparator);
}

/**
 * GLSL extended math
 */

template<typename SquareMatrix> // NBL_REQUIRES() extents are square
SquareMatrix inverse(const in SquareMatrix mat)
{
 return spirv::matrixInverse(mat);
}

float32_t2 unpackSnorm2x16(uint32_t p)
{
    return spirv::unpackSnorm2x16(p);
}

/**
 * For Vertex Shaders
 */
 // TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `&` :(
//void gl_Position() {spirv::}
uint32_t gl_VertexIndex() {return spirv::VertexIndex;}
uint32_t gl_InstanceIndex() {return spirv::InstanceIndex;}

/**
 * For Compute Shaders
 */

// TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `const&` :(
uint32_t3 gl_NumWorkGroups() {return spirv::NumWorkGroups;}
// TODO: DXC BUG prevents us from defining this!
uint32_t3 gl_WorkGroupSize();
uint32_t3 gl_WorkGroupID() {return spirv::WorkgroupId;}
uint32_t3 gl_LocalInvocationID() {return spirv::LocalInvocationId;}
uint32_t3 gl_GlobalInvocationID() {return spirv::GlobalInvocationId;}
uint32_t gl_LocalInvocationIndex() {return spirv::LocalInvocationIndex;}

void barrier() {
    spirv::controlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
}

/**
 * For Tessellation Control Shaders
 */
void tess_ctrl_barrier() {
    spirv::controlBarrier(spv::ScopeWorkgroup, spv::ScopeInvocation, 0);
}

void memoryBarrierShared() {
    spirv::memoryBarrier(spv::ScopeDevice, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
}

namespace impl 
{

template<typename T, bool isSigned, bool isIntegral>
struct bitfieldExtract {};

template<typename T, bool isSigned>
struct bitfieldExtract<T, isSigned, false>
{
 static T __call( T val, uint32_t offsetBits, uint32_t numBits )
 {
 _Static_assert( is_integral<T>::value, "T is not an integral type!" );
 return val;
 }
};

template<typename T>
struct bitfieldExtract<T, true, true>
{
 static T __call( T val, uint32_t offsetBits, uint32_t numBits )
 {
 return spirv::bitFieldSExtract<T>( val, offsetBits, numBits );
 }
};

template<typename T>
struct bitfieldExtract<T, false, true>
{
 static T __call( T val, uint32_t offsetBits, uint32_t numBits )
 {
 return spirv::bitFieldUExtract<T>( val, offsetBits, numBits );
 } 
};

} //namespace impl

template<typename T>
T bitfieldExtract( T val, uint32_t offsetBits, uint32_t numBits )
{
 return impl::bitfieldExtract<T, is_signed<T>::value, is_integral<T>::value>::__call(val,offsetBits,numBits);
}

template<typename T>
T bitfieldInsert(T base, T insert, uint32_t offset, uint32_t bits)
{
 return spirv::bitFieldInsert<T>(base, insert, offset, bits);
}

template<typename T>
T bitfieldReverse(T value)
{
 return spirv::bitReverse<T>(value);
}

}
}
}

#line 29 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/bit.hlsl"
namespace nbl
{
namespace hlsl
{

#line 54 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/bit.hlsl"
template<class T, class U>
enable_if_t<sizeof(T)==sizeof(U),T> bit_cast(U val)
{
 return spirv::bitcast<T,U>(val);
}

template<typename T, typename S>
T rotl(T x, S s);
template<typename T, typename S>
T rotr(T x, S s);

template<typename T, typename S>
T rotl(T x, S s)
{
 const T N = 32u;
 const S r = s % N;
 
 if(r >= 0)
 {
 return (x << r) | (x >> (N - r));
 }
 else
 {
 return (x >> (-r)) | (x << (N - (-r)));
 }
}

template<typename T, typename S>
T rotr(T x, S s)
{
 const T N = 32u;
 const S r = s % N;
 
 if(r >= 0)
 {
 return (x >> r) | (x << (N - r));
 }
 else
 {
 return (x << (-r)) | (x >> (N - (-r)));
 }
}

namespace impl
{
template<uint16_t bits>
uint16_t clz(uint64_t N)
{
 static const uint64_t SHIFT = bits>>1;
 static const uint64_t LO_MASK = (1ull<<SHIFT)-1;
 const bool CHOOSE_HIGH = N & (LO_MASK<<SHIFT);
 const uint64_t NEXT = (CHOOSE_HIGH ? (N>>SHIFT):N)&LO_MASK;
 const uint16_t value = uint16_t(clz<SHIFT>(NEXT) + (CHOOSE_HIGH ? 0:SHIFT));
 return value;
}

template<>
uint16_t clz<1>(uint64_t N) { return uint16_t(1u-N&1); }

} //namespace impl

template<typename T>
uint16_t countl_zero(T n)
{
 return impl::clz<sizeof(T)*8>(n);
}

}
}

#line 8 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/ieee754/impl.hlsl"
namespace nbl
{
namespace hlsl
{
namespace ieee754
{

namespace impl
{
template <typename T>
inline unsigned_integer_of_size_t<sizeof(T)> bitCastToUintType(T x)
{
	using AsUint = unsigned_integer_of_size_t<sizeof(T)>;
	return bit_cast<AsUint, T>(x);
}
// to avoid bit cast from uintN_t to uintN_t
template <> inline unsigned_integer_of_size_t<2> bitCastToUintType(uint16_t x) { return x; }
template <> inline unsigned_integer_of_size_t<4> bitCastToUintType(uint32_t x) { return x; }
template <> inline unsigned_integer_of_size_t<8> bitCastToUintType(uint64_t x) { return x; }

template <typename T>
inline T castBackToFloatType(T x)
{
	using AsFloat = typename float_of_size<sizeof(T)>::type;
	return bit_cast<AsFloat, T>(x);
}
template<> inline uint16_t castBackToFloatType(uint16_t x) { return x; }
template<> inline uint32_t castBackToFloatType(uint32_t x) { return x; }
template<> inline uint64_t castBackToFloatType(uint64_t x) { return x; }
}

}
}
}

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/ieee754.hlsl"
namespace nbl
{
namespace hlsl
{
namespace ieee754
{

template<typename Float>
struct traits_base
{
	_Static_assert(is_same<Float, float16_t>::value || is_same<Float, float32_t>::value || is_same<Float, float64_t>::value);
	const static int16_t exponentBitCnt = int16_t(0xbeef);
	const static int16_t mantissaBitCnt = int16_t(0xbeef);
};

template<>
struct traits_base<float16_t>
{
	const static int16_t exponentBitCnt = 5;
	const static int16_t mantissaBitCnt = 10;
};

template<>
struct traits_base<float32_t>
{
	const static int16_t exponentBitCnt = 8;
	const static int16_t mantissaBitCnt = 23;
};

template<>
struct traits_base<float64_t>
{
	const static int16_t exponentBitCnt = 11;
	const static int16_t mantissaBitCnt = 52;
};

template<typename Float>
struct traits : traits_base<Float>
{
	//static_assert(is_same_v<Float, float16_t> || is_same_v<Float, float32_t> || is_same_v<Float, float64_t>);

using bit_rep_t = typename unsigned_integer_of_size<sizeof(Float)>::type;
	using base_t = traits_base<Float>;

const static bit_rep_t signMask = bit_rep_t(0x1ull) << (sizeof(Float) * 8 - 1);
	const static bit_rep_t exponentMask = ((~bit_rep_t(0)) << base_t::mantissaBitCnt) ^ signMask;
	const static bit_rep_t mantissaMask = (bit_rep_t(0x1u) << base_t::mantissaBitCnt) - 1;
	const static int exponentBias = (int(0x1) << (base_t::exponentBitCnt - 1)) - 1;
	const static bit_rep_t inf = exponentMask;
	const static bit_rep_t specialValueExp = (1ull << base_t::exponentBitCnt) - 1;
	const static bit_rep_t quietNaN = exponentMask | (1ull << (base_t::mantissaBitCnt - 1));
	const static bit_rep_t max = ((1ull << (sizeof(Float) * 8 - 1)) - 1) & (~(1ull << base_t::mantissaBitCnt));
	const static bit_rep_t min = 1ull << base_t::mantissaBitCnt;
	const static int exponentMax = exponentBias;
	const static int exponentMin = -(exponentBias - 1);
};

template <typename T>
inline uint32_t extractBiasedExponent(T x)
{
	using AsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
	return glsl::bitfieldExtract<AsUint>(ieee754::impl::bitCastToUintType(x), traits<typename float_of_size<sizeof(T)>::type>::mantissaBitCnt, traits<typename float_of_size<sizeof(T)>::type>::exponentBitCnt);
}

template<>
inline uint32_t extractBiasedExponent(uint64_t x)
{
	uint64_t output = (x >> traits<float64_t>::mantissaBitCnt) & (traits<float64_t>::exponentMask >> traits<float64_t>::mantissaBitCnt);
	return uint32_t(output);
}

template<>
inline uint32_t extractBiasedExponent(float64_t x)
{
	return extractBiasedExponent<uint64_t>(ieee754::impl::bitCastToUintType(x));
}

template <typename T>
inline int extractExponent(T x)
{
	using AsFloat = typename float_of_size<sizeof(T)>::type;
	return int(extractBiasedExponent(x)) - traits<AsFloat>::exponentBias;
}

template <typename T>
inline T replaceBiasedExponent(T x, typename unsigned_integer_of_size<sizeof(T)>::type biasedExp)
{
	using AsFloat = typename float_of_size<sizeof(T)>::type;
	return impl::castBackToFloatType<T>(glsl::bitfieldInsert(ieee754::impl::bitCastToUintType(x), biasedExp, traits<AsFloat>::mantissaBitCnt, traits<AsFloat>::exponentBitCnt));
}

// performs no overflow tests, returns x*exp2(n)
template <typename T>
inline T fastMulExp2(T x, int n)
{
	return replaceBiasedExponent(x, extractBiasedExponent(x) + uint32_t(n));
}

template <typename T>
inline typename unsigned_integer_of_size<sizeof(T)>::type extractMantissa(T x)
{
	using AsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
	return ieee754::impl::bitCastToUintType(x) & traits<typename float_of_size<sizeof(T)>::type>::mantissaMask;
}

template <typename T>
inline typename unsigned_integer_of_size<sizeof(T)>::type extractNormalizeMantissa(T x)
{
	using AsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
	using AsFloat = typename float_of_size<sizeof(T)>::type;
	return extractMantissa(x) | (AsUint(1) << traits<AsFloat>::mantissaBitCnt);
}

template <typename T>
inline typename unsigned_integer_of_size<sizeof(T)>::type extractSign(T x)
{
	using AsFloat = typename float_of_size<sizeof(T)>::type;
	return (ieee754::impl::bitCastToUintType(x) & traits<AsFloat>::signMask) >> ((sizeof(T) * 8) - 1);
}

template <typename T>
inline typename unsigned_integer_of_size<sizeof(T)>::type extractSignPreserveBitPattern(T x)
{
	using AsFloat = typename float_of_size<sizeof(T)>::type;
	return ieee754::impl::bitCastToUintType(x) & traits<AsFloat>::signMask;
}

template <typename FloatingPoint ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointLikeScalar<FloatingPoint>),bool> = true>
inline FloatingPoint copySign(FloatingPoint to, FloatingPoint from)
{
	using AsUint = typename unsigned_integer_of_size<sizeof(FloatingPoint)>::type;

const AsUint toAsUint = ieee754::impl::bitCastToUintType(to) & (~ieee754::traits<FloatingPoint>::signMask);
	const AsUint fromAsUint = ieee754::impl::bitCastToUintType(from);

return bit_cast<FloatingPoint>(toAsUint | extractSignPreserveBitPattern(from));
}

template <typename FloatingPoint ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointLikeScalar<FloatingPoint>),bool> = true>
inline FloatingPoint flipSign(FloatingPoint val, bool flip = true)
{
	using AsFloat = typename float_of_size<sizeof(FloatingPoint)>::type;
	using AsUint = typename unsigned_integer_of_size<sizeof(FloatingPoint)>::type;
	const AsUint asUint = ieee754::impl::bitCastToUintType(val);
	return bit_cast<FloatingPoint>(asUint ^ (flip ? ieee754::traits<AsFloat>::signMask : 0ull));
}

}
}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/matrix.hlsl"
// Copyright (C) 2024-2025 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 11 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/matrix.hlsl"
namespace nbl
{
namespace hlsl
{
namespace concepts
{

template<typename T>
const static bool Matrix = is_matrix<T>::value;

template<typename T>
const static bool Matricial = matrix_traits<T>::IsMatrix;

}
}
}

#line 6 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/promote.hlsl"
namespace nbl
{
namespace hlsl
{

namespace impl
{

// partial specialize this for `T=matrix<scalar_t,,>|vector<scalar_t,>` and `U=matrix<scalar_t,,>|vector<scalar_t,>|scalar_t`
template<typename T, typename U>
struct Promote
{
 inline T operator()(const in U v)
 {
 return T(v);
 }
};

template<typename Scalar, typename U>
struct Promote<vector <Scalar, 1>, U>
{
 inline enable_if_t<is_scalar<Scalar>::value && is_scalar::value, vector <Scalar, 1> > operator()(const in U v)
 {
 vector <Scalar, 1> promoted = {Scalar(v)};
 return promoted;
 }
};

template<typename Scalar, typename U>
struct Promote<vector <Scalar, 2>, U>
{
 inline enable_if_t<is_scalar<Scalar>::value && is_scalar::value, vector <Scalar, 2> > operator()(const in U v)
 {
 vector <Scalar, 2> promoted = {Scalar(v), Scalar(v)};
 return promoted;
 }
};

template<typename Scalar, typename U>
struct Promote<vector <Scalar, 3>, U>
{
 inline enable_if_t<is_scalar<Scalar>::value && is_scalar::value, vector <Scalar, 3> > operator()(const in U v)
 {
 vector <Scalar, 3> promoted = {Scalar(v), Scalar(v), Scalar(v)};
 return promoted;
 }
};

template<typename Scalar, typename U>
struct Promote<vector <Scalar, 4>, U>
{
 inline enable_if_t<is_scalar<Scalar>::value && is_scalar::value, vector <Scalar, 4> > operator()(const in U v)
 {
 vector <Scalar, 4> promoted = {Scalar(v), Scalar(v), Scalar(v), Scalar(v)};
 return promoted;
 }
};

}

template<typename T, typename U>
inline T promote(const U v) // TODO: use NBL_CONST_REF_ARG(U) instead of U v (circular ref)
{
 impl::Promote<T,U> _promote;
 return _promote(v);
}

}
}

#line 6 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/numbers.hlsl"
namespace nbl 
{
namespace hlsl
{
namespace numbers
{

template <typename float_t>
const static float_t e = float_t(2.718281828459045);
template <typename float_t>
const static float_t log2e = float_t(1.4426950408889634);
template <typename float_t>
const static float_t log10e = float_t(0.4342944819032518);
template <typename float_t>
const static float_t pi = float_t(3.141592653589793);
template <typename float_t>
const static float_t inv_pi = float_t(0.3183098861837907);
template <typename float_t>
const static float_t inv_sqrtpi = float_t(0.5641895835477563);
template <typename float_t>
const static float_t ln2 = float_t(0.6931471805599453);
template <typename float_t>
const static float_t ln10 = float_t(2.302585092994046);
template <typename float_t>
const static float_t sqrt2 = float_t(1.4142135623730951);
template <typename float_t>
const static float_t sqrt3 = float_t(1.7320508075688772);
template <typename float_t>
const static float_t inv_sqrt3 = float_t(0.5773502691896257);
template <typename float_t>
const static float_t egamma = float_t(0.5772156649015329);
template <typename float_t>
const static float_t phi = float_t(1.618033988749895);

}
}
}

#line 19 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl"
namespace nbl
{
namespace hlsl
{
namespace cpp_compat_intrinsics_impl
{

template<typename UnsignedInteger ,::nbl::hlsl::enable_if_t<(hlsl::is_integral_v<UnsignedInteger>&& hlsl::is_unsigned_v<UnsignedInteger>),bool> = true>
inline bool isnan_uint_impl(UnsignedInteger val)
{
	using AsFloat = typename float_of_size<sizeof(UnsignedInteger)>::type;
	const static UnsignedInteger Mask = (UnsignedInteger(0) - 1) >> 1;
	UnsignedInteger absVal = val & Mask;
	return absVal > (ieee754::traits<AsFloat>::specialValueExp << ieee754::traits<AsFloat>::mantissaBitCnt);
}

template<typename UnsignedInteger ,::nbl::hlsl::enable_if_t<(hlsl::is_integral_v<UnsignedInteger>&& hlsl::is_unsigned_v<UnsignedInteger>),bool> = true>
inline bool isinf_uint_impl(UnsignedInteger val)
{
	using AsFloat = typename float_of_size<sizeof(UnsignedInteger)>::type;
	return (val & (~ieee754::traits<AsFloat>::signMask)) == ieee754::traits<AsFloat>::inf;
}

template<typename T ,typename __requires=void>
struct dot_helper;
template<typename T ,typename __requires=void>
struct cross_helper;
template<typename T ,typename __requires=void>
struct clamp_helper;
template<typename Integer ,typename __requires=void>
struct find_msb_helper;
template<typename Integer ,typename __requires=void>
struct find_lsb_helper;
template<typename T ,typename __requires=void>
struct bitReverse_helper;
template<typename Matrix ,typename __requires=void>
struct transpose_helper;
template<typename Vector ,typename __requires=void>
struct length_helper;
template<typename Vector ,typename __requires=void>
struct normalize_helper;
template<typename T ,typename __requires=void>
struct max_helper;
template<typename T ,typename __requires=void>
struct min_helper;
template<typename Integer ,typename __requires=void>
struct bitCount_helper;
template<typename LhsT, typename RhsT ,typename __requires=void>
struct mul_helper;
template<typename T ,typename __requires=void>
struct determinant_helper;
template<typename T ,typename __requires=void>
struct inverse_helper;
template<typename T ,typename __requires=void>
struct rsqrt_helper;
template<typename T ,typename __requires=void>
struct all_helper;
template<typename T ,typename __requires=void>
struct any_helper;
template<typename B, typename T ,typename __requires=void>
struct select_helper;
template<typename T ,typename __requires=void>
struct bitReverseAs_helper;
template<typename T ,typename __requires=void>
struct fract_helper;
template<typename T, typename U ,typename __requires=void>
struct mix_helper;
template<typename T ,typename __requires=void>
struct sign_helper;
template<typename T ,typename __requires=void>
struct radians_helper;
template<typename T ,typename __requires=void>
struct degrees_helper;
template<typename T ,typename __requires=void>
struct step_helper;
template<typename T ,typename __requires=void>
struct smoothStep_helper;
template<typename T ,typename __requires=void>
struct faceForward_helper;
template<typename T ,typename __requires=void>
struct reflect_helper;
template<typename T, typename U ,typename __requires=void>
struct refract_helper;
template<typename T ,typename __requires=void>
struct nMin_helper;
template<typename T ,typename __requires=void>
struct nMax_helper;
template<typename T ,typename __requires=void>
struct nClamp_helper;
template<typename T ,typename __requires=void>
struct addCarry_helper;
template<typename T ,typename __requires=void>
struct subBorrow_helper;
template<typename T ,typename __requires=void>
struct undef_helper;

// it is crucial these partial specializations appear first because thats what makes the helpers match SPIR-V intrinsics first

#line 125 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl"
// the template<> needs to be written ourselves
// return type is __VA_ARGS__ to protect against `,` in templated return types

#line 139 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl"
template<typename T> struct find_msb_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: findUMsb< T >(experimental::declval< T>())), conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t> >),void> >{	using return_t = conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t>;	static inline return_t __call( const T arg0 )	{		return spirv:: findUMsb<T>( arg0 );	}};;
template<typename T> struct find_msb_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: findSMsb< T >(experimental::declval< T>())), conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t> >),void> >{	using return_t = conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t>;	static inline return_t __call( const T arg0 )	{		return spirv:: findSMsb<T>( arg0 );	}};
template<typename T> struct find_lsb_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: findILsb< T >(experimental::declval< T>())), conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t> >),void> >{	using return_t = conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t>;	static inline return_t __call( const T arg0 )	{		return spirv:: findILsb<T>( arg0 );	}};

template<typename T> struct bitReverse_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: bitReverse< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: bitReverse<T>( arg0 );	}};
template<typename T> struct transpose_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: transpose< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: transpose<T>( arg0 );	}};
template<typename T> struct length_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: length< T >(experimental::declval< T>())), typename vector_traits<T>::scalar_type >),void> >{	using return_t = typename vector_traits<T>::scalar_type;	static inline return_t __call( const T arg0 )	{		return spirv:: length<T>( arg0 );	}};
template<typename T> struct normalize_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: normalize< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: normalize<T>( arg0 );	}};
template<typename T> struct rsqrt_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: inverseSqrt< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: inverseSqrt<T>( arg0 );	}};
template<typename T> struct fract_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: fract< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: fract<T>( arg0 );	}};
template<typename T> struct all_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: all< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: all<T>( arg0 );	}};
template<typename T> struct any_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: any< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: any<T>( arg0 );	}};
template<typename B, typename T> struct select_helper(experimental::declval() , experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const B arg0 , const T arg1 , const T arg2 )	{		return spirv:: select( arg0 , arg1 , arg2 );	}};
template<typename T> struct sign_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: fSign< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: fSign<T>( arg0 );	}};
template<typename T> struct sign_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sSign< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: sSign<T>( arg0 );	}};
template<typename T> struct radians_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: radians< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: radians<T>( arg0 );	}};
template<typename T> struct degrees_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: degrees< T >(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: degrees<T>( arg0 );	}};
template<typename T> struct max_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: fMax< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: fMax<T>( arg0 , arg1 );	}};
template<typename T> struct max_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: uMax< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: uMax<T>( arg0 , arg1 );	}};
template<typename T> struct max_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sMax< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: sMax<T>( arg0 , arg1 );	}};
template<typename T> struct min_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: fMin< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: fMin<T>( arg0 , arg1 );	}};
template<typename T> struct min_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: uMin< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: uMin<T>( arg0 , arg1 );	}};
template<typename T> struct min_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sMin< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: sMin<T>( arg0 , arg1 );	}};
template<typename T> struct step_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: step< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: step<T>( arg0 , arg1 );	}};
template<typename T> struct reflect_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: reflect< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: reflect<T>( arg0 , arg1 );	}};
template<typename T> struct clamp_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: fClamp< T >(experimental::declval< T>() , experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 , const T arg2 )	{		return spirv:: fClamp<T>( arg0 , arg1 , arg2 );	}};
template<typename T> struct clamp_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: uClamp< T >(experimental::declval< T>() , experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 , const T arg2 )	{		return spirv:: uClamp<T>( arg0 , arg1 , arg2 );	}};
template<typename T> struct clamp_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sClamp< T >(experimental::declval< T>() , experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 , const T arg2 )	{		return spirv:: sClamp<T>( arg0 , arg1 , arg2 );	}};
template<typename T> struct smoothStep_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: smoothStep< T >(experimental::declval< T>() , experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 , const T arg2 )	{		return spirv:: smoothStep<T>( arg0 , arg1 , arg2 );	}};
template<typename T> struct faceForward_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: faceForward< T >(experimental::declval< T>() , experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 , const T arg2 )	{		return spirv:: faceForward<T>( arg0 , arg1 , arg2 );	}};
template<typename T, typename U> struct refract_helper<T , U ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: refract< T , U >(experimental::declval< T>() , experimental::declval< T>() , experimental::declval())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 , const U arg2 )	{		return spirv:: refract<T , U>( arg0 , arg1 , arg2 );	}};
template<typename T> struct nMax_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: nMax< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: nMax<T>( arg0 , arg1 );	}};
template<typename T> struct nMin_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: nMin< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: nMin<T>( arg0 , arg1 );	}};
template<typename T> struct nClamp_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: nClamp< T >(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: nClamp<T>( arg0 , arg1 );	}};
// Can use trivial case and not worry about restricting `T` with a concept since `spirv::AddCarryOutput / SubBorrowOutput` already take care of that
template<typename T> struct addCarry_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: addCarry< T >(experimental::declval< T>() , experimental::declval< T>())), spirv::AddCarryOutput<T> >),void> >{	using return_t = spirv::AddCarryOutput<T>;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: addCarry<T>( arg0 , arg1 );	}};
template<typename T> struct subBorrow_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: subBorrow< T >(experimental::declval< T>() , experimental::declval< T>())), spirv::SubBorrowOutput<T> >),void> >{	using return_t = spirv::SubBorrowOutput<T>;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: subBorrow<T>( arg0 , arg1 );	}};
template<typename T> struct undef_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: undef< T >()), T >),void> >{	using return_t = T;	static inline return_t __call( )	{		return spirv:: undef<T>( );	}};

#line 180 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl"
template<typename T> struct bitCount_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: bitCount< T >(experimental::declval< T>())), conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t> >),void> >{	using return_t = conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t>;	static inline return_t __call( const T arg0 )	{		return spirv:: bitCount<T>( arg0 );	}};

template<typename UInt64> 
struct find_msb_helper<UInt64 ,::nbl::hlsl::enable_if_t<(is_same_v<UInt64, uint64_t>),void> >
{
	using return_t = int32_t;
	static return_t __call(const in UInt64 val)
	{
		const uint32_t highBits = uint32_t(val >> 32);
		const int32_t highMsb = find_msb_helper<uint32_t>::__call(highBits);

if (highMsb == -1)
		{
			const uint32_t lowBits = uint32_t(val);
			const int32_t lowMsb = find_msb_helper<uint32_t>::__call(lowBits);
			if (lowMsb == -1)
				return -1;

return lowMsb;
		}

return highMsb + 32;
	}
};
template<typename UInt64> 
struct find_lsb_helper<UInt64 ,::nbl::hlsl::enable_if_t<(is_same_v<UInt64, uint64_t>),void> >
{
	static int32_t __call(const in uint64_t val)
	{
		const uint32_t lowBits = uint32_t(val);
		const int32_t lowLsb = find_lsb_helper<uint32_t>::__call(lowBits);

if (lowLsb == -1)
		{
			const uint32_t highBits = uint32_t(val >> 32);
			const int32_t highLsb = find_lsb_helper<uint32_t>::__call(highBits);
			if (highLsb == -1)
				return -1;
			else
				return 32 + highLsb;
		}

return lowLsb;
	}
};

template<typename SquareMatrix>

struct inverse_helper<SquareMatrix ,::nbl::hlsl::enable_if_t<(concepts::Matrix<SquareMatrix>&& matrix_traits<SquareMatrix>::Square),void> >
{
	static SquareMatrix __call(const in SquareMatrix mat)
	{
		return spirv::matrixInverse<SquareMatrix>(mat);
	}
};

template<typename T> 
struct mix_helper<T, T ,::nbl::hlsl::enable_if_t<(always_true<__decltype(spirv::fMix<T>(experimental::declval<T>(), experimental::declval<T>(), experimental::declval<T>()))>),void> >
{
	using return_t = conditional_t<is_vector_v<T>, vector<typename vector_traits<T>::scalar_type, vector_traits<T>::Dimension>, T>;
	static inline return_t __call(const T x, const T y, const T a)
	{
		return spirv::fMix<T>(x, y, a);
	}
};

template<typename T> 
struct mix_helper<T, bool ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointScalar<T>),void> >
{
	using return_t = conditional_t<is_vector_v<T>, vector<typename vector_traits<T>::scalar_type, vector_traits<T>::Dimension>, T>;
	static inline return_t __call(const T x, const T y, const bool a)
	{
		return a ? x : y;
	}
};

template<typename SquareMatrix> 
struct determinant_helper<SquareMatrix ,::nbl::hlsl::enable_if_t<(matrix_traits<SquareMatrix>::Square),void> >
{
	static typename matrix_traits<SquareMatrix>::scalar_type __call(const in SquareMatrix mat)
	{
		return spirv::determinant<SquareMatrix>(mat);
	}
};

template<typename T>

struct cross_helper<T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointVector<T> && (vector_traits<T>::Dimension == 3)),void> >
{
	static T __call(const in T lhs, const in T rhs)
	{
		return spirv::cross<T>(lhs, rhs);
	}
};

#line 683 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl"
// C++ and HLSL specializations

template<typename T>

struct bitReverseAs_helper<T ,::nbl::hlsl::enable_if_t<(concepts::UnsignedIntegralScalar<T>),void> >
{
	static T __call(const in T val, uint16_t bits)
	{
		return bitReverse_helper<T>::__call(val) >> promote<T, scalar_type_t<T> >(scalar_type_t <T>(sizeof(T) * 8 - bits));
	}
};

template<typename Vectorial>

struct dot_helper<Vectorial ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<Vectorial>),void> >
{
	using scalar_type = typename vector_traits<Vectorial>::scalar_type;

static inline scalar_type __call(const in Vectorial lhs, const in Vectorial rhs)
	{
		static const uint32_t ArrayDim = vector_traits<Vectorial>::Dimension;
		static array_get<Vectorial, scalar_type> getter;

scalar_type retval = getter(lhs, 0) * getter(rhs, 0);
		for (uint32_t i = 1; i < ArrayDim; ++i)
			retval = retval + getter(lhs, i) * getter(rhs, i);

return retval;
	}
};

// SPIR-V already defines specializations for builtin vector types

#line 721 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl"
template<typename T>

struct clamp_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = T;
	static return_t __call(const in T val, const in T min, const in T max)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<return_t, typename traits::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, clamp_helper<typename traits::scalar_type>::__call(getter(val, i), getter(min, i), getter(max, i)));

return output;
	}
};

template<typename T>

struct cross_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T> && concepts::Vectorial<T> && (vector_traits<T>::Dimension == 3)),void> >
{
	static T __call(const in T lhs, const in T rhs)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

T output;
		setter(output, 0, getter(lhs, 1) * getter(rhs, 2) - getter(rhs, 1) * getter(lhs, 2));
		setter(output, 1, getter(lhs, 2) * getter(rhs, 0) - getter(rhs, 2) * getter(lhs, 0));
		setter(output, 2, getter(lhs, 0) * getter(rhs, 1) - getter(rhs, 0) * getter(lhs, 1));

return output;
	}
};

template<typename T>

struct min_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	static T __call(const in T a, const in T b)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

T output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, min_helper<typename traits::scalar_type>::__call(getter(a, i), getter(b, i)));

return output;
	}
};
template<typename T>

struct max_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	static T __call(const in T a, const in T b)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

T output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, max_helper<typename traits::scalar_type>::__call(getter(a, i), getter(b, i)));

return output;
	}
};

template<typename LhsT, typename RhsT>

struct mul_helper<LhsT, RhsT ,::nbl::hlsl::enable_if_t<(concepts::Matrix<LhsT> && concepts::Vector<RhsT> && (matrix_traits<LhsT>::ColumnCount == vector_traits<RhsT>::Dimension)),void> >
{
	using lhs_traits = matrix_traits<LhsT>;
	using rhs_traits = vector_traits<RhsT>;
	using return_t = vector<typename lhs_traits::scalar_type, lhs_traits::RowCount>;
	static inline return_t __call(LhsT lhs, RhsT rhs)
	{
		return mul(lhs, rhs);
	}
};

template<typename LhsT, typename RhsT>

struct mul_helper<LhsT, RhsT ,::nbl::hlsl::enable_if_t<(concepts::Matrix<LhsT> && concepts::Matrix<RhsT> && (matrix_traits<LhsT>::ColumnCount == matrix_traits<RhsT>::RowCount)),void> >
{
	using lhs_traits = matrix_traits<LhsT>;
	using rhs_traits = matrix_traits<RhsT>;
	using return_t = matrix<typename lhs_traits::scalar_type, lhs_traits::RowCount, rhs_traits::ColumnCount>;
	static inline return_t __call(LhsT lhs, RhsT rhs)
	{
		return mul(lhs, rhs);
	}
};

#line 841 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl"
template<typename T>struct rsqrt_helper<T ,::nbl::hlsl::enable_if_t<( concepts::FloatingPointVectorial<T> && concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, rsqrt_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct bitReverse_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, bitReverse_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct fract_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, fract_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct sign_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, sign_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct degrees_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, degrees_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct radians_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, radians_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};

template<typename T>struct bitCount_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = vector<int32_t, hlsl::vector_traits<T>::Dimension>;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, bitCount_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct find_msb_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = vector<int32_t, hlsl::vector_traits<T>::Dimension>;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, find_msb_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct find_lsb_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = vector<int32_t, hlsl::vector_traits<T>::Dimension>;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, find_lsb_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct nMin_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, nMin_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct nMax_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, nMax_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};

template<typename T>

struct all_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>&& is_same_v<typename vector_traits<T>::scalar_type, bool>),void> >
{
	static bool __call(const in T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

bool output = true;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			output = output && getter(x, i);

return output;
	}
};

template<typename T>

struct any_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T> && is_same_v<typename vector_traits<T>::scalar_type, bool>),void> >
{
	static bool __call(const in T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

bool output = false;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			output = output || getter(x, i);

return output;
	}
};

template<typename T>

struct step_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = T;
	static return_t __call(const in T edge, const in T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<return_t, typename traits::scalar_type> setter;
		
		return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, step_helper<typename traits::scalar_type>::__call(getter(edge, i), getter(x, i)));
		
		return output;
	}
};

template<typename T>

struct smoothStep_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = T;
	static return_t __call(const in T edge0, const in T edge1, const in T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<return_t, typename traits::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, smoothStep_helper<typename traits::scalar_type>::__call(getter(edge0, i), getter(edge1, i), getter(x, i)));

return output;
	}
};

template<typename T>

struct mix_helper<T, T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = T;
	static return_t __call(const in T x, const in T y, const in T a)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<return_t, typename traits::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, mix_helper<typename traits::scalar_type, typename traits::scalar_type>::__call(getter(x, i), getter(y, i), getter(a, i)));

return output;
	}
};

template<typename T, typename U>

struct mix_helper<T, U ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && concepts::Boolean && vector_traits<T>::Dimension == vector_traits::Dimension),void> >
{
	using return_t = T;
	static return_t __call(const in T x, const in T y, const in U a)
	{
		using traitsT = hlsl::vector_traits<T>;
		using traitsU = hlsl::vector_traits;
		array_get<T, typename traitsT::scalar_type> getterT;
		array_get<U, typename traitsU::scalar_type> getterU;
		array_set<return_t, typename traitsT::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < traitsT::Dimension; ++i)
			setter(output, i, mix_helper<typename traitsT::scalar_type, typename traitsU::scalar_type>::__call(getterT(x, i), getterT(y, i), getterU(a, i)));

return output;
	}
};

}
}
}

#line 21 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl"
namespace nbl
{
namespace hlsl
{

template<typename T>
inline T undef()
{
	return cpp_compat_intrinsics_impl::undef_helper<T>::__call();
}

template<typename T>
inline typename cpp_compat_intrinsics_impl::bitCount_helper<T>::return_t bitCount(const in T val)
{
	return cpp_compat_intrinsics_impl::bitCount_helper<T>::__call(val);
}

template<typename T>
T cross(const in T lhs, const in T rhs)
{
	return cpp_compat_intrinsics_impl::cross_helper<T>::__call(lhs, rhs);
}

template<typename T>
typename cpp_compat_intrinsics_impl::clamp_helper<T>::return_t clamp(const in T val, const in T _min, const in T _max)
{
	return cpp_compat_intrinsics_impl::clamp_helper<T>::__call(val, _min, _max);
}

template<typename FloatingPointVectorial>
typename vector_traits<FloatingPointVectorial>::scalar_type length(const in FloatingPointVectorial vec)
{
	return cpp_compat_intrinsics_impl::length_helper<FloatingPointVectorial>::__call(vec);
}

template<typename FloatingPointVectorial>
FloatingPointVectorial normalize(const in FloatingPointVectorial vec)
{
	return cpp_compat_intrinsics_impl::normalize_helper<FloatingPointVectorial>::__call(vec);
}

template<typename Vectorial>
typename vector_traits<Vectorial>::scalar_type dot(const in Vectorial lhs, const in Vectorial rhs)
{
	return cpp_compat_intrinsics_impl::dot_helper<Vectorial>::__call(lhs, rhs);
}

// determinant not defined cause its implemented via hidden friend
// https://stackoverflow.com/questions/67459950/why-is-a-friend-function-not-treated-as-a-member-of-a-namespace-of-a-class-it-wa
template<typename Matrix ,::nbl::hlsl::enable_if_t<(concepts::Matricial<Matrix>),bool> = true>
inline typename matrix_traits<Matrix>::scalar_type determinant(const in Matrix mat)
{
	return cpp_compat_intrinsics_impl::determinant_helper<Matrix>::__call(mat);
}

template<typename T>
inline typename cpp_compat_intrinsics_impl::find_lsb_helper<T>::return_t findLSB(const in T val)
{
	return cpp_compat_intrinsics_impl::find_lsb_helper<T>::__call(val);
}

template<typename T>
inline typename cpp_compat_intrinsics_impl::find_msb_helper<T>::return_t findMSB(const in T val)
{
	return cpp_compat_intrinsics_impl::find_msb_helper<T>::__call(val);
}

// inverse not defined cause its implemented via hidden friend
template<typename Matrix ,::nbl::hlsl::enable_if_t<(concepts::Matricial<Matrix>),bool> = true>
inline Matrix inverse(const in Matrix mat)
{
	return cpp_compat_intrinsics_impl::inverse_helper<Matrix>::__call(mat);
}

// transpose not defined cause its implemented via hidden friend
template<typename Matrix ,::nbl::hlsl::enable_if_t<(concepts::Matricial<Matrix>),bool> = true>
inline typename matrix_traits<Matrix>::transposed_type transpose(const in Matrix m)
{
	return cpp_compat_intrinsics_impl::transpose_helper<Matrix>::__call(m);
}

template<typename LhsT, typename RhsT>
inline typename cpp_compat_intrinsics_impl::mul_helper<LhsT, RhsT>::return_t mul(LhsT lhs, RhsT rhs)
{
	return cpp_compat_intrinsics_impl::mul_helper<LhsT, RhsT>::__call(lhs, rhs);
}

template<typename T>
inline T min(const in T a, const in T b)
{
	return cpp_compat_intrinsics_impl::min_helper<T>::__call(a, b);
}

template<typename T>
inline T max(const in T a, const in T b)
{
	return cpp_compat_intrinsics_impl::max_helper<T>::__call(a, b);
}

template<typename FloatingPoint>
inline FloatingPoint rsqrt(FloatingPoint x)
{
	return cpp_compat_intrinsics_impl::rsqrt_helper<FloatingPoint>::__call(x);
}

template<typename Integer>
inline Integer bitReverse(Integer val)
{
	return cpp_compat_intrinsics_impl::bitReverse_helper<Integer>::__call(val);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_unsigned_v<T>),bool> = true>
/**
* @brief Takes the binary representation of `value` and returns a value of the same type resulting from reversing the string of bits as if it was `bits` long.
* Keep in mind `bits` cannot exceed `8 * sizeof(T)`.
*
* @tparam T type of the value to operate on.
*
* @param [in] value The value to bitreverse.
* @param [in] bits The length of the string of bits used to represent `value`.
*/
T bitReverseAs(T val, uint16_t bits)
{
	return cpp_compat_intrinsics_impl::bitReverseAs_helper<T>::__call(val, bits);
}

template<typename Vector>
inline bool all(Vector vec)
{
	return cpp_compat_intrinsics_impl::all_helper<Vector>::__call(vec);
}

template<typename Vector>
inline bool any(Vector vec)
{
	return cpp_compat_intrinsics_impl::any_helper<Vector>::__call(vec);
}

template<typename Condition, typename ResultType>
inline ResultType select(Condition condition, ResultType object1, ResultType object2)
{
	return cpp_compat_intrinsics_impl::select_helper<Condition, ResultType>::__call(condition, object1, object2);
}

/**
* @brief Returns x - floor(x).
*
* @tparam T type of the value to operate on.
*
* @param [in] val The value to operate on.
*/
template<typename T>
inline T fract(const in T val)
{
	return cpp_compat_intrinsics_impl::fract_helper<T>::__call(val);
}

template<typename T, typename U>
inline T mix(const in T x, const in T y, const in U a)
{
	return cpp_compat_intrinsics_impl::mix_helper<T, U>::__call(x, y, a);
}

template<typename T>
inline T sign(const in T val)
{
	return cpp_compat_intrinsics_impl::sign_helper<T>::__call(val);
}

template<typename T>
inline T radians(const in T degrees)
{
	return cpp_compat_intrinsics_impl::radians_helper<T>::__call(degrees);
}

template<typename T>
inline T degrees(const in T radians)
{
	return cpp_compat_intrinsics_impl::degrees_helper<T>::__call(radians);
}

template<typename T>
inline T step(const in T edge, const in T x)
{
	return cpp_compat_intrinsics_impl::step_helper<T>::__call(edge, x);
}

template<typename T>
inline T smoothStep(const in T edge0, const in T edge1, const in T x)
{
	return cpp_compat_intrinsics_impl::smoothStep_helper<T>::__call(edge0, edge1, x);
}

template<typename T>
inline T faceForward(const in T N, const in T I, const in T Nref)
{
	return cpp_compat_intrinsics_impl::faceForward_helper<T>::__call(N, I, Nref);
}

template<typename T>
inline T reflect(const in T I, const in T N)
{
	return cpp_compat_intrinsics_impl::reflect_helper<T>::__call(I, N);
}

template<typename T, typename U>
inline T refract(const in T I, const in T N, const in U eta)
{
	return cpp_compat_intrinsics_impl::refract_helper<T, U>::__call(I, N, eta);
}

template<typename T>
inline spirv::AddCarryOutput<T> addCarry(const in T operand1, const in T operand2)
{
	return cpp_compat_intrinsics_impl::addCarry_helper<T>::__call(operand1, operand2);
}

template<typename T>
inline spirv::SubBorrowOutput<T> subBorrow(const in T operand1, const in T operand2)
{
	return cpp_compat_intrinsics_impl::subBorrow_helper<T>::__call(operand1, operand2);
}

#line 251 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl"
template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, float32_t4>),bool> = true>
inline int32_t packSnorm4x8(T vec)
{
	return spirv::packSnorm4x8(vec);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, float32_t4>),bool> = true>
inline int32_t packUnorm4x8(T vec)
{
	return spirv::packUnorm4x8(vec);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, float32_t2>),bool> = true>
inline int32_t packSnorm2x16(T vec)
{
	return spirv::packSnorm2x16(vec);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, float32_t2>),bool> = true>
inline int32_t packUnorm2x16(T vec)
{
	return spirv::packUnorm2x16(vec);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, float32_t2>),bool> = true>
inline int32_t packHalf2x16(T vec)
{
	return spirv::packHalf2x16(vec);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, int32_t2>),bool> = true>
inline float64_t packDouble2x32(T vec)
{
	return spirv::packDouble2x32(vec);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, int32_t>),bool> = true>
inline float32_t2 unpackSnorm2x16(T val)
{
	return spirv::unpackSnorm2x16(val);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, int32_t>),bool> = true>
inline float32_t2 unpackUnorm2x16(T val)
{
	return spirv::unpackUnorm2x16(val);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, int32_t>),bool> = true>
inline float32_t2 unpackHalf2x16(T val)
{
	return spirv::unpackHalf2x16(val);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, int32_t>),bool> = true>
inline float32_t4 unpackSnorm4x8(T val)
{
	return spirv::unpackSnorm4x8(val);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, int32_t>),bool> = true>
inline float32_t4 unpackUnorm4x8(T val)
{
	return spirv::unpackUnorm4x8(val);
}

template<typename T ,::nbl::hlsl::enable_if_t<(is_same_v<T, float64_t>),bool> = true>
inline int32_t2 unpackDouble2x32(T val)
{
	return spirv::unpackDouble2x32(val);
}

}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/core.hlsl"
// Copyright (C) 2024-2025 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat/truncate.hlsl"
namespace nbl
{
namespace hlsl
{

namespace impl
{

template<typename T, typename U ,typename __requires=void >
struct Truncate
{
 inline T operator()(const in U v)
 {
 return T(v);
 }
};

template<typename Scalar, uint16_t N> 
struct Truncate<vector<Scalar, 1>, vector<Scalar, N> ,::nbl::hlsl::enable_if_t<(concepts::Scalar<Scalar>),void> >
{
 inline vector<Scalar, 1> operator()(const in vector<Scalar, N> v)
 {
 vector<Scalar, 1> truncated = { v[0] };
 return truncated;
 }
};

template<typename Scalar, uint16_t N> 
struct Truncate<vector<Scalar, 2>, vector<Scalar, N> ,::nbl::hlsl::enable_if_t<(concepts::Scalar<Scalar> && N >= 2),void> >
{
 inline vector<Scalar, 2> operator()(const in vector<Scalar, N> v)
 {
 vector<Scalar, 2> truncated = { v[0], v[1]};
 return truncated;
 }
};

template<typename Scalar, uint16_t N> 
struct Truncate<vector<Scalar, 3>, vector<Scalar, N> ,::nbl::hlsl::enable_if_t<(concepts::Scalar<Scalar>&& N >= 3),void> >
{
 inline vector<Scalar, 3> operator()(const in vector<Scalar, N> v)
 {
 vector<Scalar, 3> truncated = { v[0], v[1], v[2] };
 return truncated;
 }
};

template<typename Scalar, uint16_t N> 
struct Truncate<vector<Scalar, 4>, vector<Scalar, N> ,::nbl::hlsl::enable_if_t<(concepts::Scalar<Scalar>&& N >= 4),void> >
{
 inline vector<Scalar, 4> operator()(const in vector<Scalar, N> v)
 {
 vector<Scalar, 4> truncated = { v[0], v[1], v[2], v[3] };
 return truncated;
 }
};

} //namespace impl

template<typename T, typename U>
inline T truncate(const in U v)
{
 impl::Truncate<T, U> _truncate;
 return _truncate(v);
}

}
}

#line 10 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/cpp_compat.hlsl"
// Had to push some stuff here to avoid circular dependencies

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/functional.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/glsl_compat/core.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/limits.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/macros.h"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/type_traits.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/macros.h"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/limits.hlsl"
// C++ headers

#line 18 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/limits.hlsl"
/*
    nuumeric_limits C++ API spec elements:
    is_specialized
    is_signed
    is_integer
    is_exact
    has_infinity
    has_quiet_NaN
    has_signaling_NaN
    has_denorm
    has_denorm_loss
    round_style
    is_iec559
    is_bounded
    is_modulo
    digits
    digits10
    max_digits10
    radix
    min_exponent
    min_exponent10
    max_exponent
    max_exponent10
    traps
    tinyness_before
    min
    max
    lowest
    epsilon
    round_error
    infinity
    quiet_NaN
    signaling_NaN
    denorm_min
*/

namespace nbl
{
namespace hlsl
{

enum float_denorm_style {
    denorm_indeterminate = -1,
    denorm_absent        = 0,
    denorm_present       = 1
};

enum float_round_style {
    round_indeterminate       = -1,
    round_toward_zero         = 0,
    round_to_nearest          = 1,
    round_toward_infinity     = 2,
    round_toward_neg_infinity = 3
};

#line 82 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/limits.hlsl"
// Overlapping definitions

// Below implementations are not intended to be used on C++ side
namespace impl
{

template<class T>
struct num_base : type_identity<T>
{
 const static int32_t size = sizeof(T);

const static int32_t S8  = size;
    const static int32_t S16 = size / 2;
    const static int32_t S32 = size / 4;
    const static int32_t S64 = size / 8;

/*
        float_digits_array = {11, 24, 53};
        float_digits = float_digits_array[fp_idx];
    */
    
    const static int32_t float_digits = 11*S16 + 2*S32 + 5*S64;

/*
        decimal_digits_array = floor((float_digits_array-1)*log2) = {3, 6, 15}; 
        float_decimal_digits = decimal_digits_array[fp_idx];
    */

const static int32_t float_decimal_digits = 3*(S16 + S64);

/*
        decimal_max_digits_array = ceil(float_digits_array*log2 + 1) = {5, 9, 17};
        float_decimal_max_digits = decimal_max_digits_array[fp_idx];
    */
    const static int32_t float_decimal_max_digits = 5*S16 - S32 - S64;
    
    /*
        min_decimal_exponent_array = ceil((float_min_exponent-1) * log2) = { -4, -37, -307 };
        float_min_decimal_exponent = min_decimal_exponent_array[fp_idx];
    */
    const static int32_t float_min_decimal_exponent = -4*S16 - 29*S32 - 233*S64;

/*
 max_decimal_exponent_array = floor(float_max_exponent * log2) = { 4, 38, 308 };
 float_max_decimal_exponent = max_decimal_exponent_array[fp_idx];
 */
 const static int32_t float_max_decimal_exponent = 4*S16 + 30*S32 + 232*S64;
 
 const static int32_t float_exponent_bits = 8 * size - 1 - (float_digits-1);
 const static int32_t float_max_exponent = 1 << (float_exponent_bits-1);
 const static int32_t float_min_exponent = 3 - float_max_exponent;
 const static bool is_bool = is_same<T, bool>::value;

// identifies types for which std::numeric_limits is specialized
 const static bool is_specialized = true;
 // identifies signed types
 const static bool is_signed = nbl::hlsl::is_signed<T>::value;
 // 	identifies integer types
 const static bool is_integer = is_integral<T>::value;
 // identifies exact types
 const static bool is_exact = is_integer;
 // identifies floating-point types that can represent the special value "positive infinity"
 const static bool has_infinity = !is_integer;

// (TODO) think about what this means for HLSL
    // identifies floating-point types that can represent the special value "quiet not-a-number" (NaN)
    const static bool has_quiet_NaN = !is_integer; 
    // 	identifies floating-point types that can represent the special value "signaling not-a-number" (NaN)
    const static bool has_signaling_NaN = !is_integer;
    // 	identifies the denormalization style used by the floating-point type
    const static float_denorm_style has_denorm = is_integer ? float_denorm_style::denorm_absent : float_denorm_style::denorm_present;
    // identifies the floating-point types that detect loss of precision as denormalization loss rather than inexact result
    const static bool has_denorm_loss = false;
    // identifies the rounding style used by the type
    const static float_round_style round_style = is_integer ? float_round_style::round_toward_zero : float_round_style::round_to_nearest;
    // identifies the IEC 559/IEEE 754 floating-point types
    const static bool is_iec559 = !is_integer;
    // identifies types that represent a finite set of values
    const static bool is_bounded = true;

// TODO verify this
    // identifies types that handle overflows with modulo arithmetic
    const static bool is_modulo = is_integer && !is_signed && !is_bool;

// number of radix digits that can be represented without change
    const static int32_t digits = is_integer ? (is_bool? 1 : 8*size - is_signed) : float_digits;
    // number of decimal digits that can be represented without change
    const static int32_t digits10 = is_integer ? (is_bool ? 0 : S8 * 2 + S32 + int32_t(!is_signed) * S64) : float_decimal_digits;

// number of decimal digits necessary to differentiate all values of this type
    const static int32_t max_digits10 = !is_integer ? float_decimal_max_digits : 0;

// the radix or integer base used by the representation of the given type
    const static int32_t radix = 2;

// one more than the smallest negative power of the radix that is a valid normalized floating-point value
    const static int32_t min_exponent = !is_integer ? float_min_exponent : 0;
    // the smallest negative power of ten that is a valid normalized floating-point value
    const static int32_t min_exponent10 = !is_integer ? float_min_decimal_exponent : 0;
    // 	one more than the largest integer power of the radix that is a valid finite floating-point value
    const static int32_t max_exponent = !is_integer ? float_max_exponent : 0;
    // the largest integer power of 10 that is a valid finite floating-point value
    const static int32_t max_exponent10 = !is_integer ? float_max_decimal_exponent : 0;

// identifies types which can cause arithmetic operations to trap
    const static bool traps = false;
    // identifies floating-point types that detect tinyness before rounding
    const static bool tinyness_before = false;
    
};

template<class T> 
struct num_traits : num_base<T>
{
 // have to be weird like that to avoid a warning
 const static T min = T(num_base<T>::is_signed)<<(num_base<T>::is_signed ? num_base<T>::digits:0);
 // FIXME: Lots of warnings with `T=bool`
 const static T max = ~min;
 const static T denorm_min = T(0);
 const static T quiet_NaN = T(0);
 const static T signaling_NaN = T(0);
 const static T infinity = T(0);
};

template<> 
struct num_traits<float16_t> : num_base<float16_t>
{
 // since float16_t has no constexpr ctor we have to use float32_t constants on cpp side which is only needed for testing
 using type =

float32_t
#line 217 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/limits.hlsl"
;
    const static type      min           = 6.103515e-05F;
    const static type      max           = 65504.0F;
    const static type      denorm_min    = 5.96046448e-08F;
    const static uint16_t  quiet_NaN     = 0x7FFF;
    const static uint16_t  signaling_NaN = 0x7DFF;
    const static uint16_t  infinity      = 0x7C00;
};

template<> 
struct num_traits<float32_t> : num_base<float32_t>
{
 const static float32_t max = 3.402823466e+38F;
 const static float32_t min = 1.175494351e-38F;
 const static float32_t denorm_min = 1.401298464e-45F;
 const static uint32_t quiet_NaN = 0x7FC00000u;
 const static uint32_t signaling_NaN = 0x7FC00001u;
 const static uint32_t infinity = 0x7F800000u;
};

template<> 
struct num_traits<float64_t> : num_base<float64_t>
{
 const static float64_t max = 1.7976931348623158e+308l;
 const static float64_t min = 2.2250738585072014e-308l;
 const static float64_t denorm_min = 4.9406564584124654e-324l;
 const static uint64_t quiet_NaN = 0x7FF8000000000000ull;
 const static uint64_t signaling_NaN = 0x7FF0000000000001ull;
 const static uint64_t infinity = 0x7FF0000000000000ull;
};

template<class T>
struct numeric_limits : num_traits<T>
{
 using type = typename num_traits<T>::type;
 const static type lowest = num_traits<T>::is_integer ? num_traits<T>::min : -num_traits<T>::max;
 // FIXME: warning C4293 `<<`: shift count negative or too big (only when instantiating with `int8_t`
 const static type epsilon = num_traits<T>::is_integer ? type(0) : (type(1) / type(1ull<<(num_traits<T>::float_digits-1)));
 const static type round_error = type(num_traits<T>::is_iec559)/type(2.0);
};

}

template<class T>
struct numeric_limits : impl::numeric_limits<T> {};

#line 287 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/limits.hlsl"
}
}

#line 13 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/functional.hlsl"
namespace nbl
{
namespace hlsl
{

template<uint32_t StorageClass, typename T>
using __spv_ptr_t = spirv::pointer_t<StorageClass,T>;

template<uint32_t StorageClass, typename T>
[[vk::ext_instruction(spv::OpCopyObject)]]
__spv_ptr_t<StorageClass,T> addrof([[vk::ext_reference]] T v);

template<uint32_t StorageClass, typename T>
struct reference_wrapper_base
{
 using spv_ptr_t = __spv_ptr_t<StorageClass,T>;
 spv_ptr_t ptr;

void __init(spv_ptr_t _ptr)
    {
        ptr = _ptr;
    }

T load()
 {
 return spirv::load<T,spv_ptr_t>(ptr);
 }

void store(const T val)
 {
 spirv::store<T,spv_ptr_t>(ptr,val);
 }

// TODO: use the same defaults as `glsl::atomicAnd`
 template<uint32_t memoryScope, uint32_t memorySemantics, typename S=T>
 // TODO: instead of `is_scalar_v` we need a test on whether the `spirv::atomicAnd` expression is callable
 enable_if_t<is_same_v<S,T>&&is_scalar_v<S>,T> atomicAnd(const T value)
 {
 return spirv::atomicAnd<T,spv_ptr_t>(ptr,memoryScope,memorySemantics,value);
 }
 // TODO: generate Or,Xor through a macro

// TODO: comp swap is special, has an extra parameter
};
template<typename T>
struct reference_wrapper_base<spv::StorageClassPhysicalStorageBuffer,T>
{
 using spv_ptr_t = typename T::instead_use_nbl::hlsl::bda::__ref;

// normally would have specializations of load and store
};

// we need to explicitly white-list storage classes due to
// https://github.com/microsoft/DirectXShaderCompiler/issues/6578#issuecomment-2297181671
template<uint32_t StorageClass, typename T>
struct reference_wrapper : enable_if_t<
 is_same_v<StorageClass,spv::StorageClassInput>||
 is_same_v<StorageClass,spv::StorageClassUniform>||
 is_same_v<StorageClass,spv::StorageClassWorkgroup>||
 is_same_v<StorageClass,spv::StorageClassPushConstant>||
 is_same_v<StorageClass,spv::StorageClassImage>||
 is_same_v<StorageClass,spv::StorageClassStorageBuffer>,
 reference_wrapper_base<StorageClass,T>
>
{
};
// TODO: generate atomic Add,Sub,Min,Max through partial template specializations on T
// TODO: partial specializations for T being a special SPIR-V type for image ops, etc.

#line 99 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/functional.hlsl"
template<typename T ,typename __requires=void > struct bit_and { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs & rhs; }
 using scalar_t = typename scalar_type<T>::type;
 using bitfield_t = typename unsigned_integer_of_size<sizeof(scalar_t)>::type;

_Static_assert(!is_floating_point<T>::value,"We cannot define the identity element properly, you can thank https://github.com/microsoft/DirectXShaderCompiler/issues/5868 !");
 const static T identity = ~bitfield_t(0); // TODO: need a `all_components<T>` (not in cpp_compat) which can create vectors and matrices with all members set to scalar
};

template<typename T ,typename __requires=void > struct bit_or { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs | rhs; }

const static T identity = T(0);
};

template<typename T ,typename __requires=void > struct bit_xor { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs ^ rhs; }

const static T identity = T(0);
};

template<typename T ,typename __requires=void > struct plus { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs + rhs; }

const static T identity = T(0);
};

template<typename T ,typename __requires=void > struct minus { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs - rhs; }

const static T identity = T(0);
};

template<typename T ,typename __requires=void > struct multiplies { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs * rhs; }

const static T identity = T(1);
};

template<typename T ,typename __requires=void > struct divides { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs / rhs; }

const static T identity = T(1);
};

#line 147 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/functional.hlsl"
template<typename T ,typename __requires=void >
struct bit_not
{
 using type_t = T;

T operator()(const in T operand) 
    { 
        return ~operand; 
    }
};

// The default version above only works for fundamental scalars, vectors and matrices. This is because you can't call `~x` unless `x` is one of the former.
// Similarly, calling `x.operator~()` is not valid for the aforementioned, and only for types overriding this operator. So, we need a specialization.
template<typename T> 
struct bit_not<T ,::nbl::hlsl::enable_if_t<(!(concepts::Scalar<T> || concepts::Vector<T> || concepts::Matrix<T>)),void> >
{
 using type_t = T;

T operator()(const in T operand)
    {
        return operand.operator~();
    }
};

template<typename T ,typename __requires=void > struct equal_to { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs == rhs; } };
template<typename T ,typename __requires=void > struct not_equal_to { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs != rhs; } };
template<typename T ,typename __requires=void > struct greater { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs > rhs; } };
template<typename T ,typename __requires=void > struct less { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs < rhs; } };
template<typename T ,typename __requires=void > struct greater_equal { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs >= rhs; } };
template<typename T ,typename __requires=void > struct less_equal { using type_t = T; T operator()(const in T lhs, const in T rhs) { return lhs <= rhs; } };

// The above comparison operators return bool on STD, but in HLSL they're supposed to yield bool vectors, so here's a specialization so that they return `vector<bool, N>` for vectorial types

// GLM doesn't have operators on vectors

#line 211 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/functional.hlsl"
template<typename T> struct equal_to <T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T>),void> >{ using type_t = T; vector<bool, vector_traits<T>::Dimension> operator()(const in T lhs, const in T rhs) { return lhs == rhs; }};
template<typename T> struct not_equal_to <T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T>),void> >{ using type_t = T; vector<bool, vector_traits<T>::Dimension> operator()(const in T lhs, const in T rhs) { return lhs != rhs; }};
template<typename T> struct greater <T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T>),void> >{ using type_t = T; vector<bool, vector_traits<T>::Dimension> operator()(const in T lhs, const in T rhs) { return lhs > rhs; }};
template<typename T> struct less <T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T>),void> >{ using type_t = T; vector<bool, vector_traits<T>::Dimension> operator()(const in T lhs, const in T rhs) { return lhs < rhs; }};
template<typename T> struct greater_equal <T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T>),void> >{ using type_t = T; vector<bool, vector_traits<T>::Dimension> operator()(const in T lhs, const in T rhs) { return lhs >= rhs; }};
template<typename T> struct less_equal <T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T>),void> >{ using type_t = T; vector<bool, vector_traits<T>::Dimension> operator()(const in T lhs, const in T rhs) { return lhs <= rhs; }};

// ------------------------------------------------------------- COMPOUND ASSIGNMENT OPERATORS --------------------------------------------------------------------

#line 234 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/functional.hlsl"
template<typename T> struct plus_assign { using type_t = T; using base_t = plus <type_t>; base_t baseOp; void operator()([[vk::ext_reference]] inout T lhs, const in T rhs) { lhs = baseOp(lhs, rhs); } const static T identity = base_t::identity; };
template<typename T> struct minus_assign { using type_t = T; using base_t = minus <type_t>; base_t baseOp; void operator()([[vk::ext_reference]] inout T lhs, const in T rhs) { lhs = baseOp(lhs, rhs); } const static T identity = base_t::identity; }; 
template<typename T> struct multiplies_assign { using type_t = T; using base_t = multiplies <type_t>; base_t baseOp; void operator()([[vk::ext_reference]] inout T lhs, const in T rhs) { lhs = baseOp(lhs, rhs); } const static T identity = base_t::identity; }; 
template<typename T> struct divides_assign { using type_t = T; using base_t = divides <type_t>; base_t baseOp; void operator()([[vk::ext_reference]] inout T lhs, const in T rhs) { lhs = baseOp(lhs, rhs); } const static T identity = base_t::identity; };

// ---------------------------------------------------------------- MIN, MAX, TERNARY -------------------------------------------------------------------------

// Min, Max, and Ternary and Shift operators don't use ALIAS_STD because they don't exist in STD
// TODO: implement as mix(rhs<lhs,lhs,rhs) (SPIR-V intrinsic from the extended set & glm on C++)
template<typename T>
struct minimum
{
 using type_t = T;
 using scalar_t = typename scalar_type<T>::type;

T operator()(const in T lhs, const in T rhs)
 {
 return rhs<lhs ? rhs:lhs;
 }

const static T identity = numeric_limits<scalar_t>::max; // TODO: `all_components<T>`
};

template<typename T>
struct maximum
{
 using type_t = T;
 using scalar_t = typename scalar_type<T>::type;

T operator()(const in T lhs, const in T rhs)
 {
 return lhs<rhs ? rhs:lhs;
 }

const static T identity = numeric_limits<scalar_t>::lowest; // TODO: `all_components<T>`
};

template<typename T ,typename __requires=void >
struct ternary_operator
{
 using type_t = T;

inline T operator()(const in bool condition, const in T lhs, const in T rhs)
 {
 return select<bool, T>(condition, lhs, rhs);
 }
};

// ----------------------------------------------------------------- SHIFT OPERATORS --------------------------------------------------------------------

template<typename T ,typename __requires=void >
struct left_shift_operator
{
 using type_t = T;

inline T operator()(const in T operand, const in T bits)
 {
 return operand << bits;
 }
};

template<typename T> 
struct left_shift_operator<T ,::nbl::hlsl::enable_if_t<(concepts::IntVector<T>),void> >
{
 using type_t = T;
 using scalar_t = scalar_type_t<T>;

inline T operator()(const in T operand, const in T bits)
 {
 return operand << bits;
 }

inline T operator()(const in T operand, const in scalar_t bits)
 {
 return operand << bits;
 }
};

template<typename T> 
struct left_shift_operator<T ,::nbl::hlsl::enable_if_t<(!concepts::IntVector<T> && concepts::IntegralLikeVectorial<T>),void> >
{
 using type_t = T;
 using scalar_t = typename vector_traits<T>::scalar_type;

inline T operator()(const in T operand, const in T bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 left_shift_operator<scalar_t> leftShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, leftShift(getter(operand, i), getter(bits, i)));
 }
 return shifted;
 }

inline T operator()(const in T operand, const in scalar_t bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 left_shift_operator<scalar_t> leftShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, leftShift(getter(operand, i), bits));
 }
 return shifted;
 }

inline T operator()(const in T operand, const in vector<uint16_t, vector_traits<T>::Dimension> bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 left_shift_operator<scalar_t> leftShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, leftShift(getter(operand, i), bits[i]));
 }
 return shifted;
 }

inline T operator()(const in T operand, const in uint16_t bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 left_shift_operator<scalar_t> leftShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, leftShift(getter(operand, i), bits));
 }
 return shifted;
 }
};

template<typename T ,typename __requires=void >
struct arithmetic_right_shift_operator
{
 using type_t = T;

inline T operator()(const in T operand, const in T bits)
    {
        return operand >> bits;
    }
};

template<typename T> 
struct arithmetic_right_shift_operator<T ,::nbl::hlsl::enable_if_t<(concepts::IntVector<T>),void> >
{
 using type_t = T;
 using scalar_t = scalar_type_t<T>;

inline T operator()(const in T operand, const in T bits)
    {
        return operand >> bits;
    }

inline T operator()(const in T operand, const in scalar_t bits)
    {
        return operand >> bits;
    }
};

template<typename T> 
struct arithmetic_right_shift_operator<T ,::nbl::hlsl::enable_if_t<(!concepts::IntVector<T>&& concepts::IntegralLikeVectorial<T>),void> >
{
 using type_t = T;
 using scalar_t = typename vector_traits<T>::scalar_type;

inline T operator()(const in T operand, const in T bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 arithmetic_right_shift_operator<scalar_t> rightShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, rightShift(getter(operand, i), getter(bits, i)));
 }
 return shifted;
 }

inline T operator()(const in T operand, const in scalar_t bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 arithmetic_right_shift_operator<scalar_t> rightShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, rightShift(getter(operand, i), bits));
 }
 return shifted;
 }

inline T operator()(const in T operand, const in vector<uint16_t, vector_traits<T>::Dimension> bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 arithmetic_right_shift_operator<scalar_t> rightShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, rightShift(getter(operand, i), bits[i]));
 }
 return shifted;
 }

inline T operator()(const in T operand, const in uint16_t bits)
 {
 array_get<T, scalar_t> getter;
 array_set<T, scalar_t> setter;
 const static uint16_t extent = uint16_t(extent_v<T>);
 arithmetic_right_shift_operator<scalar_t> rightShift;
 T shifted;
 [[unroll]]
 for (uint16_t i = 0; i < extent; i++)
 {
 setter(shifted, i, rightShift(getter(operand, i), bits));
 }
 return shifted;
 }
};

// Left unimplemented for vectorial types by default
template<typename T ,typename __requires=void >
struct logical_right_shift_operator
{
 using type_t = T;
 using unsigned_type_t = make_unsigned_t<T>;

inline T operator()(const in T operand, const in T bits)
 {
 arithmetic_right_shift_operator<unsigned_type_t> arithmeticRightShift;
 return _static_cast<T>(arithmeticRightShift(_static_cast<unsigned_type_t>(operand), _static_cast<unsigned_type_t>(bits)));
 }
};

} //namespace nbl
} //namespace hlsl

#line 9 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
// Didn't bother with operator*, operator/, implement if you need them. Multiplication is pretty straightforward, division requires switching on signs 
// and whether the topmost bits of the divisor are equal to 0
// - Francisco

namespace nbl 
{
namespace hlsl
{

template<bool Signed>
struct emulated_int64_base
{
 using storage_t = vector<uint32_t, 2>;
 using this_t = emulated_int64_base<Signed>;
 using this_signed_t = emulated_int64_base<true>;

storage_t data;

// ---------------------------------------------------- CONSTRUCTORS ---------------------------------------------------------------

#line 41 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
    /**
    * @brief Creates an `emulated_int64` from a vector of two `uint32_t`s representing its bitpattern
    *
    * @param [in] _data Vector of `uint32_t` encoding the `uint64_t/int64_t` being emulated. Stored as little endian (first component are the lower 32 bits)
    */
    static inline this_t create(const in storage_t _data)
    {
        this_t retVal;
        retVal.data = _data;
        return retVal;
    }

/**
    * @brief Creates an `emulated_int64` from two `uint32_t`s representing its bitpattern
    *
    * @param [in] lo Lowest 32 bits of the `uint64_t/int64_t` being emulated
    * @param [in] hi Highest 32 bits of the `uint64_t/int64_t` being emulated
    */
    static inline this_t create(const in uint32_t lo, const in uint32_t hi)
    {
        return create(storage_t(lo, hi));
    }

// ------------------------------------------------------- CONVERSION OPERATORS---------------------------------------------------------------
    // GLM requires these for vector casts

#line 74 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
    // ------------------------------------------------------- INTERNAL GETTERS -------------------------------------------------

inline uint32_t __getLSB() 
    {
        return data.x;
    }

inline uint32_t __getMSB() 
    {
        return data.y;
    }

// ------------------------------------------------------- BITWISE OPERATORS -------------------------------------------------

inline this_t operator&(const in this_t rhs) 
    {
        this_t retVal = create(data & rhs.data);
        return retVal;
    }

inline this_t operator|(const in this_t rhs) 
    {
        this_t retVal = create(data | rhs.data);
        return retVal;
    }

inline this_t operator^(const in this_t rhs) 
    {
        this_t retVal = create(data ^ rhs.data);
        return retVal;
    }

inline this_t operator~() 
    {
        this_t retVal = create(~data);
        return retVal;
    }

// Only valid in CPP

#line 119 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
    // ------------------------------------------------------- ARITHMETIC OPERATORS -------------------------------------------------

inline this_signed_t operator-() 
 {
 vector<int32_t, 2> negated = -data;
 return this_signed_t::create(_static_cast<storage_t>(negated));
 }

inline this_t operator+(const in this_t rhs) 
 {
 const spirv::AddCarryOutput<uint32_t> lowerAddResult = addCarry(__getLSB(), rhs.__getLSB());
 return create(lowerAddResult.result, __getMSB() + rhs.__getMSB() + lowerAddResult.carry);
 }

inline this_t operator-(const in this_t rhs) 
 {
 const spirv::SubBorrowOutput<uint32_t> lowerSubResult = subBorrow(__getLSB(), rhs.__getLSB());
 return create(lowerSubResult.result, __getMSB() - rhs.__getMSB() - lowerSubResult.borrow);
 }

// ------------------------------------------------------- COMPARISON OPERATORS -------------------------------------------------
 inline bool operator==(const in this_t rhs) 
 {
 equal_to<storage_t> equals;
 return all(equals(data, rhs.data));
 }

inline bool operator!=(const in this_t rhs) 
 {
 not_equal_to<storage_t> notEquals;
 return any(notEquals(data, rhs.data));
 }

inline bool operator<(const in this_t rhs) 
 {
 // Either the topmost bits, when interpreted with correct sign, are less than those of `rhs`, or they're equal and the lower bits are less
 // (lower bits are always positive in both unsigned and 2's complement so comparison can happen as-is)
 const bool MSBEqual = __getMSB() == rhs.__getMSB();
 const bool MSB = Signed ? (bit_cast<int32_t>(__getMSB()) < bit_cast<int32_t>(rhs.__getMSB())) : (__getMSB() < rhs.__getMSB());
 const bool LSB = __getLSB() < rhs.__getLSB();
 return MSBEqual ? LSB : MSB;
 }

inline bool operator>(const in this_t rhs) 
 {
 // Same reasoning as above
 const bool MSBEqual = __getMSB() == rhs.__getMSB();
 const bool MSB = Signed ? (bit_cast<int32_t>(__getMSB()) > bit_cast<int32_t>(rhs.__getMSB())) : (__getMSB() > rhs.__getMSB());
 const bool LSB = __getLSB() > rhs.__getLSB();
 return MSBEqual ? LSB : MSB;
 }

inline bool operator<=(const in this_t rhs) 
 {
 return !operator>(rhs);
 }

inline bool operator>=(const in this_t rhs) 
 {
 return !operator<(rhs);
 }
};

using emulated_uint64_t = emulated_int64_base<false>;
using emulated_int64_t = emulated_int64_base<true>;

namespace impl
{

template<bool Signed>
struct static_cast_helper<emulated_int64_base<Signed>, emulated_int64_base<!Signed> >
{
 using To = emulated_int64_base<Signed>;
 using From = emulated_int64_base<!Signed>;

static inline To cast(const in From other)
    {
        To retVal;
        retVal.data = other.data;
        return retVal;
    }
};

template<typename I, bool Signed> 
struct static_cast_helper<I, emulated_int64_base<Signed> ,::nbl::hlsl::enable_if_t<(concepts::IntegralScalar && (sizeof(I) <= sizeof(uint32_t))),void> >
{
 using To = I;
 using From = emulated_int64_base<Signed>;

// Return only the lowest bits
 static inline To cast(const in From val)
 {
 return _static_cast<To>(val.data.x);
 }
};

template<typename I, bool Signed> 
struct static_cast_helper<I, emulated_int64_base<Signed> ,::nbl::hlsl::enable_if_t<(concepts::IntegralScalar && (sizeof(I) > sizeof(uint32_t))),void> >
{
 using To = I;
 using From = emulated_int64_base<Signed>;

static inline To cast(const in From val)
 {
 return bit_cast<To>(val.data);
 }
};

template<typename I, bool Signed> 
struct static_cast_helper<emulated_int64_base<Signed>, I ,::nbl::hlsl::enable_if_t<(concepts::IntegralScalar && (sizeof(I) <= sizeof(uint32_t))),void> >
{
 using To = emulated_int64_base<Signed>;
 using From = I;

// Set only lower bits
 static inline To cast(const in From i)
 {
 return To::create(_static_cast<uint32_t>(i), uint32_t(0));
 }
};

template<typename I, bool Signed> 
struct static_cast_helper<emulated_int64_base<Signed>, I ,::nbl::hlsl::enable_if_t<(concepts::IntegralScalar && (sizeof(I) > sizeof(uint32_t))),void> >
{
 using To = emulated_int64_base<Signed>;
 using From = I;

static inline To cast(const in From i)
 {
 // `bit_cast` blocked by GLM vectors using a union
#line 252 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
 To retVal;
 retVal.data = bit_cast<vector<uint32_t, 2> >(i);
 return retVal;

}
};

} //namespace impl

// Define constructor and conversion operators

#line 281 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
// ---------------------- Functional operators ------------------------

template<bool Signed>
struct left_shift_operator<emulated_int64_base<Signed> >
{
 using type_t = emulated_int64_base<Signed>;
 const static uint32_t ComponentBitWidth = uint32_t(8 * sizeof(uint32_t));

// Can't do generic templated definition, see:
 //https://github.com/microsoft/DirectXShaderCompiler/issues/7325
 
 // If `_bits > 63` or `_bits < 0` the result is undefined
 inline type_t operator()(const in type_t operand, uint32_t bits)
 {
 const bool bigShift = bits >= ComponentBitWidth; // Shift that completely rewrites LSB
 const uint32_t shift = bigShift ? bits - ComponentBitWidth : ComponentBitWidth - bits;
 const type_t shifted = type_t::create(bigShift ? vector<uint32_t, 2>(0, operand.__getLSB() << shift)
 : vector<uint32_t, 2>(operand.__getLSB() << bits, (operand.__getMSB() << bits) | (operand.__getLSB() >> shift)));
 ternary_operator<type_t> ternary;
 return ternary(bool(bits), shifted, operand);
 }

// If `_bits > 63` or `_bits < 0` the result is undefined
 inline type_t operator()(const in type_t operand, type_t bits)
 {
 return operator()(operand, _static_cast<uint32_t>(bits));
 }
};

template<>
struct arithmetic_right_shift_operator<emulated_uint64_t>
{
 using type_t = emulated_uint64_t;
 const static uint32_t ComponentBitWidth = uint32_t(8 * sizeof(uint32_t));

// Can't do generic templated definition, see:
    //https://github.com/microsoft/DirectXShaderCompiler/issues/7325

// If `_bits > 63` the result is undefined
 inline type_t operator()(const in type_t operand, uint32_t bits)
 {
 const bool bigShift = bits >= ComponentBitWidth; // Shift that completely rewrites MSB
 const uint32_t shift = bigShift ? bits - ComponentBitWidth : ComponentBitWidth - bits;
 const type_t shifted = type_t::create(bigShift ? vector<uint32_t, 2>(operand.__getMSB() >> shift, 0)
 : vector<uint32_t, 2>((operand.__getMSB() << shift) | (operand.__getLSB() >> bits), operand.__getMSB() >> bits));
 ternary_operator<type_t> ternary;
 return ternary(bool(bits), shifted, operand);
 }

// If `_bits > 63` the result is undefined
 inline type_t operator()(const in type_t operand, type_t bits)
 {
 return operator()(operand, _static_cast<uint32_t>(bits));
 }
};

template<>
struct arithmetic_right_shift_operator<emulated_int64_t>
{
 using type_t = emulated_int64_t;
 const static uint32_t ComponentBitWidth = uint32_t(8 * sizeof(uint32_t));

// Can't do generic templated definition, see:
    //https://github.com/microsoft/DirectXShaderCompiler/issues/7325

// If `_bits > 63` or `_bits < 0` the result is undefined
 inline type_t operator()(const in type_t operand, uint32_t bits)
 {
 const bool bigShift = bits >= ComponentBitWidth; // Shift that completely rewrites MSB
 const uint32_t shift = bigShift ? bits - ComponentBitWidth : ComponentBitWidth - bits;
 const type_t shifted = type_t::create(bigShift ? vector<uint32_t, 2>(uint32_t(int32_t(operand.__getMSB()) >> shift), int32_t(operand.__getMSB()) < 0 ? ~uint32_t(0) : uint32_t(0))
 : vector<uint32_t, 2>((operand.__getMSB() << shift) | (operand.__getLSB() >> bits), uint32_t(int32_t(operand.__getMSB()) >> bits)));
 ternary_operator<type_t> ternary;
 return ternary(bool(bits), shifted, operand);
 }

#line 387 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
// ---------------------- STD arithmetic operators ------------------------
// Specializations of the structs found in functional.hlsl
// These all have to be specialized because of the identity that can't be initialized inside the struct definition

template<bool Signed>
struct plus<emulated_int64_base<Signed> >
{
 using type_t = emulated_int64_base<Signed>;

type_t operator()(const in type_t lhs, const in type_t rhs)
    {
        return lhs + rhs;
    }

const static type_t identity;
};

template<bool Signed>
struct minus<emulated_int64_base<Signed> >
{
 using type_t = emulated_int64_base<Signed>;

type_t operator()(const in type_t lhs, const in type_t rhs)
    {
        return lhs - rhs;
    }

const static type_t identity;
};

template<>
const static emulated_uint64_t plus<emulated_uint64_t>::identity = _static_cast<emulated_uint64_t>(uint64_t(0));
template<>
const static emulated_int64_t plus<emulated_int64_t>::identity = _static_cast<emulated_int64_t>(int64_t(0));
template<>
const static emulated_uint64_t minus<emulated_uint64_t>::identity = _static_cast<emulated_uint64_t>(uint64_t(0));
template<>
const static emulated_int64_t minus<emulated_int64_t>::identity = _static_cast<emulated_int64_t>(int64_t(0));

// --------------------------------- Compound assignment operators ------------------------------------------
// Specializations of the structs found in functional.hlsl

template<bool Signed>
struct plus_assign<emulated_int64_base<Signed> >
{
 using type_t = emulated_int64_base<Signed>;
 using base_t = plus<type_t>;
 base_t baseOp;
 void operator()([[vk::ext_reference]] inout type_t lhs, const in type_t rhs)
 {
 lhs = baseOp(lhs, rhs);
 }

const static type_t identity;
};

template<bool Signed>
struct minus_assign<emulated_int64_base<Signed> >
{
 using type_t = emulated_int64_base<Signed>;
 using base_t = minus<type_t>;
 base_t baseOp;
 void operator()([[vk::ext_reference]] inout type_t lhs, const in type_t rhs)
 {
 lhs = baseOp(lhs, rhs);
 }

const static type_t identity;
};

template<>
const static emulated_uint64_t plus_assign<emulated_uint64_t>::identity = plus<emulated_uint64_t>::identity;
template<>
const static emulated_int64_t plus_assign<emulated_int64_t>::identity = plus<emulated_int64_t>::identity;
template<>
const static emulated_uint64_t minus_assign<emulated_uint64_t>::identity = minus<emulated_uint64_t>::identity;
template<>
const static emulated_int64_t minus_assign<emulated_int64_t>::identity = minus<emulated_int64_t>::identity;

// ------------------------------------------------ TYPE TRAITS SATISFIED -----------------------------------------------------

template<>
struct is_signed<emulated_int64_t> : bool_constant<true> {};

template<>
struct is_unsigned<emulated_uint64_t> : bool_constant<true> {};

// --------------------------------------------------- CONCEPTS SATISFIED -----------------------------------------------------
namespace concepts
{
namespace impl
{
template<bool Signed>
struct is_emulating_integral_scalar<emulated_int64_base<Signed> >
{
 const static bool value = true;
};
}
}

} //namespace nbl
} //namespace hlsl

// Declare them as signed/unsigned versions of each other

#line 498 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/int64_t.hlsl"
template<>
struct nbl::hlsl:: make_unsigned<nbl::hlsl::emulated_uint64_t> : type_identity<nbl::hlsl::emulated_uint64_t> {};

template<>
struct nbl::hlsl:: make_unsigned<nbl::hlsl::emulated_int64_t> : type_identity<nbl::hlsl::emulated_uint64_t> {};

template<>
struct nbl::hlsl:: make_signed<nbl::hlsl::emulated_uint64_t> : type_identity<nbl::hlsl::emulated_int64_t> {};

template<>
struct nbl::hlsl:: make_signed<nbl::hlsl::emulated_int64_t> : type_identity<nbl::hlsl::emulated_int64_t> {};

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/mpl.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/mpl.hlsl"
namespace nbl
{
namespace hlsl
{
namespace mpl
{

namespace impl
{

template<uint64_t N, uint16_t bits>
struct countl_zero
{
 const static uint64_t SHIFT = bits >> 1;
 const static uint64_t LO_MASK = (1ull << SHIFT) - 1;
 const static bool CHOOSE_HIGH = (N & (LO_MASK << SHIFT))!=0;
 const static uint64_t NEXT = (CHOOSE_HIGH ? (N >> SHIFT) : N) & LO_MASK;
 const static uint16_t value = countl_zero<NEXT, SHIFT>::value + (CHOOSE_HIGH ? 0ull : SHIFT);
};

template<uint64_t N>
struct countl_zero<N, 1> : integral_constant<uint16_t, uint16_t(1u - (N & 1))>
{};

}

template<class T, T N>
struct countl_zero : impl::countl_zero<uint64_t(N), (sizeof(T) * 8)>
{
 _Static_assert(is_integral<T>::value, "countl_zero type parameter must be an integral type");
};
template<class T, T N>
const static T countl_zero_v = countl_zero<T,N>::value;

template<uint64_t N>
struct is_pot : bool_constant< (N > 0 && !(N & (N - 1))) > {};
template<uint64_t N>
const static bool is_pot_v = is_pot<N>::value;

template<uint64_t X>
struct log2
{
 const static uint16_t value = X ? (1ull<<6)-countl_zero<uint64_t, X>::value-1 : -1ull;
};
template<uint64_t X>
const static uint16_t log2_v = log2<X>::value;

template<uint64_t X>
struct log2_ceil : integral_constant<uint16_t, log2_v<X> + uint16_t(!is_pot_v<X>)> {};
template<uint64_t X>
const static uint16_t log2_ceil_v = log2_ceil<X>::value;

template<typename T, T X, int32_t S>
struct rotl
{
 const static uint32_t N = 32u;
 const static int32_t r = S % N;
 const static T value = (S >= 0) ? ((X << r) | (X >> (N - r))) : (X >> (-r)) | (X << (N - (-r)));
};
template<typename T, T X, int32_t S>
const static T rotl_v = rotl<T,X,S>::value;

template<typename T, T X, int32_t S>
struct rotr
{
 const static uint32_t N = 32u;
 const static int32_t r = S % N;
 const static T value = (S >= 0) ? ((X >> r) | (X << (N - r))) : (X << (-r)) | (X >> (N - (-r)));
};
template<typename T, T X, int32_t S>
const static T rotr_v = rotr<T,X,S>::value;

template<uint64_t X, uint64_t M>
struct align_up
{
 const static uint64_t value = X ? (((X-1)/M+1)*M):0;
};
template<uint64_t X, uint64_t M>
const static uint64_t align_up_v = align_up<X,M>::value;

template<typename T, T X, T Y>
struct max
{
 const static T value = X<Y ? Y:X;
};
template<typename T, T X, T Y>
const static T max_v = max<T,X,Y>::value;

template<typename T, T X, T Y>
struct min
{
 const static T value = X<Y ? X:Y;
};
template<typename T, T X, T Y>
const static T min_v = min<T,X,Y>::value;

template<uint64_t X>
struct round_up_to_pot : integral_constant<uint64_t, uint64_t(1) << log2_ceil_v<X> > {};
template<uint64_t X>
const static uint64_t round_up_to_pot_v = round_up_to_pot<X>::value;

template<uint64_t X>
struct round_down_to_pot : integral_constant<uint64_t, uint64_t(1) << log2_v<X> > {};
template<uint64_t X>
const static uint64_t round_down_to_pot_v = round_down_to_pot<X>::value;

}
}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/algorithm.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 9 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/algorithm.hlsl"
namespace nbl
{
namespace hlsl
{

namespace impl
{

// TODO: use structs

template<typename T>
 inline void swap([[vk::ext_reference]] inout T lhs, [[vk::ext_reference]] inout T rhs)
 {
 T tmp = lhs;
 lhs = rhs;
 rhs = tmp;
 }

template<>
 inline void swap([[vk::ext_reference]] inout uint16_t lhs, [[vk::ext_reference]] inout uint16_t rhs)
 {
 lhs ^= rhs;
 rhs ^= lhs;
 lhs ^= rhs;
 }

template<>
 inline void swap([[vk::ext_reference]] inout uint32_t lhs, [[vk::ext_reference]] inout uint32_t rhs)
 {
 lhs ^= rhs;
 rhs ^= lhs;
 lhs ^= rhs;
 }

template<>
 inline void swap([[vk::ext_reference]] inout uint64_t lhs, [[vk::ext_reference]] inout uint64_t rhs)
 {
 lhs ^= rhs;
 rhs ^= lhs;
 lhs ^= rhs;
 }

template<>
 inline void swap([[vk::ext_reference]] inout int16_t lhs, [[vk::ext_reference]] inout int16_t rhs)
 {
 lhs ^= rhs;
 rhs ^= lhs;
 lhs ^= rhs;
 }

template<>
 inline void swap([[vk::ext_reference]] inout int32_t lhs, [[vk::ext_reference]] inout int32_t rhs)
 {
 lhs ^= rhs;
 rhs ^= lhs;
 lhs ^= rhs;
 }

template<>
 inline void swap([[vk::ext_reference]] inout int64_t lhs, [[vk::ext_reference]] inout int64_t rhs)
 {
 lhs ^= rhs;
 rhs ^= lhs;
 lhs ^= rhs;
 }
#line 82 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/algorithm.hlsl"
}

template<typename T>
inline void swap([[vk::ext_reference]] inout T lhs, [[vk::ext_reference]] inout T rhs)
{
 impl::swap<T>(lhs, rhs);
}

namespace impl
{

// TODO: move this to some other header
bool isNPoT(const uint x)
{
    return x&(x-1);
}

template<class Accessor, class Comparator>
struct bound_t
{
 static bound_t<Accessor,Comparator> setup(uint begin, const uint end, const typename Accessor::value_type _value, const Comparator _comp)
 {
 bound_t<Accessor,Comparator> retval;
 retval.comp = _comp;
 retval.value = _value;
 retval.it = begin;
 retval.len = end-begin;
 return retval;
 }

uint operator()([[vk::ext_reference]] inout Accessor accessor)
 {
 if (isNPoT(len))
 {
 const uint newLen = 0x1u<<firstbithigh(len);
 const uint testPoint = it+(len-newLen);
 len = newLen;
 comp_step(accessor,testPoint);
 }
 while (len)
 {
 // could unroll 3 times or more
 iteration(accessor);
 iteration(accessor);
 }
 comp_step(accessor,it,it+1u);
 return it;
 }

void iteration([[vk::ext_reference]] inout Accessor accessor)
    {
        len >>= 1;
        const uint mid = it+len;
        comp_step(accessor,mid);
    }

void comp_step([[vk::ext_reference]] inout Accessor accessor, const uint testPoint, const uint rightBegin)
    {
        if (comp(accessor[testPoint],value))
            it = rightBegin;
    }
    void comp_step([[vk::ext_reference]] inout Accessor accessor, const uint testPoint)
    {
        comp_step(accessor,testPoint,testPoint);
    }

Comparator comp;
    typename Accessor::value_type value;
    uint it;
    uint len;
};

template<class Accessor, class Comparator>
struct lower_to_upper_comparator_transform_t
{
 bool operator()(const typename Accessor::value_type lhs, const typename Accessor::value_type rhs)
 {
 return !comp(rhs,lhs);
 }

Comparator comp;
};

}

template<class Accessor, class Comparator>
uint lower_bound([[vk::ext_reference]] inout Accessor accessor, const uint begin, const uint end, const typename Accessor::value_type value, const Comparator comp)
{
 impl::bound_t<Accessor,Comparator> implementation = impl::bound_t<Accessor,Comparator>::setup(begin,end,value,comp);
 return implementation(accessor);
}

template<class Accessor, class Comparator>
uint upper_bound([[vk::ext_reference]] inout Accessor accessor, const uint begin, const uint end, const typename Accessor::value_type value, const Comparator comp)
{
 //using TransformedComparator = impl::lower_to_upper_comparator_transform_t<Accessor,Comparator>;
 //TransformedComparator transformedComparator;
 
 impl::lower_to_upper_comparator_transform_t<Accessor,Comparator> transformedComparator;
 transformedComparator.comp = comp;
 return lower_bound<Accessor,impl::lower_to_upper_comparator_transform_t<Accessor,Comparator> >(accessor,begin,end,value,transformedComparator);
}

namespace impl
{

// extra indirection due to https://github.com/microsoft/DirectXShaderCompiler/issues/4771
template<class Accessor, typename T>
uint lower_bound([[vk::ext_reference]] inout Accessor accessor, const uint begin, const uint end, const T value)
{
 //using Comparator = nbl::hlsl::less<T>;
 //Comparator comp;
 
 nbl::hlsl::less<T> comp;
 return nbl::hlsl::lower_bound<Accessor, nbl::hlsl::less<T> >(accessor,begin,end,value,comp);
}
template<class Accessor, typename T>
uint upper_bound([[vk::ext_reference]] inout Accessor accessor, const uint begin, const uint end, const T value)
{
 //using Comparator = nbl::hlsl::less<T>;
 //Comparator comp;
 
 nbl::hlsl::less<T> comp;
 return nbl::hlsl::upper_bound<Accessor, nbl::hlsl::less<T> >(accessor,begin,end,value,comp);
}

}

template<class Accessor>
uint lower_bound([[vk::ext_reference]] inout Accessor accessor, const uint begin, const uint end, const typename Accessor::value_type value)
{
 return impl::lower_bound<Accessor,typename Accessor::value_type>(accessor,begin,end,value);
}
template<class Accessor>
uint upper_bound([[vk::ext_reference]] inout Accessor accessor, const uint begin, const uint end, const typename Accessor::value_type value)
{
 return impl::upper_bound<Accessor,typename Accessor::value_type>(accessor,begin,end,value);
}

}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/glsl_compat/core.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/impl.hlsl"
// C++ includes

#line 18 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/impl.hlsl"
namespace nbl
{
namespace hlsl
{
namespace tgmath_impl
{

template<typename T ,typename __requires=void>
struct erf_helper;
template<typename T ,typename __requires=void>
struct erfInv_helper;
template<typename T ,typename __requires=void>
struct isnan_helper;
template<typename T ,typename __requires=void>
struct isinf_helper;
template<typename V ,typename __requires=void>
struct floor_helper;
template<typename T ,typename __requires=void>
struct pow_helper;
template<typename T ,typename __requires=void>
struct exp_helper;
template<typename T ,typename __requires=void>
struct exp2_helper;
template<typename T ,typename __requires=void>
struct log_helper;
template<typename T ,typename __requires=void>
struct log2_helper;
template<typename T ,typename __requires=void>
struct abs_helper;
template<typename T ,typename __requires=void>
struct cos_helper;
template<typename T ,typename __requires=void>
struct sin_helper;
template<typename T ,typename __requires=void>
struct acos_helper;
template<typename T ,typename __requires=void>
struct tan_helper;
template<typename T ,typename __requires=void>
struct asin_helper;
template<typename T ,typename __requires=void>
struct atan_helper;
template<typename T ,typename __requires=void>
struct sinh_helper;
template<typename T ,typename __requires=void>
struct cosh_helper;
template<typename T ,typename __requires=void>
struct tanh_helper;
template<typename T ,typename __requires=void>
struct asinh_helper;
template<typename T ,typename __requires=void>
struct acosh_helper;
template<typename T ,typename __requires=void>
struct atanh_helper;
template<typename T ,typename __requires=void>
struct atan2_helper;

template<typename T ,typename __requires=void>
struct sqrt_helper;
template<typename T ,typename __requires=void>
struct modf_helper;
template<typename T ,typename __requires=void>
struct round_helper;
template<typename T ,typename __requires=void>
struct roundEven_helper;
template<typename T ,typename __requires=void>
struct trunc_helper;
template<typename T ,typename __requires=void>
struct ceil_helper;
template<typename T ,typename __requires=void>
struct fma_helper;
template<typename T, typename U ,typename __requires=void>
struct ldexp_helper;
template<typename T ,typename __requires=void>
struct modfStruct_helper;
template<typename T ,typename __requires=void>
struct frexpStruct_helper;

#line 102 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/impl.hlsl"
// the template<> needs to be written ourselves
// return type is __VA_ARGS__ to protect against `,` in templated return types

#line 115 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/impl.hlsl"
template<typename T> struct sin_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sin<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: sin<T>( arg0 );	}};
template<typename T> struct cos_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: cos<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: cos<T>( arg0 );	}};
template<typename T> struct acos_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: acos<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: acos<T>( arg0 );	}};
template<typename T> struct tan_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: tan<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: tan<T>( arg0 );	}};
template<typename T> struct asin_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: asin<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: asin<T>( arg0 );	}};
template<typename T> struct atan_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: atan<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: atan<T>( arg0 );	}};
template<typename T> struct sinh_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sinh<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: sinh<T>( arg0 );	}};
template<typename T> struct cosh_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: cosh<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: cosh<T>( arg0 );	}};
template<typename T> struct tanh_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: tanh<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: tanh<T>( arg0 );	}};
template<typename T> struct asinh_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: asinh<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: asinh<T>( arg0 );	}};
template<typename T> struct acosh_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: acosh<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: acosh<T>( arg0 );	}};
template<typename T> struct atanh_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: atanh<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: atanh<T>( arg0 );	}};
template<typename T> struct atan2_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: atan2<T>(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: atan2<T>( arg0 , arg1 );	}};
template<typename T> struct abs_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sAbs<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: sAbs<T>( arg0 );	}};
template<typename T> struct abs_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: fAbs<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: fAbs<T>( arg0 );	}};
template<typename T> struct sqrt_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: sqrt<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: sqrt<T>( arg0 );	}};
template<typename T> struct log_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: log<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: log<T>( arg0 );	}};
template<typename T> struct log2_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: log2<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: log2<T>( arg0 );	}};
template<typename T> struct exp2_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: exp2<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: exp2<T>( arg0 );	}};
template<typename T> struct exp_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: exp<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: exp<T>( arg0 );	}};
template<typename T> struct floor_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: floor<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: floor<T>( arg0 );	}};
template<typename T> struct round_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: round<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: round<T>( arg0 );	}};
template<typename T> struct roundEven_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: roundEven<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: roundEven<T>( arg0 );	}};
template<typename T> struct trunc_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: trunc<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: trunc<T>( arg0 );	}};
template<typename T> struct ceil_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: ceil<T>(experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 )	{		return spirv:: ceil<T>( arg0 );	}};
template<typename T> struct pow_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: pow<T>(experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 )	{		return spirv:: pow<T>( arg0 , arg1 );	}};
template<typename T> struct fma_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: fma<T>(experimental::declval< T>() , experimental::declval< T>() , experimental::declval< T>())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const T arg1 , const T arg2 )	{		return spirv:: fma<T>( arg0 , arg1 , arg2 );	}};
template<typename T, typename U> struct ldexp_helper<T , U ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: ldexp<T>(experimental::declval< T>() , experimental::declval())), T >),void> >{	using return_t = T;	static inline return_t __call( const T arg0 , const U arg1 )	{		return spirv:: ldexp<T>( arg0 , arg1 );	}};
template<typename T> struct modfStruct_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: modfStruct<T>(experimental::declval< T>())), ModfOutput<T> >),void> >{	using return_t = ModfOutput<T>;	static inline return_t __call( const T arg0 )	{		return spirv:: modfStruct<T>( arg0 );	}};
template<typename T> struct frexpStruct_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: frexpStruct<T>(experimental::declval< T>())), FrexpOutput<T> >),void> >{	using return_t = FrexpOutput<T>;	static inline return_t __call( const T arg0 )	{		return spirv:: frexpStruct<T>( arg0 );	}};

template<typename T> struct isinf_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: isInf<T>(experimental::declval< T>())), conditional_t<is_vector_v<T>, vector<bool, vector_traits<T>::Dimension>, bool> >),void> >{	using return_t = conditional_t<is_vector_v<T>, vector<bool, vector_traits<T>::Dimension>, bool>;	static inline return_t __call( const T arg0 )	{		return spirv:: isInf<T>( arg0 );	}};
template<typename T> struct isnan_helper<T ,::nbl::hlsl::enable_if_t<(is_same_v<__decltype(spirv:: isNan<T>(experimental::declval< T>())), conditional_t<is_vector_v<T>, vector<bool, vector_traits<T>::Dimension>, bool> >),void> >{	using return_t = conditional_t<is_vector_v<T>, vector<bool, vector_traits<T>::Dimension>, bool>;	static inline return_t __call( const T arg0 )	{		return spirv:: isNan<T>( arg0 );	}};

template<typename T> 
struct modf_helper<T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointScalar<T>),void> >
{
	using return_t = T;
	static inline return_t __call(const T x)
	{
		ModfOutput<T> output = modfStruct_helper<T>::__call(x);
		return output.fractionalPart;
	}
};

template<typename T> 
struct modf_helper<T ,::nbl::hlsl::enable_if_t<(concepts::FloatingPoint<T> && is_vector_v<T>),void> >
{
	using return_t = T;
	static inline return_t __call(const T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, modf_helper<typename traits::scalar_type>::__call(getter(x, i)));

return output;
	}
};

template<typename FloatingPoint>

struct erf_helper<FloatingPoint ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointScalar<FloatingPoint>),void> >
{
	static FloatingPoint __call(const in FloatingPoint _x)
	{
		const FloatingPoint a1 = FloatingPoint(0.254829592l);
		const FloatingPoint a2 = FloatingPoint(-0.284496736l);
		const FloatingPoint a3 = FloatingPoint(1.421413741l);
		const FloatingPoint a4 = FloatingPoint(-1.453152027l);
		const FloatingPoint a5 = FloatingPoint(1.061405429l);
		const FloatingPoint p = FloatingPoint(0.3275911l);

FloatingPoint _sign = FloatingPoint(sign(_x));
		FloatingPoint x = abs(_x);

FloatingPoint t = FloatingPoint(1.0l) / (FloatingPoint(1.0l) + p * x);
		FloatingPoint y = FloatingPoint(1.0l) - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * exp(-x * x);

return _sign * y;
	}
};

#line 390 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/impl.hlsl"
// C++ and HLSL specializations

template<typename FloatingPoint>

struct erfInv_helper<FloatingPoint ,::nbl::hlsl::enable_if_t<(concepts::FloatingPointScalar<FloatingPoint>),void> >
{
	static FloatingPoint __call(const in FloatingPoint _x)
	{
		FloatingPoint x = clamp<FloatingPoint>(_x, FloatingPoint(-0.99999l), FloatingPoint(0.99999l));

FloatingPoint w = -log_helper<FloatingPoint>::__call((FloatingPoint(1.0l) - x) * (FloatingPoint(1.0l) + x));
		FloatingPoint p;
		if (w < 5.0)
		{
			w -= FloatingPoint(2.5l);
			p = FloatingPoint(2.81022636e-08l);
			p = FloatingPoint(3.43273939e-07l) + p * w;
			p = FloatingPoint(-3.5233877e-06l) + p * w;
			p = FloatingPoint(-4.39150654e-06l) + p * w;
			p = FloatingPoint(0.00021858087l) + p * w;
			p = FloatingPoint(-0.00125372503l) + p * w;
			p = FloatingPoint(-0.00417768164l) + p * w;
			p = FloatingPoint(0.246640727l) + p * w;
			p = FloatingPoint(1.50140941l) + p * w;
		}
		else
		{
			w = sqrt_helper<FloatingPoint>::__call(w) - FloatingPoint(3.0l);
			p = FloatingPoint(-0.000200214257l);
			p = FloatingPoint(0.000100950558l) + p * w;
			p = FloatingPoint(0.00134934322l) + p * w;
			p = FloatingPoint(-0.00367342844l) + p * w;
			p = FloatingPoint(0.00573950773l) + p * w;
			p = FloatingPoint(-0.0076224613l) + p * w;
			p = FloatingPoint(0.00943887047l) + p * w;
			p = FloatingPoint(1.00167406l) + p * w;
			p = FloatingPoint(2.83297682l) + p * w;
		}
		return p * x;
	}
};

// SPIR-V already defines specializations for builtin vector types

#line 460 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath/impl.hlsl"
template<typename T>struct sqrt_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, sqrt_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct abs_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, abs_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct log_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, log_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct log2_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, log2_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct exp2_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, exp2_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct exp_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, exp_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct floor_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, floor_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};

template<typename T>struct isinf_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = vector<int32_t, vector_traits<T>::Dimension>;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, isinf_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct isnan_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = vector<int32_t, vector_traits<T>::Dimension>;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, isnan_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct cos_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, cos_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct sin_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, sin_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct acos_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, acos_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct tan_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, tan_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct asin_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, asin_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct atan_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, atan_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct sinh_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, sinh_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct cosh_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, cosh_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct tanh_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, tanh_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct asinh_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, asinh_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct acosh_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, acosh_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct atanh_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, atanh_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct modf_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, modf_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct round_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, round_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct roundEven_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, roundEven_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct trunc_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, trunc_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct ceil_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T> && !is_vector_v<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, ceil_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct erf_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, erf_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};
template<typename T>struct erfInv_helper<T ,::nbl::hlsl::enable_if_t<( concepts::Vectorial<T>),void> >{	using return_t = T;	static return_t __call(const in T vec)	{		using traits = hlsl::vector_traits<T>;		using return_t_traits = hlsl::vector_traits<return_t>;		array_get<T, typename traits::scalar_type> getter;		array_set<return_t, typename return_t_traits::scalar_type> setter;		return_t output;		for (uint32_t i = 0; i < traits::Dimension; ++i)			setter(output, i, erfInv_helper<typename traits::scalar_type>::__call(getter(vec, i)));		return output;	}};

template<typename T>

struct pow_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = T;
	static return_t __call(const in T x, const in T y)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;
		
		return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, pow_helper<typename traits::scalar_type>::__call(getter(x, i), getter(y, i)));
	
		return output;
	}
};

template<typename T>

struct fma_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = T;
	static return_t __call(const in T x, const in T y, const in T z)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, fma_helper<typename traits::scalar_type>::__call(getter(x, i), getter(y, i), getter(z, i)));

return output;
	}
};

template<typename T, typename U>

struct ldexp_helper<T, U ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T> && (vector_traits<T>::Dimension == vector_traits::Dimension)),void> >
{
	using return_t = T;
	static return_t __call(const in T arg, const in U exp)
	{
		using arg_traits = hlsl::vector_traits<T>;
		using exp_traits = hlsl::vector_traits;
		array_get<T, typename arg_traits::scalar_type> argGetter;
		array_get<U, typename exp_traits::scalar_type> expGetter;
		array_set<T, typename arg_traits::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < arg_traits::Dimension; ++i)
			setter(output, i, ldexp_helper<typename arg_traits::scalar_type, typename exp_traits::scalar_type>::__call(argGetter(arg, i), expGetter(exp, i)));

return output;
	}
};

template<typename T>

struct modfStruct_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = ModfOutput<T>;
	static return_t __call(const in T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

T fracPartOut;
		T intPartOut;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
		{
			using component_return_t = ModfOutput<typename vector_traits<T>::scalar_type>;
			component_return_t result = modfStruct_helper<typename traits::scalar_type>::__call(getter(x, i));

setter(fracPartOut, i, result.fractionalPart);
			setter(intPartOut, i, result.wholeNumberPart);
		}

return_t output;
		output.fractionalPart = fracPartOut;
		output.wholeNumberPart = intPartOut;

return output;
	}
};

template<typename T>

struct frexpStruct_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = FrexpOutput<T>;
	static return_t __call(const in T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> significandSetter;
		array_set<T, typename traits::scalar_type> exponentSetter;

T significandOut;
		T exponentOut;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
		{
			using component_return_t = FrexpOutput<typename vector_traits<T>::scalar_type>;
			component_return_t result = frexpStruct_helper<typename traits::scalar_type>::__call(getter(x, i));

significandSetter(significandOut, i, result.significand);
			exponentSetter(exponentOut, i, result.exponent);
		}

return_t output;
		output.significand = significandOut;
		output.exponent = exponentOut;

return output;
	}
};

template<typename T>

struct atan2_helper<T ,::nbl::hlsl::enable_if_t<(concepts::Vectorial<T> && !is_vector_v<T>),void> >
{
	using return_t = T;
	static return_t __call(const in T y, const in T x)
	{
		using traits = hlsl::vector_traits<T>;
		array_get<T, typename traits::scalar_type> getter;
		array_set<T, typename traits::scalar_type> setter;

return_t output;
		for (uint32_t i = 0; i < traits::Dimension; ++i)
			setter(output, i, atan2_helper<typename traits::scalar_type>::__call(getter(y, i), getter(x, i)));

return output;
	}
};

}
}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h
#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/concepts/core.hlsl"
// Copyright (C) 2024-2025 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 16 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath.hlsl"
// C++ headers

#line 22 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/tgmath.hlsl"
namespace nbl
{
namespace hlsl
{
template<typename T>
inline T erf(T x)
{
 return tgmath_impl::erf_helper<T>::__call(x);
}

template<typename T>
inline T erfInv(T x)
{
 return tgmath_impl::erfInv_helper<T>::__call(x);
}

template<typename T>
inline T floor(const in T val)
{
 return tgmath_impl::floor_helper<T>::__call(val);
}

template<typename T>
inline typename tgmath_impl::isnan_helper<T>::return_t isnan(const in T val)
{
 return tgmath_impl::isnan_helper<T>::__call(val);
}

template<typename T>
inline typename tgmath_impl::isinf_helper<T>::return_t isinf(const in T val)
{
 return tgmath_impl::isinf_helper<T>::__call(val);
}

template<typename T>
inline T pow(const in T x, const in T y)
{
 return tgmath_impl::pow_helper<T>::__call(x, y);
}

template<typename T>
inline T exp(const in T x)
{
 return tgmath_impl::exp_helper<T>::__call(x);
}

template<typename T>
inline T exp2(const in T x)
{
 return tgmath_impl::exp2_helper<T>::__call(x);
}

template<typename T>
inline T log(const in T x)
{
 return tgmath_impl::log_helper<T>::__call(x);
}

template<typename T>
inline T log2(const in T x)
{
 return tgmath_impl::log2_helper<T>::__call(x);
}

template<typename T>
inline T abs(const in T val)
{
 return tgmath_impl::abs_helper<T>::__call(val);
}

template<typename T>
inline T sqrt(const in T val)
{
 return tgmath_impl::sqrt_helper<T>::__call(val);
}

template<typename T>
inline T sin(const in T val)
{
 return tgmath_impl::sin_helper<T>::__call(val);
}

template<typename T>
inline T cos(const in T val)
{
 return tgmath_impl::cos_helper<T>::__call(val);
}

template<typename T>
inline T acos(const in T val)
{
 return tgmath_impl::acos_helper<T>::__call(val);
}

template<typename T>
inline T tan(const in T val)
{
 return tgmath_impl::tan_helper<T>::__call(val);
}

template<typename T>
inline T asin(const in T val)
{
 return tgmath_impl::asin_helper<T>::__call(val);
}

template<typename T>
inline T atan(const in T val)
{
 return tgmath_impl::atan_helper<T>::__call(val);
}

template<typename T>
inline T sinh(const in T val)
{
 return tgmath_impl::sinh_helper<T>::__call(val);
}

template<typename T>
inline T cosh(const in T val)
{
 return tgmath_impl::cosh_helper<T>::__call(val);
}

template<typename T>
inline T tanh(const in T val)
{
 return tgmath_impl::tanh_helper<T>::__call(val);
}

template<typename T>
inline T asinh(const in T val)
{
 return tgmath_impl::asinh_helper<T>::__call(val);
}

template<typename T>
inline T acosh(const in T val)
{
 return tgmath_impl::acosh_helper<T>::__call(val);
}

template<typename T>
inline T atanh(const in T val)
{
 return tgmath_impl::atanh_helper<T>::__call(val);
}

template<typename T>
inline T atan2(const in T y, const in T x)
{
 return tgmath_impl::atan2_helper<T>::__call(y, x);
}

/**
* @brief Returns fractional part of given floating-point value.
*
* @tparam T type of the value to operate on.
*
* @param [in] val The value to retrive fractional part from.
*/
template<typename T>
inline T modf(const in T val)
{
 return tgmath_impl::modf_helper<T>::__call(val);
}

template<typename T>
inline T round(const in T val)
{
 return tgmath_impl::round_helper<T>::__call(val);
}

template<typename T>
inline T roundEven(const in T val)
{
 return tgmath_impl::roundEven_helper<T>::__call(val);
}

template<typename T>
inline T trunc(const in T val)
{
 return tgmath_impl::trunc_helper<T>::__call(val);
}

template<typename T>
inline T ceil(const in T val)
{
 return tgmath_impl::ceil_helper<T>::__call(val);
}

template<typename T>
inline T fma(const in T x, const in T y, const in T z)
{
 return tgmath_impl::fma_helper<T>::__call(x, y, z);
}

template<typename T, typename U>
inline T ldexp(const in T arg, const in U exp)
{
 return tgmath_impl::ldexp_helper<T, U>::__call(arg, exp);
}

template<typename T>
inline ModfOutput<T> modfStruct(const in T val)
{
 return tgmath_impl::modfStruct_helper<T>::__call(val);
}

template<typename T>
inline FrexpOutput<T> frexpStruct(const in T val)
{
 return tgmath_impl::frexpStruct_helper<T>::__call(val);
}

}
}

#line 10 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/float64_t_impl.hlsl"
// TODO: when it will be possible, use this unions wherever they fit:
/*
* union Mantissa
* {
*   struct
*   {
*       uint32_t highBits;
*       uint64_t lowBits;
*   };
*
*   uint32_t2 packed;
* };
*
*/
/*
* union Mantissa
* {
*   struct
*   {
*       uint64_t lhs;
*       uint64_t rhs;
*   };
*
*   uint32_t4 packed;
* };
*
*/

namespace nbl
{
namespace hlsl
{
namespace emulated_float64_t_impl
{
inline uint64_t2 shiftMantissaLeftBy53(uint64_t mantissa64)
{
 uint64_t2 output;
 output.x = mantissa64 >> (64 - ieee754::traits<float64_t>::mantissaBitCnt);
 output.y = mantissa64 << (ieee754::traits<float64_t>::mantissaBitCnt);

return output;
}

template<bool FlushDenormToZero>
inline uint64_t castFloat32ToStorageType(float32_t val)
{
 if (FlushDenormToZero)
 {
 const uint64_t sign = uint64_t(ieee754::extractSign(val)) << 63;
 if (hlsl::isinf(val))
 return ieee754::traits<float64_t>::inf | sign;
 uint32_t asUint = ieee754::impl::bitCastToUintType(val);
 const int f32BiasedExp = int(ieee754::extractBiasedExponent(val));
 if (f32BiasedExp == 0)
 return sign;
 const uint64_t biasedExp = uint64_t(f32BiasedExp - ieee754::traits<float32_t>::exponentBias + ieee754::traits<float64_t>::exponentBias) << (ieee754::traits<float64_t>::mantissaBitCnt);
 const uint64_t mantissa = (uint64_t(ieee754::traits<float32_t>::mantissaMask) & asUint) << (ieee754::traits<float64_t>::mantissaBitCnt - ieee754::traits<float32_t>::mantissaBitCnt);

return sign | biasedExp | mantissa;
    }
    else
    {
        // static_assert(false);
        return 0xdeadbeefbadcaffeull;
    }
};

inline bool isZero(uint64_t val)
{
 return (val << 1) == 0ull;
}

template<typename T>
inline uint64_t reinterpretAsFloat64BitPattern(T);

template<>
inline uint64_t reinterpretAsFloat64BitPattern<uint64_t>(uint64_t val)
{
 if (isZero(val))
 return val;

int exp = findMSB(val);
    uint64_t mantissa;

int shiftCnt = 52 - exp;
 if (shiftCnt >= 0)
 {
 mantissa = val << shiftCnt;
 }
 else
 {
 const int shiftCntAbs = -shiftCnt;
 uint64_t roundingBit = 1ull << (shiftCnt - 1);
 uint64_t stickyBitMask = roundingBit - 1;
 uint64_t stickyBit = val & stickyBitMask;

mantissa = val >> shiftCntAbs;

if ((val & roundingBit) && (!stickyBit))
        {
            bool isEven = mantissa & 1;
            if (!isEven)
                mantissa++;
        }
        else if ((val & roundingBit) && (stickyBit || (mantissa & 1)))
            val += roundingBit;

//val += (1ull << (shiftCnt)) - 1;
 //mantissa = val >> shiftCntAbs;

if (mantissa & 1ull << 53)
 {
 mantissa >>= 1;
 exp++;
 }
 }
 mantissa &= ieee754::traits<float64_t>::mantissaMask;
 const uint64_t biasedExp = uint64_t(ieee754::traits<float64_t>::exponentBias + exp) << ieee754::traits<float64_t>::mantissaBitCnt;

return biasedExp | mantissa;
};

template<>
inline uint64_t reinterpretAsFloat64BitPattern<int64_t>(int64_t val)
{
 const uint64_t sign = val & ieee754::traits<float64_t>::signMask;
 const uint64_t absVal = uint64_t(abs(val));
 return sign | reinterpretAsFloat64BitPattern(absVal);
};

inline uint64_t flushDenormToZero(uint64_t value)
{
 const uint64_t biasBits = value & ieee754::traits<float64_t>::exponentMask;
 return biasBits ? value : (value & ieee754::traits<float64_t>::signMask);
}

inline uint64_t assembleFloat64(uint64_t signShifted, uint64_t expShifted, uint64_t mantissa)
{
    return  signShifted | expShifted | mantissa;
}

inline bool areBothInfinity(uint64_t lhs, uint64_t rhs)
{
 lhs &= ~ieee754::traits<float64_t>::signMask;
 rhs &= ~ieee754::traits<float64_t>::signMask;

return lhs == rhs && lhs == ieee754::traits<float64_t>::inf;
}

inline bool areBothZero(uint64_t lhs, uint64_t rhs)
{
 return !bool((lhs | rhs) << 1);
}

inline bool areBothSameSignZero(uint64_t lhs, uint64_t rhs)
{
 return !bool((lhs) << 1) && (lhs == rhs);
}

template<bool FastMath, typename Op>
inline bool operatorLessAndGreaterCommonImplementation(uint64_t lhs, uint64_t rhs)
{
 if (!FastMath)
 {
 if (cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(lhs) || cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(rhs))
 return false;
 if (emulated_float64_t_impl::areBothZero(lhs, rhs))
 return false;
 }

const uint64_t lhsSign = ieee754::extractSignPreserveBitPattern(lhs);
    const uint64_t rhsSign = ieee754::extractSignPreserveBitPattern(rhs);

// flip bits of negative numbers and flip signs of all numbers
 if (lhsSign)
 lhs ^= 0x7FFFFFFFFFFFFFFFull;
 if (rhsSign)
 rhs ^= 0x7FFFFFFFFFFFFFFFull;
 lhs ^= ieee754::traits<float64_t>::signMask;
 rhs ^= ieee754::traits<float64_t>::signMask;

Op compare;
    return compare(lhs, rhs);
}

// TODO: remove, use Newton-Raphson instead
// returns pair of quotient and remainder
inline uint64_t divmod128by64(const uint64_t dividentHigh, const uint64_t dividentLow, uint64_t divisor)
{
 const uint64_t b = 1ull << 32;
 uint64_t un1, un0, vn1, vn0, q1, q0, un32, un21, un10, rhat, left, right;
 uint64_t s;

s = countl_zero(divisor);
 divisor <<= s;
 vn1 = divisor >> 32;
 vn0 = divisor & 0xFFFFFFFF;

if (s > 0)
 {
 un32 = (dividentHigh << s) | (dividentLow >> (64 - s));
 un10 = dividentLow << s;
 }
 else
 {
 un32 = dividentHigh;
 un10 = dividentLow;
 }

un1 = un10 >> 32;
    un0 = un10 & 0xFFFFFFFF;

q1 = un32 / vn1;
    rhat = un32 % vn1;

left = q1 * vn0;
 right = (rhat << 32) + un1;
 while ((q1 >= b) || (left > right))
 {
 --q1;
 rhat += vn1;
 if (rhat < b)
 {
 left -= vn0;
 right = (rhat << 32) | un1;
 }
 break;
 }

un21 = (un32 << 32) + (un1 - (q1 * divisor));

q0 = un21 / vn1;
    rhat = un21 % vn1;

left = q0 * vn0;
 right = (rhat << 32) | un0;
 while ((q0 >= b) || (left > right))
 {
 --q0;
 rhat += vn1;
 if (rhat < b)
 {
 left -= vn0;
 right = (rhat << 32) | un0;
 continue;
 }
 break;
 }

return (q1 << 32) | q0;
}

struct uint128_t
{
    uint64_t highBits;
    uint64_t lowBits;
};

inline uint64_t subMantissas128NormalizeResult(const uint64_t greaterNumberMantissa, const uint64_t lesserNumberMantissaHigh, const uint64_t lesserNumberMantissaLow, [[vk::ext_reference]] inout int resultExp)
{
    uint64_t greaterHigh, greaterLow;
    greaterHigh = greaterNumberMantissa;
    greaterLow = 0ull;

uint64_t diffHigh, diffLow;
    diffHigh = greaterHigh - lesserNumberMantissaHigh;
    diffLow = greaterLow - lesserNumberMantissaLow;

if (lesserNumberMantissaLow > greaterLow)
        --diffHigh;

int msbIdx = findMSB(diffHigh);
    if (msbIdx == -1)
    {
        msbIdx = findMSB(diffLow);
        if (msbIdx == -1)
            return 0ull;
    }
    else
    {
        msbIdx += 64;
    }

static const int TargetMSB = 52 + 64;
    int shiftAmount = msbIdx - TargetMSB;
    resultExp += shiftAmount;

if (shiftAmount < 0)
 {
 shiftAmount = -shiftAmount;
 diffHigh <<= shiftAmount;
 const uint64_t shiftedOutBits = diffLow >> (64 - shiftAmount);
 diffHigh |= shiftedOutBits;
 }

return diffHigh;
}

}
}
}

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/float64_t.hlsl"
namespace nbl
{
namespace hlsl
{
    /*enum E_ROUNDING_MODE
    {
        FLOAT_ROUND_NEAREST_EVEN,
        FLOAT_ROUND_TO_ZERO,
        FLOAT_ROUND_DOWN,
        FLOAT_ROUND_UP
    };*/

// currently only FLOAT_ROUND_TO_ZERO is supported, cannot implement partial specialization in this case due to dxc bug https://github.com/microsoft/DirectXShaderCompiler/issues/5563
 // TODO: partial specializations with new template parameter `E_ROUNDING_MODE RoundingMode`
 template<bool FastMath = true, bool FlushDenormToZero = true>
 struct emulated_float64_t
 {
 using storage_t = uint64_t;
 using this_t = emulated_float64_t<FastMath, FlushDenormToZero>;

storage_t data;

template<bool FastMathOther, bool FlushDenormToZeroOther>
 inline static this_t create(emulated_float64_t<FastMathOther, FlushDenormToZeroOther> other)
 {
 if (FlushDenormToZero)
 return bit_cast<this_t>(emulated_float64_t_impl::flushDenormToZero(other.data));
 else
 return bit_cast<this_t>(other.data);
 }

const static this_t create(int32_t val)
 {
 if (FlushDenormToZero)
 return bit_cast<this_t>(emulated_float64_t_impl::flushDenormToZero(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(int64_t(val))));
 else
 return bit_cast<this_t>(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(int64_t(val)));
 }

const static this_t create(int64_t val)
 {
 if (FlushDenormToZero)
 return bit_cast<this_t>(emulated_float64_t_impl::flushDenormToZero(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(val)));
 else
 return bit_cast<this_t>(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(val));
 }

const static this_t create(uint32_t val)
 {
 if (FlushDenormToZero)
 return bit_cast<this_t>(emulated_float64_t_impl::flushDenormToZero(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(uint64_t(val))));
 else
 return bit_cast<this_t>(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(uint64_t(val)));

}

const static this_t create(uint64_t val)
 {
 if (FlushDenormToZero)
 return bit_cast<this_t>(emulated_float64_t_impl::flushDenormToZero(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(val)));
 else
 return bit_cast<this_t>(emulated_float64_t_impl::reinterpretAsFloat64BitPattern(val));

}

const static this_t create(float32_t val)
 {
 this_t output;
 output.data = emulated_float64_t_impl::castFloat32ToStorageType<FlushDenormToZero>(val);
 return output;
 }

const static this_t create(float64_t val)
        {
            this_t retval;

uint32_t lo, hi;
 asuint(val, lo, hi);
 retval.data = emulated_float64_t_impl::flushDenormToZero((uint64_t(hi) << 32) | uint64_t(lo));
 return retval;
#line 91 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/float64_t.hlsl"
 }

// arithmetic operators
 this_t operator+(const this_t rhs) 
 {
 if (FlushDenormToZero)
 {
 if(!FastMath)
 {
 const bool isRhsInf = cpp_compat_intrinsics_impl::isinf_uint_impl(rhs.data);
 if (cpp_compat_intrinsics_impl::isinf_uint_impl(data))
 {
 if (isRhsInf && ((data ^ rhs.data) & ieee754::traits<float64_t>::signMask))
 return bit_cast<this_t>(ieee754::traits<float64_t>::quietNaN | ieee754::traits<float64_t>::signMask);
 return bit_cast<this_t>(data);
 }
 else if (isRhsInf)
 return bit_cast<this_t>(rhs.data);
 }

const int lhsBiasedExp = ieee754::extractBiasedExponent(data);
                const int rhsBiasedExp = ieee754::extractBiasedExponent(rhs.data);

uint64_t lhsSign = ieee754::extractSignPreserveBitPattern(data);
 uint64_t rhsSign = ieee754::extractSignPreserveBitPattern(rhs.data);
 
 if(!FastMath)
 {
 if (cpp_compat_intrinsics_impl::isinf_uint_impl(data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::inf | ieee754::extractSignPreserveBitPattern(max(data, rhs.data)));
 }

const bool isRhsZero = emulated_float64_t_impl::isZero(rhs.data);
 if (emulated_float64_t_impl::isZero(data))
 {
 if(isRhsZero)
 return bit_cast<this_t>((uint64_t(data == rhs.data) << 63) & lhsSign);

return bit_cast<this_t>(emulated_float64_t_impl::flushDenormToZero(rhs.data));
 }
 else if (isRhsZero)
 {
 return bit_cast<this_t>(emulated_float64_t_impl::flushDenormToZero(data));
 }

uint64_t lhsNormMantissa = ieee754::extractNormalizeMantissa(data);
                uint64_t rhsNormMantissa = ieee754::extractNormalizeMantissa(rhs.data);

const int expDiff = lhsBiasedExp - rhsBiasedExp;

int exp = max(lhsBiasedExp, rhsBiasedExp) - ieee754::traits<float64_t>::exponentBias;
 const uint32_t shiftAmount = abs(expDiff);

if (expDiff < 0)
 {
 // so lhsNormMantissa always holds mantissa of number with greater exponent
 swap<uint64_t>(lhsNormMantissa, rhsNormMantissa);
 swap<uint64_t>(lhsSign, rhsSign);
 }

uint64_t resultMantissa;
 if (lhsSign != rhsSign)
 {
 if ((data | ieee754::traits<float64_t>::signMask) == (rhs.data | ieee754::traits<float64_t>::signMask))
 return _static_cast<this_t>(0ull);

uint64_t rhsNormMantissaHigh = shiftAmount >= 64 ? 0ull : rhsNormMantissa >> shiftAmount;
 uint64_t rhsNormMantissaLow = 0ull;
 if (shiftAmount < 128)
 {
 if (shiftAmount >= 64)
 rhsNormMantissaLow = rhsNormMantissa >> (shiftAmount - 64);
 else
 rhsNormMantissaLow = rhsNormMantissa << (64 - shiftAmount);
 }

const int64_t mantissaDiff = int64_t(lhsNormMantissa) - int64_t(rhsNormMantissaHigh);
 // can only happen when shiftAmount == 0, so it is safe to swap only high bits of rhs mantissa
 if (mantissaDiff < 0)
 {
 swap<uint64_t>(lhsNormMantissa, rhsNormMantissaHigh);
 swap<uint64_t>(lhsSign, rhsSign);
 }

resultMantissa = emulated_float64_t_impl::subMantissas128NormalizeResult(lhsNormMantissa, rhsNormMantissaHigh, rhsNormMantissaLow, exp);

if (resultMantissa == 0ull)
 return _static_cast<this_t>(0ull);
 }
 else
 {
 rhsNormMantissa >>= shiftAmount;
 resultMantissa = lhsNormMantissa + rhsNormMantissa;

if (resultMantissa & 1ull << 53)
 {
 ++exp;
 resultMantissa >>= 1;
 }
 }

uint64_t resultBiasedExp = uint64_t(exp) + ieee754::traits<float64_t>::exponentBias;
 resultMantissa &= ieee754::traits<float64_t>::mantissaMask;
 uint64_t output = emulated_float64_t_impl::assembleFloat64(lhsSign, resultBiasedExp << ieee754::traits<float64_t>::mantissaBitCnt, resultMantissa);
 output = emulated_float64_t_impl::flushDenormToZero(output);
 return bit_cast<this_t>(output);
 }

// not implemented
 if (!FlushDenormToZero)
 return bit_cast<this_t>(0xdeadbeefbadcaffeull);
 }

this_t operator+(float rhs)
 {
 return bit_cast<this_t>(data) + create(rhs);
 }

this_t operator-(this_t rhs) 
 {
 this_t lhs = bit_cast<this_t>(data);
 this_t rhsFlipped = rhs.flipSign();
 
 return lhs + rhsFlipped;
 }

this_t operator-(float rhs) 
 {
 return bit_cast<this_t>(data) - create(rhs);
 }

this_t operator*(this_t rhs) 
 {
 if(FlushDenormToZero)
 {
 uint64_t sign = (data ^ rhs.data) & ieee754::traits<float64_t>::signMask;
 if (!FastMath)
 {
 if (cpp_compat_intrinsics_impl::isnan_uint_impl(data) || cpp_compat_intrinsics_impl::isnan_uint_impl(rhs.data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::quietNaN | sign);
 if (cpp_compat_intrinsics_impl::isinf_uint_impl(data) || cpp_compat_intrinsics_impl::isinf_uint_impl(rhs.data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::inf | sign);
 if (emulated_float64_t_impl::isZero(data) || emulated_float64_t_impl::isZero(rhs.data))
 return bit_cast<this_t>(sign);
 }

if (emulated_float64_t_impl::isZero(data) || emulated_float64_t_impl::isZero(rhs.data))
 return bit_cast<this_t>(sign);

this_t retval = this_t::create(0ull);

int lhsBiasedExp = ieee754::extractBiasedExponent(data);
                int rhsBiasedExp = ieee754::extractBiasedExponent(rhs.data);

int exp = int(lhsBiasedExp + rhsBiasedExp) - ieee754::traits<float64_t>::exponentBias;

uint64_t lhsMantissa = ieee754::extractMantissa(data);
                uint64_t rhsMantissa = ieee754::extractMantissa(rhs.data);

const uint64_t hi_l = (lhsMantissa >> 21) | (1ull << 31);
 const uint64_t lo_l = lhsMantissa & ((1ull << 21) - 1);
 const uint64_t hi_r = (rhsMantissa >> 21) | (1ull << 31);
 const uint64_t lo_r = rhsMantissa & ((1ull << 21) - 1);

//const uint64_t RoundToNearest = (1ull << 31) - 1;
 uint64_t newPseudoMantissa = ((hi_l * hi_r) >> 10) + ((hi_l * lo_r + lo_l * hi_r/* + RoundToNearest*/) >> 31);

if (newPseudoMantissa & (0x1ull << 53))
 {
 newPseudoMantissa >>= 1;
 ++exp;
 }
 newPseudoMantissa &= (ieee754::traits<float64_t>::mantissaMask);

uint64_t output = emulated_float64_t_impl::assembleFloat64(sign, uint64_t(exp) << ieee754::traits<float64_t>::mantissaBitCnt, newPseudoMantissa);
 output = emulated_float64_t_impl::flushDenormToZero(output);
 return bit_cast<this_t>(output);
 }
 else
 {
 //static_assert(false, "not implemented yet");
 return bit_cast<this_t>(0xdeadbeefbadcaffeull);
 }
 }

this_t operator*(float rhs)
 {
 return bit_cast<this_t>(data) * create(rhs);
 }

this_t operator/(const this_t rhs) 
 {
 if (FlushDenormToZero)
 {
 const uint64_t sign = (data ^ rhs.data) & ieee754::traits<float64_t>::signMask;

int lhsBiasedExp = ieee754::extractBiasedExponent(data);
                int rhsBiasedExp = ieee754::extractBiasedExponent(rhs.data);

if(!FastMath)
 {
 if (cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(data) || cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(rhs.data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::quietNaN);
 if (emulated_float64_t_impl::areBothZero(data, rhs.data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::quietNaN | sign);
 if (emulated_float64_t_impl::isZero(rhs.data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::inf | sign);
 if (emulated_float64_t_impl::areBothInfinity(data, rhs.data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::quietNaN | ieee754::traits<float64_t>::signMask);
 if (cpp_compat_intrinsics_impl::isinf_uint_impl(data))
 return bit_cast<this_t>(ieee754::traits<float64_t>::inf | sign);
 if (cpp_compat_intrinsics_impl::isinf_uint_impl(rhs.data))
 return bit_cast<this_t>(sign);
 }

if (emulated_float64_t_impl::isZero(data))
 return bit_cast<this_t>(sign);

const uint64_t lhsRealMantissa = (ieee754::extractMantissa(data) | (1ull << ieee754::traits<float64_t>::mantissaBitCnt));
 const uint64_t rhsRealMantissa = ieee754::extractMantissa(rhs.data) | (1ull << ieee754::traits<float64_t>::mantissaBitCnt);

int exp = lhsBiasedExp - rhsBiasedExp + int(ieee754::traits<float64_t>::exponentBias);

uint64_t2 lhsMantissaShifted = emulated_float64_t_impl::shiftMantissaLeftBy53(lhsRealMantissa);
                uint64_t mantissa = emulated_float64_t_impl::divmod128by64(lhsMantissaShifted.x, lhsMantissaShifted.y, rhsRealMantissa);

const int msb = findMSB(mantissa);
 if(msb != -1)
 {
 const int shiftAmount = 52 - msb;
 ;
 mantissa <<= shiftAmount;
 exp -= shiftAmount;
 }

mantissa &= ieee754::traits<float64_t>::mantissaMask;

uint64_t output = emulated_float64_t_impl::assembleFloat64(sign, uint64_t(exp) << ieee754::traits<float64_t>::mantissaBitCnt, mantissa);
 output = emulated_float64_t_impl::flushDenormToZero(output);
 return bit_cast<this_t>(output);
 }
 else
 {
 //static_assert(false, "not implemented yet");
 return bit_cast<this_t>(0xdeadbeefbadcaffeull);
 }
 }

this_t operator/(const float rhs) 
 {
 return bit_cast<this_t>(data) / create(rhs);
 }

// relational operators
 bool operator==(this_t rhs) 
 {
 if (!FastMath)
 {
 if (cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(data) || cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(rhs.data))
 return false;
 if (emulated_float64_t_impl::areBothZero(data, rhs.data))
 return true;
 }

return data == rhs.data;
 }
 bool operator!=(this_t rhs) 
 {
 if (!FastMath && (cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(data) || cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(rhs.data)))
 return false;

return !(bit_cast<this_t>(data) == rhs);
 }
 bool operator<(this_t rhs) 
 {
 return emulated_float64_t_impl::operatorLessAndGreaterCommonImplementation<FastMath, hlsl::less<uint64_t> >(data, rhs.data);
 }
 bool operator>(this_t rhs) 
 {
 return emulated_float64_t_impl::operatorLessAndGreaterCommonImplementation<FastMath, hlsl::greater<uint64_t> >(data, rhs.data);
 }
 bool operator<=(this_t rhs) 
 { 
 if (!FastMath && (cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(data) || cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(rhs.data)))
 return false;

return !(bit_cast<this_t>(data) > bit_cast<this_t>(rhs.data));
 }
 bool operator>=(this_t rhs)
 {
 if (!FastMath && (cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(data) || cpp_compat_intrinsics_impl::isnan_uint_impl<uint64_t>(rhs.data)))
 return false;

return !(bit_cast<this_t>(data) < bit_cast<this_t>(rhs.data));
 }

this_t flipSign()
 {
 return bit_cast<this_t>(data ^ ieee754::traits<float64_t>::signMask);
 }

const static bool isFastMathSupported = FastMath;
    };

#line 471 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/float64_t.hlsl"
namespace impl
{

template<typename To, bool FastMath, bool FlushDenormToZero>
struct static_cast_helper<To,emulated_float64_t<FastMath,FlushDenormToZero>,void>
{
 _Static_assert(is_scalar<To>::value);

using From = emulated_float64_t<FastMath,FlushDenormToZero>;
 
 static inline To cast(From v)
 {
 using ToAsFloat = typename float_of_size<sizeof(To)>::type;
 using ToAsUint = typename unsigned_integer_of_size<sizeof(To)>::type;

if (emulated_float64_t_impl::isZero(v.data))
            return 0;

if (is_same_v<To, float64_t>)
 return To(bit_cast<float64_t>(v.data));

if (is_floating_point<To>::value)
 {
 const int exponent = ieee754::extractExponent(v.data);
 if (!From::isFastMathSupported)
 {
 if (exponent > ieee754::traits<ToAsFloat>::exponentMax)
 return bit_cast<To>(ieee754::traits<ToAsFloat>::inf);
 if (exponent < ieee754::traits<ToAsFloat>::exponentMin)
 return bit_cast<To>(-ieee754::traits<ToAsFloat>::inf);
 if (cpp_compat_intrinsics_impl::isinf_uint_impl(v.data))
 return bit_cast<To>(ieee754::traits<ToAsFloat>::quietNaN);
 }

const uint32_t toBitSize = sizeof(To) * 8;
 const ToAsUint sign = ToAsUint(ieee754::extractSign(v.data) << (toBitSize - 1));
 const ToAsUint biasedExponent = ToAsUint(exponent + ieee754::traits<ToAsFloat>::exponentBias) << ieee754::traits<ToAsFloat>::mantissaBitCnt;
 const ToAsUint mantissa = ToAsUint(v.data >> (ieee754::traits<float64_t>::mantissaBitCnt - ieee754::traits<ToAsFloat>::mantissaBitCnt)) & ieee754::traits<ToAsFloat>::mantissaMask;

return bit_cast<ToAsFloat>(sign | biasedExponent | mantissa);
 }

// NOTE: casting from negative float to unsigned int is an UB, function will return abs value in this case
 if (is_integral<To>::value)
 {
 const int exponent = ieee754::extractExponent(v.data);
 if (exponent < 0)
 return 0;

uint64_t unsignedOutput = ieee754::extractMantissa(v.data) | 1ull << ieee754::traits<float64_t>::mantissaBitCnt;
 const int shiftAmount = exponent - int(ieee754::traits<float64_t>::mantissaBitCnt);

if (shiftAmount < 0)
 unsignedOutput >>= -shiftAmount;
 else
 unsignedOutput <<= shiftAmount;

if (is_signed<To>::value)
 {
 int64_t signedOutput64 = unsignedOutput & ((1ull << 63) - 1);
 To signedOutput = To(signedOutput64);
 if (ieee754::extractSignPreserveBitPattern(v.data) != 0)
 signedOutput = -signedOutput;

return signedOutput;
            }

return To(unsignedOutput);
        }

// assert(false);
        return To(0xdeadbeefbadcaffeull);
    }
};

template<typename From, bool FastMath, bool FlushDenormToZero>
struct static_cast_helper<emulated_float64_t<FastMath, FlushDenormToZero>, From, void>
{
 using To = emulated_float64_t<FastMath, FlushDenormToZero>;

static inline To cast(From v)
    {
        return To::create(v);
    }
};

template<bool FastMath, bool FlushDenormToZero>
struct static_cast_helper<emulated_float64_t<FastMath, FlushDenormToZero>, emulated_float64_t<FastMath, FlushDenormToZero>, void>
{
 static inline emulated_float64_t<FastMath, FlushDenormToZero> cast(emulated_float64_t<FastMath, FlushDenormToZero> v)
 {
 return v;
 }
};

}

template<>inline emulated_float64_t<true, true> bit_cast<emulated_float64_t<true, true>, uint64_t>(const in uint64_t val){emulated_float64_t<true, true> output;output.data = val;return output;}template<>inline emulated_float64_t<true, true> bit_cast<emulated_float64_t<true, true>, float64_t>(const in float64_t val){emulated_float64_t<true, true> output;output.data = bit_cast<uint64_t>(val);return output;}template<>inline uint64_t bit_cast<uint64_t, emulated_float64_t<true, true> >(const in emulated_float64_t<true, true> val){return val.data;}template<>inline float64_t bit_cast<float64_t, emulated_float64_t<true, true> >(const in emulated_float64_t<true, true> val){return bit_cast<float64_t>(val.data);};
template<>inline emulated_float64_t<false, false> bit_cast<emulated_float64_t<false, false>, uint64_t>(const in uint64_t val){emulated_float64_t<false, false> output;output.data = val;return output;}template<>inline emulated_float64_t<false, false> bit_cast<emulated_float64_t<false, false>, float64_t>(const in float64_t val){emulated_float64_t<false, false> output;output.data = bit_cast<uint64_t>(val);return output;}template<>inline uint64_t bit_cast<uint64_t, emulated_float64_t<false, false> >(const in emulated_float64_t<false, false> val){return val.data;}template<>inline float64_t bit_cast<float64_t, emulated_float64_t<false, false> >(const in emulated_float64_t<false, false> val){return bit_cast<float64_t>(val.data);};
template<>inline emulated_float64_t<true, false> bit_cast<emulated_float64_t<true, false>, uint64_t>(const in uint64_t val){emulated_float64_t<true, false> output;output.data = val;return output;}template<>inline emulated_float64_t<true, false> bit_cast<emulated_float64_t<true, false>, float64_t>(const in float64_t val){emulated_float64_t<true, false> output;output.data = bit_cast<uint64_t>(val);return output;}template<>inline uint64_t bit_cast<uint64_t, emulated_float64_t<true, false> >(const in emulated_float64_t<true, false> val){return val.data;}template<>inline float64_t bit_cast<float64_t, emulated_float64_t<true, false> >(const in emulated_float64_t<true, false> val){return bit_cast<float64_t>(val.data);};
template<>inline emulated_float64_t<false, true> bit_cast<emulated_float64_t<false, true>, uint64_t>(const in uint64_t val){emulated_float64_t<false, true> output;output.data = val;return output;}template<>inline emulated_float64_t<false, true> bit_cast<emulated_float64_t<false, true>, float64_t>(const in float64_t val){emulated_float64_t<false, true> output;output.data = bit_cast<uint64_t>(val);return output;}template<>inline uint64_t bit_cast<uint64_t, emulated_float64_t<false, true> >(const in emulated_float64_t<false, true> val){return val.data;}template<>inline float64_t bit_cast<float64_t, emulated_float64_t<false, true> >(const in emulated_float64_t<false, true> val){return bit_cast<float64_t>(val.data);};

//template<bool FastMath, bool FlushDenormToZero>
//struct is_floating_point<emulated_float64_t<FastMath, FlushDenormToZero> > : bool_constant<true> {};

namespace ieee754
{
namespace impl
{
template<> inline uint64_t bitCastToUintType(emulated_float64_t<true, true> x) { return x.data; }
template<> inline uint64_t bitCastToUintType(emulated_float64_t<false, false> x) { return x.data; }
template<> inline uint64_t bitCastToUintType(emulated_float64_t<true, false> x) { return x.data; }
template<> inline uint64_t bitCastToUintType(emulated_float64_t<false, true> x) { return x.data; }
}

template<>struct traits_base<emulated_float64_t<true, true> >{ const static int16_t exponentBitCnt = 11; const static int16_t mantissaBitCnt = 52;};template<>inline uint32_t extractBiasedExponent(emulated_float64_t<true, true> x){ return extractBiasedExponent<uint64_t>(x.data);}template<>inline int extractExponent(emulated_float64_t<true, true> x){ return extractExponent(x.data);}template<>inline emulated_float64_t<true, true> replaceBiasedExponent(emulated_float64_t<true, true> x, typename unsigned_integer_of_size<sizeof(emulated_float64_t<true, true>)>::type biasedExp){ return emulated_float64_t<true, true>(replaceBiasedExponent(x.data, biasedExp));}template <>inline emulated_float64_t<true, true> fastMulExp2(emulated_float64_t<true, true> x, int n){ return emulated_float64_t<true, true>(replaceBiasedExponent(x.data, extractBiasedExponent(x) + uint32_t(n)));}template <>inline unsigned_integer_of_size<sizeof(emulated_float64_t<true, true>)>::type extractMantissa(emulated_float64_t<true, true> x){ return extractMantissa(x.data);}template <>inline uint64_t extractNormalizeMantissa(emulated_float64_t<true, true> x){ return extractNormalizeMantissa(x.data);};
template<>struct traits_base<emulated_float64_t<false, false> >{ const static int16_t exponentBitCnt = 11; const static int16_t mantissaBitCnt = 52;};template<>inline uint32_t extractBiasedExponent(emulated_float64_t<false, false> x){ return extractBiasedExponent<uint64_t>(x.data);}template<>inline int extractExponent(emulated_float64_t<false, false> x){ return extractExponent(x.data);}template<>inline emulated_float64_t<false, false> replaceBiasedExponent(emulated_float64_t<false, false> x, typename unsigned_integer_of_size<sizeof(emulated_float64_t<false, false>)>::type biasedExp){ return emulated_float64_t<false, false>(replaceBiasedExponent(x.data, biasedExp));}template <>inline emulated_float64_t<false, false> fastMulExp2(emulated_float64_t<false, false> x, int n){ return emulated_float64_t<false, false>(replaceBiasedExponent(x.data, extractBiasedExponent(x) + uint32_t(n)));}template <>inline unsigned_integer_of_size<sizeof(emulated_float64_t<false, false>)>::type extractMantissa(emulated_float64_t<false, false> x){ return extractMantissa(x.data);}template <>inline uint64_t extractNormalizeMantissa(emulated_float64_t<false, false> x){ return extractNormalizeMantissa(x.data);};
template<>struct traits_base<emulated_float64_t<true, false> >{ const static int16_t exponentBitCnt = 11; const static int16_t mantissaBitCnt = 52;};template<>inline uint32_t extractBiasedExponent(emulated_float64_t<true, false> x){ return extractBiasedExponent<uint64_t>(x.data);}template<>inline int extractExponent(emulated_float64_t<true, false> x){ return extractExponent(x.data);}template<>inline emulated_float64_t<true, false> replaceBiasedExponent(emulated_float64_t<true, false> x, typename unsigned_integer_of_size<sizeof(emulated_float64_t<true, false>)>::type biasedExp){ return emulated_float64_t<true, false>(replaceBiasedExponent(x.data, biasedExp));}template <>inline emulated_float64_t<true, false> fastMulExp2(emulated_float64_t<true, false> x, int n){ return emulated_float64_t<true, false>(replaceBiasedExponent(x.data, extractBiasedExponent(x) + uint32_t(n)));}template <>inline unsigned_integer_of_size<sizeof(emulated_float64_t<true, false>)>::type extractMantissa(emulated_float64_t<true, false> x){ return extractMantissa(x.data);}template <>inline uint64_t extractNormalizeMantissa(emulated_float64_t<true, false> x){ return extractNormalizeMantissa(x.data);};
template<>struct traits_base<emulated_float64_t<false, true> >{ const static int16_t exponentBitCnt = 11; const static int16_t mantissaBitCnt = 52;};template<>inline uint32_t extractBiasedExponent(emulated_float64_t<false, true> x){ return extractBiasedExponent<uint64_t>(x.data);}template<>inline int extractExponent(emulated_float64_t<false, true> x){ return extractExponent(x.data);}template<>inline emulated_float64_t<false, true> replaceBiasedExponent(emulated_float64_t<false, true> x, typename unsigned_integer_of_size<sizeof(emulated_float64_t<false, true>)>::type biasedExp){ return emulated_float64_t<false, true>(replaceBiasedExponent(x.data, biasedExp));}template <>inline emulated_float64_t<false, true> fastMulExp2(emulated_float64_t<false, true> x, int n){ return emulated_float64_t<false, true>(replaceBiasedExponent(x.data, extractBiasedExponent(x) + uint32_t(n)));}template <>inline unsigned_integer_of_size<sizeof(emulated_float64_t<false, true>)>::type extractMantissa(emulated_float64_t<false, true> x){ return extractMantissa(x.data);}template <>inline uint64_t extractNormalizeMantissa(emulated_float64_t<false, true> x){ return extractNormalizeMantissa(x.data);};
}

namespace concepts
{
namespace impl
{
template<bool FastMath, bool FlushDenormToZero>
struct is_emulating_floating_point_scalar<emulated_float64_t<FastMath, FlushDenormToZero> >
{
 const static bool value = true;
};
}
}

}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/device_capabilities_traits.hlsl"
// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/member_test_macros.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/member_test_macros.hlsl"
namespace nbl
{
namespace hlsl
{

namespace impl
{

enum e_member_presence
{
 is_present = 1<<0,
 is_static = 1<<1,
 is_const = 1<<2,
};

template<bool=false>
struct if_2_else_1 : integral_constant<uint32_t,1> {};
template<>
struct if_2_else_1<true> : integral_constant<uint32_t,2> {};

}

typedef impl::e_member_presence e_member_presence;
}

}

#line 62 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/member_test_macros.hlsl"
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_x: false_type { }; template<class T> struct is_static_member_x<T,typename enable_if<!is_same<__decltype(T::x),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_x: false_type { using type = void; }; template<class T> struct is_member_x<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().x),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().x); }; } template<class T> struct has_member_x { const static e_member_presence value = (e_member_presence)(impl::is_member_x<T>::value + 2*impl::is_static_member_x<T>::value + 4*is_const<typename impl::is_member_x<T>::type>::value); }; template<class T, class F> struct has_member_x_with_type : bool_constant<has_member_x<T>::value && is_same<typename impl::is_member_x<T>::type, F>::value> {}; } }
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_y: false_type { }; template<class T> struct is_static_member_y<T,typename enable_if<!is_same<__decltype(T::y),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_y: false_type { using type = void; }; template<class T> struct is_member_y<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().y),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().y); }; } template<class T> struct has_member_y { const static e_member_presence value = (e_member_presence)(impl::is_member_y<T>::value + 2*impl::is_static_member_y<T>::value + 4*is_const<typename impl::is_member_y<T>::type>::value); }; template<class T, class F> struct has_member_y_with_type : bool_constant<has_member_y<T>::value && is_same<typename impl::is_member_y<T>::type, F>::value> {}; } }
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_z: false_type { }; template<class T> struct is_static_member_z<T,typename enable_if<!is_same<__decltype(T::z),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_z: false_type { using type = void; }; template<class T> struct is_member_z<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().z),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().z); }; } template<class T> struct has_member_z { const static e_member_presence value = (e_member_presence)(impl::is_member_z<T>::value + 2*impl::is_static_member_z<T>::value + 4*is_const<typename impl::is_member_z<T>::type>::value); }; template<class T, class F> struct has_member_z_with_type : bool_constant<has_member_z<T>::value && is_same<typename impl::is_member_z<T>::type, F>::value> {}; } }
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_w: false_type { }; template<class T> struct is_static_member_w<T,typename enable_if<!is_same<__decltype(T::w),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_w: false_type { using type = void; }; template<class T> struct is_member_w<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().w),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().w); }; } template<class T> struct has_member_w { const static e_member_presence value = (e_member_presence)(impl::is_member_w<T>::value + 2*impl::is_static_member_w<T>::value + 4*is_const<typename impl::is_member_w<T>::type>::value); }; template<class T, class F> struct has_member_w_with_type : bool_constant<has_member_w<T>::value && is_same<typename impl::is_member_w<T>::type, F>::value> {}; } }

#line 95 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/member_test_macros.hlsl"
/* 
    types that are impilicitly convertible to each other mess this check up

struct S
    {
        void a(int) { return 0;}
    };

has_method_a<S, float>::value will be true 
 since float is implicitly convertible to int and
 due to how we check function signatures at the moment
*/

// TODO: these should probably generate without a namespace and be expected to be put inside a namespace

#line 119 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/member_test_macros.hlsl"
namespace nbl { namespace hlsl { namespace impl { template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_static_method_a : false_type {}; template<class T > struct has_static_method_a<T , typename make_void<__decltype(T::a())>::type> : true_type { using return_type = __decltype(T::a()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_static_method_a<T , Arg0, typename make_void<__decltype(T::a(experimental::declval<Arg0>()))>::type> : true_type { using return_type = __decltype(T::a(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_static_method_a<T , Arg0 , Arg1, typename make_void<__decltype(T::a(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : true_type { using return_type = __decltype(T::a(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_static_method_a<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(T::a(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : true_type { using return_type = __decltype(T::a(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; } template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_method_a : false_type {}; template<class T > struct has_method_a<T , typename make_void<__decltype(experimental::declval<T>().a())>::type> : impl::if_2_else_1<impl::has_static_method_a<T >::value> { using return_type = __decltype(experimental::declval<T>().a()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_method_a<T , Arg0, typename make_void<__decltype(experimental::declval<T>().a(experimental::declval<Arg0>()))>::type> : impl::if_2_else_1<impl::has_static_method_a<T , Arg0>::value> { using return_type = __decltype(experimental::declval<T>().a(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_method_a<T , Arg0 , Arg1, typename make_void<__decltype(experimental::declval<T>().a(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : impl::if_2_else_1<impl::has_static_method_a<T , Arg0 , Arg1>::value> { using return_type = __decltype(experimental::declval<T>().a(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_method_a<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(experimental::declval<T>().a(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : impl::if_2_else_1<impl::has_static_method_a<T , Arg0 , Arg1 , Arg2>::value> { using return_type = __decltype(experimental::declval<T>().a(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; }} // TODO: remove
namespace nbl { namespace hlsl { namespace impl { template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_static_method_b : false_type {}; template<class T > struct has_static_method_b<T , typename make_void<__decltype(T::b())>::type> : true_type { using return_type = __decltype(T::b()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_static_method_b<T , Arg0, typename make_void<__decltype(T::b(experimental::declval<Arg0>()))>::type> : true_type { using return_type = __decltype(T::b(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_static_method_b<T , Arg0 , Arg1, typename make_void<__decltype(T::b(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : true_type { using return_type = __decltype(T::b(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_static_method_b<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(T::b(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : true_type { using return_type = __decltype(T::b(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; } template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_method_b : false_type {}; template<class T > struct has_method_b<T , typename make_void<__decltype(experimental::declval<T>().b())>::type> : impl::if_2_else_1<impl::has_static_method_b<T >::value> { using return_type = __decltype(experimental::declval<T>().b()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_method_b<T , Arg0, typename make_void<__decltype(experimental::declval<T>().b(experimental::declval<Arg0>()))>::type> : impl::if_2_else_1<impl::has_static_method_b<T , Arg0>::value> { using return_type = __decltype(experimental::declval<T>().b(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_method_b<T , Arg0 , Arg1, typename make_void<__decltype(experimental::declval<T>().b(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : impl::if_2_else_1<impl::has_static_method_b<T , Arg0 , Arg1>::value> { using return_type = __decltype(experimental::declval<T>().b(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_method_b<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(experimental::declval<T>().b(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : impl::if_2_else_1<impl::has_static_method_b<T , Arg0 , Arg1 , Arg2>::value> { using return_type = __decltype(experimental::declval<T>().b(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; }} // TODO: remove
namespace nbl { namespace hlsl { namespace impl { template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_static_method_get : false_type {}; template<class T > struct has_static_method_get<T , typename make_void<__decltype(T::get())>::type> : true_type { using return_type = __decltype(T::get()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_static_method_get<T , Arg0, typename make_void<__decltype(T::get(experimental::declval<Arg0>()))>::type> : true_type { using return_type = __decltype(T::get(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_static_method_get<T , Arg0 , Arg1, typename make_void<__decltype(T::get(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : true_type { using return_type = __decltype(T::get(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_static_method_get<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(T::get(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : true_type { using return_type = __decltype(T::get(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; } template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_method_get : false_type {}; template<class T > struct has_method_get<T , typename make_void<__decltype(experimental::declval<T>().get())>::type> : impl::if_2_else_1<impl::has_static_method_get<T >::value> { using return_type = __decltype(experimental::declval<T>().get()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_method_get<T , Arg0, typename make_void<__decltype(experimental::declval<T>().get(experimental::declval<Arg0>()))>::type> : impl::if_2_else_1<impl::has_static_method_get<T , Arg0>::value> { using return_type = __decltype(experimental::declval<T>().get(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_method_get<T , Arg0 , Arg1, typename make_void<__decltype(experimental::declval<T>().get(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : impl::if_2_else_1<impl::has_static_method_get<T , Arg0 , Arg1>::value> { using return_type = __decltype(experimental::declval<T>().get(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_method_get<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(experimental::declval<T>().get(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : impl::if_2_else_1<impl::has_static_method_get<T , Arg0 , Arg1 , Arg2>::value> { using return_type = __decltype(experimental::declval<T>().get(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; }}
namespace nbl { namespace hlsl { namespace impl { template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_static_method_set : false_type {}; template<class T > struct has_static_method_set<T , typename make_void<__decltype(T::set())>::type> : true_type { using return_type = __decltype(T::set()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_static_method_set<T , Arg0, typename make_void<__decltype(T::set(experimental::declval<Arg0>()))>::type> : true_type { using return_type = __decltype(T::set(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_static_method_set<T , Arg0 , Arg1, typename make_void<__decltype(T::set(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : true_type { using return_type = __decltype(T::set(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_static_method_set<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(T::set(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : true_type { using return_type = __decltype(T::set(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; } template<typename T , typename Arg0=void , typename Arg1=void , typename Arg2=void , typename Arg3=void, class=void> struct has_method_set : false_type {}; template<class T > struct has_method_set<T , typename make_void<__decltype(experimental::declval<T>().set())>::type> : impl::if_2_else_1<impl::has_static_method_set<T >::value> { using return_type = __decltype(experimental::declval<T>().set()); const static uint arg_count = 0; }; template<class T , typename Arg0> struct has_method_set<T , Arg0, typename make_void<__decltype(experimental::declval<T>().set(experimental::declval<Arg0>()))>::type> : impl::if_2_else_1<impl::has_static_method_set<T , Arg0>::value> { using return_type = __decltype(experimental::declval<T>().set(experimental::declval<Arg0>())); const static uint arg_count = 1; }; template<class T , typename Arg0 , typename Arg1> struct has_method_set<T , Arg0 , Arg1, typename make_void<__decltype(experimental::declval<T>().set(experimental::declval<Arg0>() , experimental::declval<Arg1>()))>::type> : impl::if_2_else_1<impl::has_static_method_set<T , Arg0 , Arg1>::value> { using return_type = __decltype(experimental::declval<T>().set(experimental::declval<Arg0>() , experimental::declval<Arg1>())); const static uint arg_count = 2; }; template<class T , typename Arg0 , typename Arg1 , typename Arg2> struct has_method_set<T , Arg0 , Arg1 , Arg2, typename make_void<__decltype(experimental::declval<T>().set(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>()))>::type> : impl::if_2_else_1<impl::has_static_method_set<T , Arg0 , Arg1 , Arg2>::value> { using return_type = __decltype(experimental::declval<T>().set(experimental::declval<Arg0>() , experimental::declval<Arg1>() , experimental::declval<Arg2>())); const static uint arg_count = 3; }; }}

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/limits.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 1 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/enums.hlsl"
// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
// This file is part of the "Nabla Engine".
// For conditions of distribution and use, see copyright notice in nabla.h

#line 8 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/enums.hlsl"
namespace nbl
{
namespace hlsl
{

// TODO: make this enum class
enum ShaderStage : uint32_t
{
 ESS_UNKNOWN = 0,
 ESS_VERTEX = 1 << 0,
 ESS_TESSELLATION_CONTROL = 1 << 1,
 ESS_TESSELLATION_EVALUATION = 1 << 2,
 ESS_GEOMETRY = 1 << 3,
 ESS_FRAGMENT = 1 << 4,
 ESS_COMPUTE = 1 << 5,
 ESS_TASK = 1 << 6,
 ESS_MESH = 1 << 7,
 ESS_RAYGEN = 1 << 8,
 ESS_ANY_HIT = 1 << 9,
 ESS_CLOSEST_HIT = 1 << 10,
 ESS_MISS = 1 << 11,
 ESS_INTERSECTION = 1 << 12,
 ESS_CALLABLE = 1 << 13,
 ESS_ALL_GRAPHICS = 0x0000001F,
 ESS_ALL_OR_LIBRARY = 0x7fffffff
};

enum TextureClamp : uint16_t
{
    //! Texture repeats
    ETC_REPEAT = 0,
    //! Texture is clamped to the edge pixel
    ETC_CLAMP_TO_EDGE,
    //! Texture is clamped to the border pixel (if exists)
    ETC_CLAMP_TO_BORDER,
    //! Texture is alternatingly mirrored (0..1..0..1..0..)
    ETC_MIRROR,
    //! Texture is mirrored once and then clamped to edge
    ETC_MIRROR_CLAMP_TO_EDGE,

ETC_COUNT
};

enum SampleCountFlags : uint16_t
{
    ESCF_1_BIT = 0x01,
	ESCF_2_BIT = 0x02,
	ESCF_4_BIT = 0x04,
	ESCF_8_BIT = 0x08,
	ESCF_16_BIT = 0x10,
	ESCF_32_BIT = 0x20,
	ESCF_64_BIT = 0x40
};
        
enum ResolveModeFlags : uint16_t
{
    NONE = 0,
    SAMPLE_ZERO_BIT = 0x00000001,
    AVERAGE_BIT = 0x00000002,
    MIN_BIT = 0x00000004,
    MAX_BIT = 0x00000008
};

enum SpirvVersion : uint32_t
{
    ESV_1_0 = 0x010000u,
    ESV_1_1 = 0x010100u,
    ESV_1_2 = 0x010200u,
    ESV_1_3 = 0x010300u,
    ESV_1_4 = 0x010400u,
    ESV_1_5 = 0x010500u,
    ESV_1_6 = 0x010600u,
};

enum PointClippingBehavior : uint16_t {
    EPCB_ALL_CLIP_PLANES = 0,
    EPCB_USER_CLIP_PLANES_ONLY = 1,
};

enum SwapchainMode : uint16_t {
    ESM_NONE = 0,
    ESM_SURFACE = 0x01
};

#line 101 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/enums.hlsl"
}
}

#line 1 "C:/Users/fjlet/Desktop/Nabla/build/src/nbl/device/include/nbl/video/device_capabilities_traits_testers.hlsl"
// Limits Testers
// VK 1.0
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxImageDimension1D: false_type { }; template<class T> struct is_static_member_maxImageDimension1D<T,typename enable_if<!is_same<__decltype(T::maxImageDimension1D),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxImageDimension1D: false_type { using type = void; }; template<class T> struct is_member_maxImageDimension1D<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxImageDimension1D),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxImageDimension1D); }; } template<class T> struct has_member_maxImageDimension1D { const static e_member_presence value = (e_member_presence)(impl::is_member_maxImageDimension1D<T>::value + 2*impl::is_static_member_maxImageDimension1D<T>::value + 4*is_const<typename impl::is_member_maxImageDimension1D<T>::type>::value); }; template<class T, class F> struct has_member_maxImageDimension1D_with_type : bool_constant<has_member_maxImageDimension1D<T>::value && is_same<typename impl::is_member_maxImageDimension1D<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxImageDimension2D: false_type { }; template<class T> struct is_static_member_maxImageDimension2D<T,typename enable_if<!is_same<__decltype(T::maxImageDimension2D),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxImageDimension2D: false_type { using type = void; }; template<class T> struct is_member_maxImageDimension2D<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxImageDimension2D),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxImageDimension2D); }; } template<class T> struct has_member_maxImageDimension2D { const static e_member_presence value = (e_member_presence)(impl::is_member_maxImageDimension2D<T>::value + 2*impl::is_static_member_maxImageDimension2D<T>::value + 4*is_const<typename impl::is_member_maxImageDimension2D<T>::type>::value); }; template<class T, class F> struct has_member_maxImageDimension2D_with_type : bool_constant<has_member_maxImageDimension2D<T>::value && is_same<typename impl::is_member_maxImageDimension2D<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxImageDimension3D: false_type { }; template<class T> struct is_static_member_maxImageDimension3D<T,typename enable_if<!is_same<__decltype(T::maxImageDimension3D),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxImageDimension3D: false_type { using type = void; }; template<class T> struct is_member_maxImageDimension3D<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxImageDimension3D),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxImageDimension3D); }; } template<class T> struct has_member_maxImageDimension3D { const static e_member_presence value = (e_member_presence)(impl::is_member_maxImageDimension3D<T>::value + 2*impl::is_static_member_maxImageDimension3D<T>::value + 4*is_const<typename impl::is_member_maxImageDimension3D<T>::type>::value); }; template<class T, class F> struct has_member_maxImageDimension3D_with_type : bool_constant<has_member_maxImageDimension3D<T>::value && is_same<typename impl::is_member_maxImageDimension3D<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxImageDimensionCube: false_type { }; template<class T> struct is_static_member_maxImageDimensionCube<T,typename enable_if<!is_same<__decltype(T::maxImageDimensionCube),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxImageDimensionCube: false_type { using type = void; }; template<class T> struct is_member_maxImageDimensionCube<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxImageDimensionCube),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxImageDimensionCube); }; } template<class T> struct has_member_maxImageDimensionCube { const static e_member_presence value = (e_member_presence)(impl::is_member_maxImageDimensionCube<T>::value + 2*impl::is_static_member_maxImageDimensionCube<T>::value + 4*is_const<typename impl::is_member_maxImageDimensionCube<T>::type>::value); }; template<class T, class F> struct has_member_maxImageDimensionCube_with_type : bool_constant<has_member_maxImageDimensionCube<T>::value && is_same<typename impl::is_member_maxImageDimensionCube<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxImageArrayLayers: false_type { }; template<class T> struct is_static_member_maxImageArrayLayers<T,typename enable_if<!is_same<__decltype(T::maxImageArrayLayers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxImageArrayLayers: false_type { using type = void; }; template<class T> struct is_member_maxImageArrayLayers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxImageArrayLayers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxImageArrayLayers); }; } template<class T> struct has_member_maxImageArrayLayers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxImageArrayLayers<T>::value + 2*impl::is_static_member_maxImageArrayLayers<T>::value + 4*is_const<typename impl::is_member_maxImageArrayLayers<T>::type>::value); }; template<class T, class F> struct has_member_maxImageArrayLayers_with_type : bool_constant<has_member_maxImageArrayLayers<T>::value && is_same<typename impl::is_member_maxImageArrayLayers<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxBufferViewTexels: false_type { }; template<class T> struct is_static_member_maxBufferViewTexels<T,typename enable_if<!is_same<__decltype(T::maxBufferViewTexels),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxBufferViewTexels: false_type { using type = void; }; template<class T> struct is_member_maxBufferViewTexels<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxBufferViewTexels),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxBufferViewTexels); }; } template<class T> struct has_member_maxBufferViewTexels { const static e_member_presence value = (e_member_presence)(impl::is_member_maxBufferViewTexels<T>::value + 2*impl::is_static_member_maxBufferViewTexels<T>::value + 4*is_const<typename impl::is_member_maxBufferViewTexels<T>::type>::value); }; template<class T, class F> struct has_member_maxBufferViewTexels_with_type : bool_constant<has_member_maxBufferViewTexels<T>::value && is_same<typename impl::is_member_maxBufferViewTexels<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxUBOSize: false_type { }; template<class T> struct is_static_member_maxUBOSize<T,typename enable_if<!is_same<__decltype(T::maxUBOSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxUBOSize: false_type { using type = void; }; template<class T> struct is_member_maxUBOSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxUBOSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxUBOSize); }; } template<class T> struct has_member_maxUBOSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxUBOSize<T>::value + 2*impl::is_static_member_maxUBOSize<T>::value + 4*is_const<typename impl::is_member_maxUBOSize<T>::type>::value); }; template<class T, class F> struct has_member_maxUBOSize_with_type : bool_constant<has_member_maxUBOSize<T>::value && is_same<typename impl::is_member_maxUBOSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSSBOSize: false_type { }; template<class T> struct is_static_member_maxSSBOSize<T,typename enable_if<!is_same<__decltype(T::maxSSBOSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSSBOSize: false_type { using type = void; }; template<class T> struct is_member_maxSSBOSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSSBOSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSSBOSize); }; } template<class T> struct has_member_maxSSBOSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSSBOSize<T>::value + 2*impl::is_static_member_maxSSBOSize<T>::value + 4*is_const<typename impl::is_member_maxSSBOSize<T>::type>::value); }; template<class T, class F> struct has_member_maxSSBOSize_with_type : bool_constant<has_member_maxSSBOSize<T>::value && is_same<typename impl::is_member_maxSSBOSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPushConstantsSize: false_type { }; template<class T> struct is_static_member_maxPushConstantsSize<T,typename enable_if<!is_same<__decltype(T::maxPushConstantsSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPushConstantsSize: false_type { using type = void; }; template<class T> struct is_member_maxPushConstantsSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPushConstantsSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPushConstantsSize); }; } template<class T> struct has_member_maxPushConstantsSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPushConstantsSize<T>::value + 2*impl::is_static_member_maxPushConstantsSize<T>::value + 4*is_const<typename impl::is_member_maxPushConstantsSize<T>::type>::value); }; template<class T, class F> struct has_member_maxPushConstantsSize_with_type : bool_constant<has_member_maxPushConstantsSize<T>::value && is_same<typename impl::is_member_maxPushConstantsSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxMemoryAllocationCount: false_type { }; template<class T> struct is_static_member_maxMemoryAllocationCount<T,typename enable_if<!is_same<__decltype(T::maxMemoryAllocationCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxMemoryAllocationCount: false_type { using type = void; }; template<class T> struct is_member_maxMemoryAllocationCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxMemoryAllocationCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxMemoryAllocationCount); }; } template<class T> struct has_member_maxMemoryAllocationCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxMemoryAllocationCount<T>::value + 2*impl::is_static_member_maxMemoryAllocationCount<T>::value + 4*is_const<typename impl::is_member_maxMemoryAllocationCount<T>::type>::value); }; template<class T, class F> struct has_member_maxMemoryAllocationCount_with_type : bool_constant<has_member_maxMemoryAllocationCount<T>::value && is_same<typename impl::is_member_maxMemoryAllocationCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSamplerAllocationCount: false_type { }; template<class T> struct is_static_member_maxSamplerAllocationCount<T,typename enable_if<!is_same<__decltype(T::maxSamplerAllocationCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSamplerAllocationCount: false_type { using type = void; }; template<class T> struct is_member_maxSamplerAllocationCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSamplerAllocationCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSamplerAllocationCount); }; } template<class T> struct has_member_maxSamplerAllocationCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSamplerAllocationCount<T>::value + 2*impl::is_static_member_maxSamplerAllocationCount<T>::value + 4*is_const<typename impl::is_member_maxSamplerAllocationCount<T>::type>::value); }; template<class T, class F> struct has_member_maxSamplerAllocationCount_with_type : bool_constant<has_member_maxSamplerAllocationCount<T>::value && is_same<typename impl::is_member_maxSamplerAllocationCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_bufferImageGranularity: false_type { }; template<class T> struct is_static_member_bufferImageGranularity<T,typename enable_if<!is_same<__decltype(T::bufferImageGranularity),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_bufferImageGranularity: false_type { using type = void; }; template<class T> struct is_member_bufferImageGranularity<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().bufferImageGranularity),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().bufferImageGranularity); }; } template<class T> struct has_member_bufferImageGranularity { const static e_member_presence value = (e_member_presence)(impl::is_member_bufferImageGranularity<T>::value + 2*impl::is_static_member_bufferImageGranularity<T>::value + 4*is_const<typename impl::is_member_bufferImageGranularity<T>::type>::value); }; template<class T, class F> struct has_member_bufferImageGranularity_with_type : bool_constant<has_member_bufferImageGranularity<T>::value && is_same<typename impl::is_member_bufferImageGranularity<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorSamplers: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorSamplers<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorSamplers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorSamplers: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorSamplers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorSamplers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorSamplers); }; } template<class T> struct has_member_maxPerStageDescriptorSamplers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorSamplers<T>::value + 2*impl::is_static_member_maxPerStageDescriptorSamplers<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorSamplers<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorSamplers_with_type : bool_constant<has_member_maxPerStageDescriptorSamplers<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorSamplers<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUBOs: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUBOs<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUBOs: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUBOs); }; } template<class T> struct has_member_maxPerStageDescriptorUBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUBOs<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUBOs<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUBOs_with_type : bool_constant<has_member_maxPerStageDescriptorUBOs<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorSSBOs: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorSSBOs<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorSSBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorSSBOs: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorSSBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorSSBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorSSBOs); }; } template<class T> struct has_member_maxPerStageDescriptorSSBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorSSBOs<T>::value + 2*impl::is_static_member_maxPerStageDescriptorSSBOs<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorSSBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorSSBOs_with_type : bool_constant<has_member_maxPerStageDescriptorSSBOs<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorSSBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorImages: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorImages<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorImages: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorImages); }; } template<class T> struct has_member_maxPerStageDescriptorImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorImages<T>::value + 2*impl::is_static_member_maxPerStageDescriptorImages<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorImages<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorImages_with_type : bool_constant<has_member_maxPerStageDescriptorImages<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorStorageImages: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorStorageImages<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorStorageImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorStorageImages: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorStorageImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorStorageImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorStorageImages); }; } template<class T> struct has_member_maxPerStageDescriptorStorageImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorStorageImages<T>::value + 2*impl::is_static_member_maxPerStageDescriptorStorageImages<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorStorageImages<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorStorageImages_with_type : bool_constant<has_member_maxPerStageDescriptorStorageImages<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorStorageImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorInputAttachments: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorInputAttachments<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorInputAttachments),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorInputAttachments: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorInputAttachments<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorInputAttachments),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorInputAttachments); }; } template<class T> struct has_member_maxPerStageDescriptorInputAttachments { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorInputAttachments<T>::value + 2*impl::is_static_member_maxPerStageDescriptorInputAttachments<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorInputAttachments<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorInputAttachments_with_type : bool_constant<has_member_maxPerStageDescriptorInputAttachments<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorInputAttachments<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageResources: false_type { }; template<class T> struct is_static_member_maxPerStageResources<T,typename enable_if<!is_same<__decltype(T::maxPerStageResources),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageResources: false_type { using type = void; }; template<class T> struct is_member_maxPerStageResources<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageResources),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageResources); }; } template<class T> struct has_member_maxPerStageResources { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageResources<T>::value + 2*impl::is_static_member_maxPerStageResources<T>::value + 4*is_const<typename impl::is_member_maxPerStageResources<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageResources_with_type : bool_constant<has_member_maxPerStageResources<T>::value && is_same<typename impl::is_member_maxPerStageResources<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetSamplers: false_type { }; template<class T> struct is_static_member_maxDescriptorSetSamplers<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetSamplers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetSamplers: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetSamplers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetSamplers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetSamplers); }; } template<class T> struct has_member_maxDescriptorSetSamplers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetSamplers<T>::value + 2*impl::is_static_member_maxDescriptorSetSamplers<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetSamplers<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetSamplers_with_type : bool_constant<has_member_maxDescriptorSetSamplers<T>::value && is_same<typename impl::is_member_maxDescriptorSetSamplers<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUBOs); }; } template<class T> struct has_member_maxDescriptorSetUBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetUBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUBOs_with_type : bool_constant<has_member_maxDescriptorSetUBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetUBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetDynamicOffsetUBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetDynamicOffsetUBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetDynamicOffsetUBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetDynamicOffsetUBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetDynamicOffsetUBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetDynamicOffsetUBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetDynamicOffsetUBOs); }; } template<class T> struct has_member_maxDescriptorSetDynamicOffsetUBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetDynamicOffsetUBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetDynamicOffsetUBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetDynamicOffsetUBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetDynamicOffsetUBOs_with_type : bool_constant<has_member_maxDescriptorSetDynamicOffsetUBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetDynamicOffsetUBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetSSBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetSSBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetSSBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetSSBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetSSBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetSSBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetSSBOs); }; } template<class T> struct has_member_maxDescriptorSetSSBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetSSBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetSSBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetSSBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetSSBOs_with_type : bool_constant<has_member_maxDescriptorSetSSBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetSSBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetDynamicOffsetSSBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetDynamicOffsetSSBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetDynamicOffsetSSBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetDynamicOffsetSSBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetDynamicOffsetSSBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetDynamicOffsetSSBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetDynamicOffsetSSBOs); }; } template<class T> struct has_member_maxDescriptorSetDynamicOffsetSSBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetDynamicOffsetSSBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetDynamicOffsetSSBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetDynamicOffsetSSBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetDynamicOffsetSSBOs_with_type : bool_constant<has_member_maxDescriptorSetDynamicOffsetSSBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetDynamicOffsetSSBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetImages: false_type { }; template<class T> struct is_static_member_maxDescriptorSetImages<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetImages: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetImages); }; } template<class T> struct has_member_maxDescriptorSetImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetImages<T>::value + 2*impl::is_static_member_maxDescriptorSetImages<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetImages<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetImages_with_type : bool_constant<has_member_maxDescriptorSetImages<T>::value && is_same<typename impl::is_member_maxDescriptorSetImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetStorageImages: false_type { }; template<class T> struct is_static_member_maxDescriptorSetStorageImages<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetStorageImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetStorageImages: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetStorageImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetStorageImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetStorageImages); }; } template<class T> struct has_member_maxDescriptorSetStorageImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetStorageImages<T>::value + 2*impl::is_static_member_maxDescriptorSetStorageImages<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetStorageImages<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetStorageImages_with_type : bool_constant<has_member_maxDescriptorSetStorageImages<T>::value && is_same<typename impl::is_member_maxDescriptorSetStorageImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetInputAttachments: false_type { }; template<class T> struct is_static_member_maxDescriptorSetInputAttachments<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetInputAttachments),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetInputAttachments: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetInputAttachments<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetInputAttachments),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetInputAttachments); }; } template<class T> struct has_member_maxDescriptorSetInputAttachments { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetInputAttachments<T>::value + 2*impl::is_static_member_maxDescriptorSetInputAttachments<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetInputAttachments<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetInputAttachments_with_type : bool_constant<has_member_maxDescriptorSetInputAttachments<T>::value && is_same<typename impl::is_member_maxDescriptorSetInputAttachments<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxVertexOutputComponents: false_type { }; template<class T> struct is_static_member_maxVertexOutputComponents<T,typename enable_if<!is_same<__decltype(T::maxVertexOutputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxVertexOutputComponents: false_type { using type = void; }; template<class T> struct is_member_maxVertexOutputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxVertexOutputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxVertexOutputComponents); }; } template<class T> struct has_member_maxVertexOutputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxVertexOutputComponents<T>::value + 2*impl::is_static_member_maxVertexOutputComponents<T>::value + 4*is_const<typename impl::is_member_maxVertexOutputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxVertexOutputComponents_with_type : bool_constant<has_member_maxVertexOutputComponents<T>::value && is_same<typename impl::is_member_maxVertexOutputComponents<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationGenerationLevel: false_type { }; template<class T> struct is_static_member_maxTessellationGenerationLevel<T,typename enable_if<!is_same<__decltype(T::maxTessellationGenerationLevel),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationGenerationLevel: false_type { using type = void; }; template<class T> struct is_member_maxTessellationGenerationLevel<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationGenerationLevel),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationGenerationLevel); }; } template<class T> struct has_member_maxTessellationGenerationLevel { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationGenerationLevel<T>::value + 2*impl::is_static_member_maxTessellationGenerationLevel<T>::value + 4*is_const<typename impl::is_member_maxTessellationGenerationLevel<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationGenerationLevel_with_type : bool_constant<has_member_maxTessellationGenerationLevel<T>::value && is_same<typename impl::is_member_maxTessellationGenerationLevel<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationPatchSize: false_type { }; template<class T> struct is_static_member_maxTessellationPatchSize<T,typename enable_if<!is_same<__decltype(T::maxTessellationPatchSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationPatchSize: false_type { using type = void; }; template<class T> struct is_member_maxTessellationPatchSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationPatchSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationPatchSize); }; } template<class T> struct has_member_maxTessellationPatchSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationPatchSize<T>::value + 2*impl::is_static_member_maxTessellationPatchSize<T>::value + 4*is_const<typename impl::is_member_maxTessellationPatchSize<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationPatchSize_with_type : bool_constant<has_member_maxTessellationPatchSize<T>::value && is_same<typename impl::is_member_maxTessellationPatchSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationControlPerVertexInputComponents: false_type { }; template<class T> struct is_static_member_maxTessellationControlPerVertexInputComponents<T,typename enable_if<!is_same<__decltype(T::maxTessellationControlPerVertexInputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationControlPerVertexInputComponents: false_type { using type = void; }; template<class T> struct is_member_maxTessellationControlPerVertexInputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationControlPerVertexInputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationControlPerVertexInputComponents); }; } template<class T> struct has_member_maxTessellationControlPerVertexInputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationControlPerVertexInputComponents<T>::value + 2*impl::is_static_member_maxTessellationControlPerVertexInputComponents<T>::value + 4*is_const<typename impl::is_member_maxTessellationControlPerVertexInputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationControlPerVertexInputComponents_with_type : bool_constant<has_member_maxTessellationControlPerVertexInputComponents<T>::value && is_same<typename impl::is_member_maxTessellationControlPerVertexInputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationControlPerVertexOutputComponents: false_type { }; template<class T> struct is_static_member_maxTessellationControlPerVertexOutputComponents<T,typename enable_if<!is_same<__decltype(T::maxTessellationControlPerVertexOutputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationControlPerVertexOutputComponents: false_type { using type = void; }; template<class T> struct is_member_maxTessellationControlPerVertexOutputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationControlPerVertexOutputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationControlPerVertexOutputComponents); }; } template<class T> struct has_member_maxTessellationControlPerVertexOutputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationControlPerVertexOutputComponents<T>::value + 2*impl::is_static_member_maxTessellationControlPerVertexOutputComponents<T>::value + 4*is_const<typename impl::is_member_maxTessellationControlPerVertexOutputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationControlPerVertexOutputComponents_with_type : bool_constant<has_member_maxTessellationControlPerVertexOutputComponents<T>::value && is_same<typename impl::is_member_maxTessellationControlPerVertexOutputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationControlPerPatchOutputComponents: false_type { }; template<class T> struct is_static_member_maxTessellationControlPerPatchOutputComponents<T,typename enable_if<!is_same<__decltype(T::maxTessellationControlPerPatchOutputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationControlPerPatchOutputComponents: false_type { using type = void; }; template<class T> struct is_member_maxTessellationControlPerPatchOutputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationControlPerPatchOutputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationControlPerPatchOutputComponents); }; } template<class T> struct has_member_maxTessellationControlPerPatchOutputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationControlPerPatchOutputComponents<T>::value + 2*impl::is_static_member_maxTessellationControlPerPatchOutputComponents<T>::value + 4*is_const<typename impl::is_member_maxTessellationControlPerPatchOutputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationControlPerPatchOutputComponents_with_type : bool_constant<has_member_maxTessellationControlPerPatchOutputComponents<T>::value && is_same<typename impl::is_member_maxTessellationControlPerPatchOutputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationControlTotalOutputComponents: false_type { }; template<class T> struct is_static_member_maxTessellationControlTotalOutputComponents<T,typename enable_if<!is_same<__decltype(T::maxTessellationControlTotalOutputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationControlTotalOutputComponents: false_type { using type = void; }; template<class T> struct is_member_maxTessellationControlTotalOutputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationControlTotalOutputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationControlTotalOutputComponents); }; } template<class T> struct has_member_maxTessellationControlTotalOutputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationControlTotalOutputComponents<T>::value + 2*impl::is_static_member_maxTessellationControlTotalOutputComponents<T>::value + 4*is_const<typename impl::is_member_maxTessellationControlTotalOutputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationControlTotalOutputComponents_with_type : bool_constant<has_member_maxTessellationControlTotalOutputComponents<T>::value && is_same<typename impl::is_member_maxTessellationControlTotalOutputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationEvaluationInputComponents: false_type { }; template<class T> struct is_static_member_maxTessellationEvaluationInputComponents<T,typename enable_if<!is_same<__decltype(T::maxTessellationEvaluationInputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationEvaluationInputComponents: false_type { using type = void; }; template<class T> struct is_member_maxTessellationEvaluationInputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationEvaluationInputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationEvaluationInputComponents); }; } template<class T> struct has_member_maxTessellationEvaluationInputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationEvaluationInputComponents<T>::value + 2*impl::is_static_member_maxTessellationEvaluationInputComponents<T>::value + 4*is_const<typename impl::is_member_maxTessellationEvaluationInputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationEvaluationInputComponents_with_type : bool_constant<has_member_maxTessellationEvaluationInputComponents<T>::value && is_same<typename impl::is_member_maxTessellationEvaluationInputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTessellationEvaluationOutputComponents: false_type { }; template<class T> struct is_static_member_maxTessellationEvaluationOutputComponents<T,typename enable_if<!is_same<__decltype(T::maxTessellationEvaluationOutputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTessellationEvaluationOutputComponents: false_type { using type = void; }; template<class T> struct is_member_maxTessellationEvaluationOutputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTessellationEvaluationOutputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTessellationEvaluationOutputComponents); }; } template<class T> struct has_member_maxTessellationEvaluationOutputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTessellationEvaluationOutputComponents<T>::value + 2*impl::is_static_member_maxTessellationEvaluationOutputComponents<T>::value + 4*is_const<typename impl::is_member_maxTessellationEvaluationOutputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxTessellationEvaluationOutputComponents_with_type : bool_constant<has_member_maxTessellationEvaluationOutputComponents<T>::value && is_same<typename impl::is_member_maxTessellationEvaluationOutputComponents<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxGeometryShaderInvocations: false_type { }; template<class T> struct is_static_member_maxGeometryShaderInvocations<T,typename enable_if<!is_same<__decltype(T::maxGeometryShaderInvocations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxGeometryShaderInvocations: false_type { using type = void; }; template<class T> struct is_member_maxGeometryShaderInvocations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxGeometryShaderInvocations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxGeometryShaderInvocations); }; } template<class T> struct has_member_maxGeometryShaderInvocations { const static e_member_presence value = (e_member_presence)(impl::is_member_maxGeometryShaderInvocations<T>::value + 2*impl::is_static_member_maxGeometryShaderInvocations<T>::value + 4*is_const<typename impl::is_member_maxGeometryShaderInvocations<T>::type>::value); }; template<class T, class F> struct has_member_maxGeometryShaderInvocations_with_type : bool_constant<has_member_maxGeometryShaderInvocations<T>::value && is_same<typename impl::is_member_maxGeometryShaderInvocations<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxGeometryInputComponents: false_type { }; template<class T> struct is_static_member_maxGeometryInputComponents<T,typename enable_if<!is_same<__decltype(T::maxGeometryInputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxGeometryInputComponents: false_type { using type = void; }; template<class T> struct is_member_maxGeometryInputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxGeometryInputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxGeometryInputComponents); }; } template<class T> struct has_member_maxGeometryInputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxGeometryInputComponents<T>::value + 2*impl::is_static_member_maxGeometryInputComponents<T>::value + 4*is_const<typename impl::is_member_maxGeometryInputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxGeometryInputComponents_with_type : bool_constant<has_member_maxGeometryInputComponents<T>::value && is_same<typename impl::is_member_maxGeometryInputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxGeometryOutputComponents: false_type { }; template<class T> struct is_static_member_maxGeometryOutputComponents<T,typename enable_if<!is_same<__decltype(T::maxGeometryOutputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxGeometryOutputComponents: false_type { using type = void; }; template<class T> struct is_member_maxGeometryOutputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxGeometryOutputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxGeometryOutputComponents); }; } template<class T> struct has_member_maxGeometryOutputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxGeometryOutputComponents<T>::value + 2*impl::is_static_member_maxGeometryOutputComponents<T>::value + 4*is_const<typename impl::is_member_maxGeometryOutputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxGeometryOutputComponents_with_type : bool_constant<has_member_maxGeometryOutputComponents<T>::value && is_same<typename impl::is_member_maxGeometryOutputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxGeometryOutputVertices: false_type { }; template<class T> struct is_static_member_maxGeometryOutputVertices<T,typename enable_if<!is_same<__decltype(T::maxGeometryOutputVertices),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxGeometryOutputVertices: false_type { using type = void; }; template<class T> struct is_member_maxGeometryOutputVertices<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxGeometryOutputVertices),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxGeometryOutputVertices); }; } template<class T> struct has_member_maxGeometryOutputVertices { const static e_member_presence value = (e_member_presence)(impl::is_member_maxGeometryOutputVertices<T>::value + 2*impl::is_static_member_maxGeometryOutputVertices<T>::value + 4*is_const<typename impl::is_member_maxGeometryOutputVertices<T>::type>::value); }; template<class T, class F> struct has_member_maxGeometryOutputVertices_with_type : bool_constant<has_member_maxGeometryOutputVertices<T>::value && is_same<typename impl::is_member_maxGeometryOutputVertices<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxGeometryTotalOutputComponents: false_type { }; template<class T> struct is_static_member_maxGeometryTotalOutputComponents<T,typename enable_if<!is_same<__decltype(T::maxGeometryTotalOutputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxGeometryTotalOutputComponents: false_type { using type = void; }; template<class T> struct is_member_maxGeometryTotalOutputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxGeometryTotalOutputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxGeometryTotalOutputComponents); }; } template<class T> struct has_member_maxGeometryTotalOutputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxGeometryTotalOutputComponents<T>::value + 2*impl::is_static_member_maxGeometryTotalOutputComponents<T>::value + 4*is_const<typename impl::is_member_maxGeometryTotalOutputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxGeometryTotalOutputComponents_with_type : bool_constant<has_member_maxGeometryTotalOutputComponents<T>::value && is_same<typename impl::is_member_maxGeometryTotalOutputComponents<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFragmentInputComponents: false_type { }; template<class T> struct is_static_member_maxFragmentInputComponents<T,typename enable_if<!is_same<__decltype(T::maxFragmentInputComponents),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFragmentInputComponents: false_type { using type = void; }; template<class T> struct is_member_maxFragmentInputComponents<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFragmentInputComponents),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFragmentInputComponents); }; } template<class T> struct has_member_maxFragmentInputComponents { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFragmentInputComponents<T>::value + 2*impl::is_static_member_maxFragmentInputComponents<T>::value + 4*is_const<typename impl::is_member_maxFragmentInputComponents<T>::type>::value); }; template<class T, class F> struct has_member_maxFragmentInputComponents_with_type : bool_constant<has_member_maxFragmentInputComponents<T>::value && is_same<typename impl::is_member_maxFragmentInputComponents<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFragmentOutputAttachments: false_type { }; template<class T> struct is_static_member_maxFragmentOutputAttachments<T,typename enable_if<!is_same<__decltype(T::maxFragmentOutputAttachments),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFragmentOutputAttachments: false_type { using type = void; }; template<class T> struct is_member_maxFragmentOutputAttachments<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFragmentOutputAttachments),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFragmentOutputAttachments); }; } template<class T> struct has_member_maxFragmentOutputAttachments { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFragmentOutputAttachments<T>::value + 2*impl::is_static_member_maxFragmentOutputAttachments<T>::value + 4*is_const<typename impl::is_member_maxFragmentOutputAttachments<T>::type>::value); }; template<class T, class F> struct has_member_maxFragmentOutputAttachments_with_type : bool_constant<has_member_maxFragmentOutputAttachments<T>::value && is_same<typename impl::is_member_maxFragmentOutputAttachments<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFragmentDualSrcAttachments: false_type { }; template<class T> struct is_static_member_maxFragmentDualSrcAttachments<T,typename enable_if<!is_same<__decltype(T::maxFragmentDualSrcAttachments),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFragmentDualSrcAttachments: false_type { using type = void; }; template<class T> struct is_member_maxFragmentDualSrcAttachments<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFragmentDualSrcAttachments),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFragmentDualSrcAttachments); }; } template<class T> struct has_member_maxFragmentDualSrcAttachments { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFragmentDualSrcAttachments<T>::value + 2*impl::is_static_member_maxFragmentDualSrcAttachments<T>::value + 4*is_const<typename impl::is_member_maxFragmentDualSrcAttachments<T>::type>::value); }; template<class T, class F> struct has_member_maxFragmentDualSrcAttachments_with_type : bool_constant<has_member_maxFragmentDualSrcAttachments<T>::value && is_same<typename impl::is_member_maxFragmentDualSrcAttachments<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFragmentCombinedOutputResources: false_type { }; template<class T> struct is_static_member_maxFragmentCombinedOutputResources<T,typename enable_if<!is_same<__decltype(T::maxFragmentCombinedOutputResources),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFragmentCombinedOutputResources: false_type { using type = void; }; template<class T> struct is_member_maxFragmentCombinedOutputResources<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFragmentCombinedOutputResources),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFragmentCombinedOutputResources); }; } template<class T> struct has_member_maxFragmentCombinedOutputResources { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFragmentCombinedOutputResources<T>::value + 2*impl::is_static_member_maxFragmentCombinedOutputResources<T>::value + 4*is_const<typename impl::is_member_maxFragmentCombinedOutputResources<T>::type>::value); }; template<class T, class F> struct has_member_maxFragmentCombinedOutputResources_with_type : bool_constant<has_member_maxFragmentCombinedOutputResources<T>::value && is_same<typename impl::is_member_maxFragmentCombinedOutputResources<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxComputeSharedMemorySize: false_type { }; template<class T> struct is_static_member_maxComputeSharedMemorySize<T,typename enable_if<!is_same<__decltype(T::maxComputeSharedMemorySize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxComputeSharedMemorySize: false_type { using type = void; }; template<class T> struct is_member_maxComputeSharedMemorySize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxComputeSharedMemorySize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxComputeSharedMemorySize); }; } template<class T> struct has_member_maxComputeSharedMemorySize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxComputeSharedMemorySize<T>::value + 2*impl::is_static_member_maxComputeSharedMemorySize<T>::value + 4*is_const<typename impl::is_member_maxComputeSharedMemorySize<T>::type>::value); }; template<class T, class F> struct has_member_maxComputeSharedMemorySize_with_type : bool_constant<has_member_maxComputeSharedMemorySize<T>::value && is_same<typename impl::is_member_maxComputeSharedMemorySize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxComputeWorkGroupCountX: false_type { }; template<class T> struct is_static_member_maxComputeWorkGroupCountX<T,typename enable_if<!is_same<__decltype(T::maxComputeWorkGroupCountX),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxComputeWorkGroupCountX: false_type { using type = void; }; template<class T> struct is_member_maxComputeWorkGroupCountX<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxComputeWorkGroupCountX),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxComputeWorkGroupCountX); }; } template<class T> struct has_member_maxComputeWorkGroupCountX { const static e_member_presence value = (e_member_presence)(impl::is_member_maxComputeWorkGroupCountX<T>::value + 2*impl::is_static_member_maxComputeWorkGroupCountX<T>::value + 4*is_const<typename impl::is_member_maxComputeWorkGroupCountX<T>::type>::value); }; template<class T, class F> struct has_member_maxComputeWorkGroupCountX_with_type : bool_constant<has_member_maxComputeWorkGroupCountX<T>::value && is_same<typename impl::is_member_maxComputeWorkGroupCountX<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxComputeWorkGroupCountY: false_type { }; template<class T> struct is_static_member_maxComputeWorkGroupCountY<T,typename enable_if<!is_same<__decltype(T::maxComputeWorkGroupCountY),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxComputeWorkGroupCountY: false_type { using type = void; }; template<class T> struct is_member_maxComputeWorkGroupCountY<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxComputeWorkGroupCountY),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxComputeWorkGroupCountY); }; } template<class T> struct has_member_maxComputeWorkGroupCountY { const static e_member_presence value = (e_member_presence)(impl::is_member_maxComputeWorkGroupCountY<T>::value + 2*impl::is_static_member_maxComputeWorkGroupCountY<T>::value + 4*is_const<typename impl::is_member_maxComputeWorkGroupCountY<T>::type>::value); }; template<class T, class F> struct has_member_maxComputeWorkGroupCountY_with_type : bool_constant<has_member_maxComputeWorkGroupCountY<T>::value && is_same<typename impl::is_member_maxComputeWorkGroupCountY<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxComputeWorkGroupCountZ: false_type { }; template<class T> struct is_static_member_maxComputeWorkGroupCountZ<T,typename enable_if<!is_same<__decltype(T::maxComputeWorkGroupCountZ),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxComputeWorkGroupCountZ: false_type { using type = void; }; template<class T> struct is_member_maxComputeWorkGroupCountZ<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxComputeWorkGroupCountZ),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxComputeWorkGroupCountZ); }; } template<class T> struct has_member_maxComputeWorkGroupCountZ { const static e_member_presence value = (e_member_presence)(impl::is_member_maxComputeWorkGroupCountZ<T>::value + 2*impl::is_static_member_maxComputeWorkGroupCountZ<T>::value + 4*is_const<typename impl::is_member_maxComputeWorkGroupCountZ<T>::type>::value); }; template<class T, class F> struct has_member_maxComputeWorkGroupCountZ_with_type : bool_constant<has_member_maxComputeWorkGroupCountZ<T>::value && is_same<typename impl::is_member_maxComputeWorkGroupCountZ<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxComputeWorkGroupInvocations: false_type { }; template<class T> struct is_static_member_maxComputeWorkGroupInvocations<T,typename enable_if<!is_same<__decltype(T::maxComputeWorkGroupInvocations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxComputeWorkGroupInvocations: false_type { using type = void; }; template<class T> struct is_member_maxComputeWorkGroupInvocations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxComputeWorkGroupInvocations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxComputeWorkGroupInvocations); }; } template<class T> struct has_member_maxComputeWorkGroupInvocations { const static e_member_presence value = (e_member_presence)(impl::is_member_maxComputeWorkGroupInvocations<T>::value + 2*impl::is_static_member_maxComputeWorkGroupInvocations<T>::value + 4*is_const<typename impl::is_member_maxComputeWorkGroupInvocations<T>::type>::value); }; template<class T, class F> struct has_member_maxComputeWorkGroupInvocations_with_type : bool_constant<has_member_maxComputeWorkGroupInvocations<T>::value && is_same<typename impl::is_member_maxComputeWorkGroupInvocations<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxWorkgroupSizeX: false_type { }; template<class T> struct is_static_member_maxWorkgroupSizeX<T,typename enable_if<!is_same<__decltype(T::maxWorkgroupSizeX),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxWorkgroupSizeX: false_type { using type = void; }; template<class T> struct is_member_maxWorkgroupSizeX<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxWorkgroupSizeX),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxWorkgroupSizeX); }; } template<class T> struct has_member_maxWorkgroupSizeX { const static e_member_presence value = (e_member_presence)(impl::is_member_maxWorkgroupSizeX<T>::value + 2*impl::is_static_member_maxWorkgroupSizeX<T>::value + 4*is_const<typename impl::is_member_maxWorkgroupSizeX<T>::type>::value); }; template<class T, class F> struct has_member_maxWorkgroupSizeX_with_type : bool_constant<has_member_maxWorkgroupSizeX<T>::value && is_same<typename impl::is_member_maxWorkgroupSizeX<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxWorkgroupSizeY: false_type { }; template<class T> struct is_static_member_maxWorkgroupSizeY<T,typename enable_if<!is_same<__decltype(T::maxWorkgroupSizeY),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxWorkgroupSizeY: false_type { using type = void; }; template<class T> struct is_member_maxWorkgroupSizeY<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxWorkgroupSizeY),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxWorkgroupSizeY); }; } template<class T> struct has_member_maxWorkgroupSizeY { const static e_member_presence value = (e_member_presence)(impl::is_member_maxWorkgroupSizeY<T>::value + 2*impl::is_static_member_maxWorkgroupSizeY<T>::value + 4*is_const<typename impl::is_member_maxWorkgroupSizeY<T>::type>::value); }; template<class T, class F> struct has_member_maxWorkgroupSizeY_with_type : bool_constant<has_member_maxWorkgroupSizeY<T>::value && is_same<typename impl::is_member_maxWorkgroupSizeY<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxWorkgroupSizeZ: false_type { }; template<class T> struct is_static_member_maxWorkgroupSizeZ<T,typename enable_if<!is_same<__decltype(T::maxWorkgroupSizeZ),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxWorkgroupSizeZ: false_type { using type = void; }; template<class T> struct is_member_maxWorkgroupSizeZ<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxWorkgroupSizeZ),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxWorkgroupSizeZ); }; } template<class T> struct has_member_maxWorkgroupSizeZ { const static e_member_presence value = (e_member_presence)(impl::is_member_maxWorkgroupSizeZ<T>::value + 2*impl::is_static_member_maxWorkgroupSizeZ<T>::value + 4*is_const<typename impl::is_member_maxWorkgroupSizeZ<T>::type>::value); }; template<class T, class F> struct has_member_maxWorkgroupSizeZ_with_type : bool_constant<has_member_maxWorkgroupSizeZ<T>::value && is_same<typename impl::is_member_maxWorkgroupSizeZ<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_subPixelPrecisionBits: false_type { }; template<class T> struct is_static_member_subPixelPrecisionBits<T,typename enable_if<!is_same<__decltype(T::subPixelPrecisionBits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_subPixelPrecisionBits: false_type { using type = void; }; template<class T> struct is_member_subPixelPrecisionBits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().subPixelPrecisionBits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().subPixelPrecisionBits); }; } template<class T> struct has_member_subPixelPrecisionBits { const static e_member_presence value = (e_member_presence)(impl::is_member_subPixelPrecisionBits<T>::value + 2*impl::is_static_member_subPixelPrecisionBits<T>::value + 4*is_const<typename impl::is_member_subPixelPrecisionBits<T>::type>::value); }; template<class T, class F> struct has_member_subPixelPrecisionBits_with_type : bool_constant<has_member_subPixelPrecisionBits<T>::value && is_same<typename impl::is_member_subPixelPrecisionBits<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_subTexelPrecisionBits: false_type { }; template<class T> struct is_static_member_subTexelPrecisionBits<T,typename enable_if<!is_same<__decltype(T::subTexelPrecisionBits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_subTexelPrecisionBits: false_type { using type = void; }; template<class T> struct is_member_subTexelPrecisionBits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().subTexelPrecisionBits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().subTexelPrecisionBits); }; } template<class T> struct has_member_subTexelPrecisionBits { const static e_member_presence value = (e_member_presence)(impl::is_member_subTexelPrecisionBits<T>::value + 2*impl::is_static_member_subTexelPrecisionBits<T>::value + 4*is_const<typename impl::is_member_subTexelPrecisionBits<T>::type>::value); }; template<class T, class F> struct has_member_subTexelPrecisionBits_with_type : bool_constant<has_member_subTexelPrecisionBits<T>::value && is_same<typename impl::is_member_subTexelPrecisionBits<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_mipmapPrecisionBits: false_type { }; template<class T> struct is_static_member_mipmapPrecisionBits<T,typename enable_if<!is_same<__decltype(T::mipmapPrecisionBits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_mipmapPrecisionBits: false_type { using type = void; }; template<class T> struct is_member_mipmapPrecisionBits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().mipmapPrecisionBits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().mipmapPrecisionBits); }; } template<class T> struct has_member_mipmapPrecisionBits { const static e_member_presence value = (e_member_presence)(impl::is_member_mipmapPrecisionBits<T>::value + 2*impl::is_static_member_mipmapPrecisionBits<T>::value + 4*is_const<typename impl::is_member_mipmapPrecisionBits<T>::type>::value); }; template<class T, class F> struct has_member_mipmapPrecisionBits_with_type : bool_constant<has_member_mipmapPrecisionBits<T>::value && is_same<typename impl::is_member_mipmapPrecisionBits<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDrawIndirectCount: false_type { }; template<class T> struct is_static_member_maxDrawIndirectCount<T,typename enable_if<!is_same<__decltype(T::maxDrawIndirectCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDrawIndirectCount: false_type { using type = void; }; template<class T> struct is_member_maxDrawIndirectCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDrawIndirectCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDrawIndirectCount); }; } template<class T> struct has_member_maxDrawIndirectCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDrawIndirectCount<T>::value + 2*impl::is_static_member_maxDrawIndirectCount<T>::value + 4*is_const<typename impl::is_member_maxDrawIndirectCount<T>::type>::value); }; template<class T, class F> struct has_member_maxDrawIndirectCount_with_type : bool_constant<has_member_maxDrawIndirectCount<T>::value && is_same<typename impl::is_member_maxDrawIndirectCount<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSamplerLodBiasBitPattern: false_type { }; template<class T> struct is_static_member_maxSamplerLodBiasBitPattern<T,typename enable_if<!is_same<__decltype(T::maxSamplerLodBiasBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSamplerLodBiasBitPattern: false_type { using type = void; }; template<class T> struct is_member_maxSamplerLodBiasBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSamplerLodBiasBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSamplerLodBiasBitPattern); }; } template<class T> struct has_member_maxSamplerLodBiasBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSamplerLodBiasBitPattern<T>::value + 2*impl::is_static_member_maxSamplerLodBiasBitPattern<T>::value + 4*is_const<typename impl::is_member_maxSamplerLodBiasBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_maxSamplerLodBiasBitPattern_with_type : bool_constant<has_member_maxSamplerLodBiasBitPattern<T>::value && is_same<typename impl::is_member_maxSamplerLodBiasBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSamplerAnisotropyLog2: false_type { }; template<class T> struct is_static_member_maxSamplerAnisotropyLog2<T,typename enable_if<!is_same<__decltype(T::maxSamplerAnisotropyLog2),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSamplerAnisotropyLog2: false_type { using type = void; }; template<class T> struct is_member_maxSamplerAnisotropyLog2<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSamplerAnisotropyLog2),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSamplerAnisotropyLog2); }; } template<class T> struct has_member_maxSamplerAnisotropyLog2 { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSamplerAnisotropyLog2<T>::value + 2*impl::is_static_member_maxSamplerAnisotropyLog2<T>::value + 4*is_const<typename impl::is_member_maxSamplerAnisotropyLog2<T>::type>::value); }; template<class T, class F> struct has_member_maxSamplerAnisotropyLog2_with_type : bool_constant<has_member_maxSamplerAnisotropyLog2<T>::value && is_same<typename impl::is_member_maxSamplerAnisotropyLog2<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxViewports: false_type { }; template<class T> struct is_static_member_maxViewports<T,typename enable_if<!is_same<__decltype(T::maxViewports),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxViewports: false_type { using type = void; }; template<class T> struct is_member_maxViewports<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxViewports),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxViewports); }; } template<class T> struct has_member_maxViewports { const static e_member_presence value = (e_member_presence)(impl::is_member_maxViewports<T>::value + 2*impl::is_static_member_maxViewports<T>::value + 4*is_const<typename impl::is_member_maxViewports<T>::type>::value); }; template<class T, class F> struct has_member_maxViewports_with_type : bool_constant<has_member_maxViewports<T>::value && is_same<typename impl::is_member_maxViewports<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxViewportDimsX: false_type { }; template<class T> struct is_static_member_maxViewportDimsX<T,typename enable_if<!is_same<__decltype(T::maxViewportDimsX),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxViewportDimsX: false_type { using type = void; }; template<class T> struct is_member_maxViewportDimsX<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxViewportDimsX),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxViewportDimsX); }; } template<class T> struct has_member_maxViewportDimsX { const static e_member_presence value = (e_member_presence)(impl::is_member_maxViewportDimsX<T>::value + 2*impl::is_static_member_maxViewportDimsX<T>::value + 4*is_const<typename impl::is_member_maxViewportDimsX<T>::type>::value); }; template<class T, class F> struct has_member_maxViewportDimsX_with_type : bool_constant<has_member_maxViewportDimsX<T>::value && is_same<typename impl::is_member_maxViewportDimsX<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxViewportDimsY: false_type { }; template<class T> struct is_static_member_maxViewportDimsY<T,typename enable_if<!is_same<__decltype(T::maxViewportDimsY),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxViewportDimsY: false_type { using type = void; }; template<class T> struct is_member_maxViewportDimsY<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxViewportDimsY),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxViewportDimsY); }; } template<class T> struct has_member_maxViewportDimsY { const static e_member_presence value = (e_member_presence)(impl::is_member_maxViewportDimsY<T>::value + 2*impl::is_static_member_maxViewportDimsY<T>::value + 4*is_const<typename impl::is_member_maxViewportDimsY<T>::type>::value); }; template<class T, class F> struct has_member_maxViewportDimsY_with_type : bool_constant<has_member_maxViewportDimsY<T>::value && is_same<typename impl::is_member_maxViewportDimsY<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_viewportBoundsRangeBitPatternMin: false_type { }; template<class T> struct is_static_member_viewportBoundsRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(T::viewportBoundsRangeBitPatternMin),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_viewportBoundsRangeBitPatternMin: false_type { using type = void; }; template<class T> struct is_member_viewportBoundsRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().viewportBoundsRangeBitPatternMin),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().viewportBoundsRangeBitPatternMin); }; } template<class T> struct has_member_viewportBoundsRangeBitPatternMin { const static e_member_presence value = (e_member_presence)(impl::is_member_viewportBoundsRangeBitPatternMin<T>::value + 2*impl::is_static_member_viewportBoundsRangeBitPatternMin<T>::value + 4*is_const<typename impl::is_member_viewportBoundsRangeBitPatternMin<T>::type>::value); }; template<class T, class F> struct has_member_viewportBoundsRangeBitPatternMin_with_type : bool_constant<has_member_viewportBoundsRangeBitPatternMin<T>::value && is_same<typename impl::is_member_viewportBoundsRangeBitPatternMin<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_viewportBoundsRangeBitPatternMax: false_type { }; template<class T> struct is_static_member_viewportBoundsRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(T::viewportBoundsRangeBitPatternMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_viewportBoundsRangeBitPatternMax: false_type { using type = void; }; template<class T> struct is_member_viewportBoundsRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().viewportBoundsRangeBitPatternMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().viewportBoundsRangeBitPatternMax); }; } template<class T> struct has_member_viewportBoundsRangeBitPatternMax { const static e_member_presence value = (e_member_presence)(impl::is_member_viewportBoundsRangeBitPatternMax<T>::value + 2*impl::is_static_member_viewportBoundsRangeBitPatternMax<T>::value + 4*is_const<typename impl::is_member_viewportBoundsRangeBitPatternMax<T>::type>::value); }; template<class T, class F> struct has_member_viewportBoundsRangeBitPatternMax_with_type : bool_constant<has_member_viewportBoundsRangeBitPatternMax<T>::value && is_same<typename impl::is_member_viewportBoundsRangeBitPatternMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_viewportSubPixelBits: false_type { }; template<class T> struct is_static_member_viewportSubPixelBits<T,typename enable_if<!is_same<__decltype(T::viewportSubPixelBits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_viewportSubPixelBits: false_type { using type = void; }; template<class T> struct is_member_viewportSubPixelBits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().viewportSubPixelBits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().viewportSubPixelBits); }; } template<class T> struct has_member_viewportSubPixelBits { const static e_member_presence value = (e_member_presence)(impl::is_member_viewportSubPixelBits<T>::value + 2*impl::is_static_member_viewportSubPixelBits<T>::value + 4*is_const<typename impl::is_member_viewportSubPixelBits<T>::type>::value); }; template<class T, class F> struct has_member_viewportSubPixelBits_with_type : bool_constant<has_member_viewportSubPixelBits<T>::value && is_same<typename impl::is_member_viewportSubPixelBits<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minMemoryMapAlignment: false_type { }; template<class T> struct is_static_member_minMemoryMapAlignment<T,typename enable_if<!is_same<__decltype(T::minMemoryMapAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minMemoryMapAlignment: false_type { using type = void; }; template<class T> struct is_member_minMemoryMapAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minMemoryMapAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minMemoryMapAlignment); }; } template<class T> struct has_member_minMemoryMapAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_minMemoryMapAlignment<T>::value + 2*impl::is_static_member_minMemoryMapAlignment<T>::value + 4*is_const<typename impl::is_member_minMemoryMapAlignment<T>::type>::value); }; template<class T, class F> struct has_member_minMemoryMapAlignment_with_type : bool_constant<has_member_minMemoryMapAlignment<T>::value && is_same<typename impl::is_member_minMemoryMapAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_bufferViewAlignment: false_type { }; template<class T> struct is_static_member_bufferViewAlignment<T,typename enable_if<!is_same<__decltype(T::bufferViewAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_bufferViewAlignment: false_type { using type = void; }; template<class T> struct is_member_bufferViewAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().bufferViewAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().bufferViewAlignment); }; } template<class T> struct has_member_bufferViewAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_bufferViewAlignment<T>::value + 2*impl::is_static_member_bufferViewAlignment<T>::value + 4*is_const<typename impl::is_member_bufferViewAlignment<T>::type>::value); }; template<class T, class F> struct has_member_bufferViewAlignment_with_type : bool_constant<has_member_bufferViewAlignment<T>::value && is_same<typename impl::is_member_bufferViewAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minUBOAlignment: false_type { }; template<class T> struct is_static_member_minUBOAlignment<T,typename enable_if<!is_same<__decltype(T::minUBOAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minUBOAlignment: false_type { using type = void; }; template<class T> struct is_member_minUBOAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minUBOAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minUBOAlignment); }; } template<class T> struct has_member_minUBOAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_minUBOAlignment<T>::value + 2*impl::is_static_member_minUBOAlignment<T>::value + 4*is_const<typename impl::is_member_minUBOAlignment<T>::type>::value); }; template<class T, class F> struct has_member_minUBOAlignment_with_type : bool_constant<has_member_minUBOAlignment<T>::value && is_same<typename impl::is_member_minUBOAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minSSBOAlignment: false_type { }; template<class T> struct is_static_member_minSSBOAlignment<T,typename enable_if<!is_same<__decltype(T::minSSBOAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minSSBOAlignment: false_type { using type = void; }; template<class T> struct is_member_minSSBOAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minSSBOAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minSSBOAlignment); }; } template<class T> struct has_member_minSSBOAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_minSSBOAlignment<T>::value + 2*impl::is_static_member_minSSBOAlignment<T>::value + 4*is_const<typename impl::is_member_minSSBOAlignment<T>::type>::value); }; template<class T, class F> struct has_member_minSSBOAlignment_with_type : bool_constant<has_member_minSSBOAlignment<T>::value && is_same<typename impl::is_member_minSSBOAlignment<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minTexelOffset: false_type { }; template<class T> struct is_static_member_minTexelOffset<T,typename enable_if<!is_same<__decltype(T::minTexelOffset),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minTexelOffset: false_type { using type = void; }; template<class T> struct is_member_minTexelOffset<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minTexelOffset),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minTexelOffset); }; } template<class T> struct has_member_minTexelOffset { const static e_member_presence value = (e_member_presence)(impl::is_member_minTexelOffset<T>::value + 2*impl::is_static_member_minTexelOffset<T>::value + 4*is_const<typename impl::is_member_minTexelOffset<T>::type>::value); }; template<class T, class F> struct has_member_minTexelOffset_with_type : bool_constant<has_member_minTexelOffset<T>::value && is_same<typename impl::is_member_minTexelOffset<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTexelOffset: false_type { }; template<class T> struct is_static_member_maxTexelOffset<T,typename enable_if<!is_same<__decltype(T::maxTexelOffset),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTexelOffset: false_type { using type = void; }; template<class T> struct is_member_maxTexelOffset<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTexelOffset),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTexelOffset); }; } template<class T> struct has_member_maxTexelOffset { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTexelOffset<T>::value + 2*impl::is_static_member_maxTexelOffset<T>::value + 4*is_const<typename impl::is_member_maxTexelOffset<T>::type>::value); }; template<class T, class F> struct has_member_maxTexelOffset_with_type : bool_constant<has_member_maxTexelOffset<T>::value && is_same<typename impl::is_member_maxTexelOffset<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minTexelGatherOffset: false_type { }; template<class T> struct is_static_member_minTexelGatherOffset<T,typename enable_if<!is_same<__decltype(T::minTexelGatherOffset),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minTexelGatherOffset: false_type { using type = void; }; template<class T> struct is_member_minTexelGatherOffset<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minTexelGatherOffset),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minTexelGatherOffset); }; } template<class T> struct has_member_minTexelGatherOffset { const static e_member_presence value = (e_member_presence)(impl::is_member_minTexelGatherOffset<T>::value + 2*impl::is_static_member_minTexelGatherOffset<T>::value + 4*is_const<typename impl::is_member_minTexelGatherOffset<T>::type>::value); }; template<class T, class F> struct has_member_minTexelGatherOffset_with_type : bool_constant<has_member_minTexelGatherOffset<T>::value && is_same<typename impl::is_member_minTexelGatherOffset<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxTexelGatherOffset: false_type { }; template<class T> struct is_static_member_maxTexelGatherOffset<T,typename enable_if<!is_same<__decltype(T::maxTexelGatherOffset),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxTexelGatherOffset: false_type { using type = void; }; template<class T> struct is_member_maxTexelGatherOffset<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxTexelGatherOffset),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxTexelGatherOffset); }; } template<class T> struct has_member_maxTexelGatherOffset { const static e_member_presence value = (e_member_presence)(impl::is_member_maxTexelGatherOffset<T>::value + 2*impl::is_static_member_maxTexelGatherOffset<T>::value + 4*is_const<typename impl::is_member_maxTexelGatherOffset<T>::type>::value); }; template<class T, class F> struct has_member_maxTexelGatherOffset_with_type : bool_constant<has_member_maxTexelGatherOffset<T>::value && is_same<typename impl::is_member_maxTexelGatherOffset<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minInterpolationOffsetBitPattern: false_type { }; template<class T> struct is_static_member_minInterpolationOffsetBitPattern<T,typename enable_if<!is_same<__decltype(T::minInterpolationOffsetBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minInterpolationOffsetBitPattern: false_type { using type = void; }; template<class T> struct is_member_minInterpolationOffsetBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minInterpolationOffsetBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minInterpolationOffsetBitPattern); }; } template<class T> struct has_member_minInterpolationOffsetBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_minInterpolationOffsetBitPattern<T>::value + 2*impl::is_static_member_minInterpolationOffsetBitPattern<T>::value + 4*is_const<typename impl::is_member_minInterpolationOffsetBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_minInterpolationOffsetBitPattern_with_type : bool_constant<has_member_minInterpolationOffsetBitPattern<T>::value && is_same<typename impl::is_member_minInterpolationOffsetBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxInterpolationOffsetBitPattern: false_type { }; template<class T> struct is_static_member_maxInterpolationOffsetBitPattern<T,typename enable_if<!is_same<__decltype(T::maxInterpolationOffsetBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxInterpolationOffsetBitPattern: false_type { using type = void; }; template<class T> struct is_member_maxInterpolationOffsetBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxInterpolationOffsetBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxInterpolationOffsetBitPattern); }; } template<class T> struct has_member_maxInterpolationOffsetBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_maxInterpolationOffsetBitPattern<T>::value + 2*impl::is_static_member_maxInterpolationOffsetBitPattern<T>::value + 4*is_const<typename impl::is_member_maxInterpolationOffsetBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_maxInterpolationOffsetBitPattern_with_type : bool_constant<has_member_maxInterpolationOffsetBitPattern<T>::value && is_same<typename impl::is_member_maxInterpolationOffsetBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_subPixelInterpolationOffsetBits: false_type { }; template<class T> struct is_static_member_subPixelInterpolationOffsetBits<T,typename enable_if<!is_same<__decltype(T::subPixelInterpolationOffsetBits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_subPixelInterpolationOffsetBits: false_type { using type = void; }; template<class T> struct is_member_subPixelInterpolationOffsetBits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().subPixelInterpolationOffsetBits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().subPixelInterpolationOffsetBits); }; } template<class T> struct has_member_subPixelInterpolationOffsetBits { const static e_member_presence value = (e_member_presence)(impl::is_member_subPixelInterpolationOffsetBits<T>::value + 2*impl::is_static_member_subPixelInterpolationOffsetBits<T>::value + 4*is_const<typename impl::is_member_subPixelInterpolationOffsetBits<T>::type>::value); }; template<class T, class F> struct has_member_subPixelInterpolationOffsetBits_with_type : bool_constant<has_member_subPixelInterpolationOffsetBits<T>::value && is_same<typename impl::is_member_subPixelInterpolationOffsetBits<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFramebufferWidth: false_type { }; template<class T> struct is_static_member_maxFramebufferWidth<T,typename enable_if<!is_same<__decltype(T::maxFramebufferWidth),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFramebufferWidth: false_type { using type = void; }; template<class T> struct is_member_maxFramebufferWidth<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFramebufferWidth),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFramebufferWidth); }; } template<class T> struct has_member_maxFramebufferWidth { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFramebufferWidth<T>::value + 2*impl::is_static_member_maxFramebufferWidth<T>::value + 4*is_const<typename impl::is_member_maxFramebufferWidth<T>::type>::value); }; template<class T, class F> struct has_member_maxFramebufferWidth_with_type : bool_constant<has_member_maxFramebufferWidth<T>::value && is_same<typename impl::is_member_maxFramebufferWidth<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFramebufferHeight: false_type { }; template<class T> struct is_static_member_maxFramebufferHeight<T,typename enable_if<!is_same<__decltype(T::maxFramebufferHeight),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFramebufferHeight: false_type { using type = void; }; template<class T> struct is_member_maxFramebufferHeight<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFramebufferHeight),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFramebufferHeight); }; } template<class T> struct has_member_maxFramebufferHeight { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFramebufferHeight<T>::value + 2*impl::is_static_member_maxFramebufferHeight<T>::value + 4*is_const<typename impl::is_member_maxFramebufferHeight<T>::type>::value); }; template<class T, class F> struct has_member_maxFramebufferHeight_with_type : bool_constant<has_member_maxFramebufferHeight<T>::value && is_same<typename impl::is_member_maxFramebufferHeight<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFramebufferLayers: false_type { }; template<class T> struct is_static_member_maxFramebufferLayers<T,typename enable_if<!is_same<__decltype(T::maxFramebufferLayers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFramebufferLayers: false_type { using type = void; }; template<class T> struct is_member_maxFramebufferLayers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFramebufferLayers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFramebufferLayers); }; } template<class T> struct has_member_maxFramebufferLayers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFramebufferLayers<T>::value + 2*impl::is_static_member_maxFramebufferLayers<T>::value + 4*is_const<typename impl::is_member_maxFramebufferLayers<T>::type>::value); }; template<class T, class F> struct has_member_maxFramebufferLayers_with_type : bool_constant<has_member_maxFramebufferLayers<T>::value && is_same<typename impl::is_member_maxFramebufferLayers<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxColorAttachments: false_type { }; template<class T> struct is_static_member_maxColorAttachments<T,typename enable_if<!is_same<__decltype(T::maxColorAttachments),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxColorAttachments: false_type { using type = void; }; template<class T> struct is_member_maxColorAttachments<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxColorAttachments),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxColorAttachments); }; } template<class T> struct has_member_maxColorAttachments { const static e_member_presence value = (e_member_presence)(impl::is_member_maxColorAttachments<T>::value + 2*impl::is_static_member_maxColorAttachments<T>::value + 4*is_const<typename impl::is_member_maxColorAttachments<T>::type>::value); }; template<class T, class F> struct has_member_maxColorAttachments_with_type : bool_constant<has_member_maxColorAttachments<T>::value && is_same<typename impl::is_member_maxColorAttachments<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSampleMaskWords: false_type { }; template<class T> struct is_static_member_maxSampleMaskWords<T,typename enable_if<!is_same<__decltype(T::maxSampleMaskWords),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSampleMaskWords: false_type { using type = void; }; template<class T> struct is_member_maxSampleMaskWords<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSampleMaskWords),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSampleMaskWords); }; } template<class T> struct has_member_maxSampleMaskWords { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSampleMaskWords<T>::value + 2*impl::is_static_member_maxSampleMaskWords<T>::value + 4*is_const<typename impl::is_member_maxSampleMaskWords<T>::type>::value); }; template<class T, class F> struct has_member_maxSampleMaskWords_with_type : bool_constant<has_member_maxSampleMaskWords<T>::value && is_same<typename impl::is_member_maxSampleMaskWords<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_timestampPeriodInNanoSecondsBitPattern: false_type { }; template<class T> struct is_static_member_timestampPeriodInNanoSecondsBitPattern<T,typename enable_if<!is_same<__decltype(T::timestampPeriodInNanoSecondsBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_timestampPeriodInNanoSecondsBitPattern: false_type { using type = void; }; template<class T> struct is_member_timestampPeriodInNanoSecondsBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().timestampPeriodInNanoSecondsBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().timestampPeriodInNanoSecondsBitPattern); }; } template<class T> struct has_member_timestampPeriodInNanoSecondsBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_timestampPeriodInNanoSecondsBitPattern<T>::value + 2*impl::is_static_member_timestampPeriodInNanoSecondsBitPattern<T>::value + 4*is_const<typename impl::is_member_timestampPeriodInNanoSecondsBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_timestampPeriodInNanoSecondsBitPattern_with_type : bool_constant<has_member_timestampPeriodInNanoSecondsBitPattern<T>::value && is_same<typename impl::is_member_timestampPeriodInNanoSecondsBitPattern<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxClipDistances: false_type { }; template<class T> struct is_static_member_maxClipDistances<T,typename enable_if<!is_same<__decltype(T::maxClipDistances),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxClipDistances: false_type { using type = void; }; template<class T> struct is_member_maxClipDistances<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxClipDistances),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxClipDistances); }; } template<class T> struct has_member_maxClipDistances { const static e_member_presence value = (e_member_presence)(impl::is_member_maxClipDistances<T>::value + 2*impl::is_static_member_maxClipDistances<T>::value + 4*is_const<typename impl::is_member_maxClipDistances<T>::type>::value); }; template<class T, class F> struct has_member_maxClipDistances_with_type : bool_constant<has_member_maxClipDistances<T>::value && is_same<typename impl::is_member_maxClipDistances<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxCullDistances: false_type { }; template<class T> struct is_static_member_maxCullDistances<T,typename enable_if<!is_same<__decltype(T::maxCullDistances),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxCullDistances: false_type { using type = void; }; template<class T> struct is_member_maxCullDistances<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxCullDistances),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxCullDistances); }; } template<class T> struct has_member_maxCullDistances { const static e_member_presence value = (e_member_presence)(impl::is_member_maxCullDistances<T>::value + 2*impl::is_static_member_maxCullDistances<T>::value + 4*is_const<typename impl::is_member_maxCullDistances<T>::type>::value); }; template<class T, class F> struct has_member_maxCullDistances_with_type : bool_constant<has_member_maxCullDistances<T>::value && is_same<typename impl::is_member_maxCullDistances<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxCombinedClipAndCullDistances: false_type { }; template<class T> struct is_static_member_maxCombinedClipAndCullDistances<T,typename enable_if<!is_same<__decltype(T::maxCombinedClipAndCullDistances),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxCombinedClipAndCullDistances: false_type { using type = void; }; template<class T> struct is_member_maxCombinedClipAndCullDistances<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxCombinedClipAndCullDistances),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxCombinedClipAndCullDistances); }; } template<class T> struct has_member_maxCombinedClipAndCullDistances { const static e_member_presence value = (e_member_presence)(impl::is_member_maxCombinedClipAndCullDistances<T>::value + 2*impl::is_static_member_maxCombinedClipAndCullDistances<T>::value + 4*is_const<typename impl::is_member_maxCombinedClipAndCullDistances<T>::type>::value); }; template<class T, class F> struct has_member_maxCombinedClipAndCullDistances_with_type : bool_constant<has_member_maxCombinedClipAndCullDistances<T>::value && is_same<typename impl::is_member_maxCombinedClipAndCullDistances<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_discreteQueuePriorities: false_type { }; template<class T> struct is_static_member_discreteQueuePriorities<T,typename enable_if<!is_same<__decltype(T::discreteQueuePriorities),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_discreteQueuePriorities: false_type { using type = void; }; template<class T> struct is_member_discreteQueuePriorities<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().discreteQueuePriorities),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().discreteQueuePriorities); }; } template<class T> struct has_member_discreteQueuePriorities { const static e_member_presence value = (e_member_presence)(impl::is_member_discreteQueuePriorities<T>::value + 2*impl::is_static_member_discreteQueuePriorities<T>::value + 4*is_const<typename impl::is_member_discreteQueuePriorities<T>::type>::value); }; template<class T, class F> struct has_member_discreteQueuePriorities_with_type : bool_constant<has_member_discreteQueuePriorities<T>::value && is_same<typename impl::is_member_discreteQueuePriorities<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pointSizeRangeBitPatternMin: false_type { }; template<class T> struct is_static_member_pointSizeRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(T::pointSizeRangeBitPatternMin),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pointSizeRangeBitPatternMin: false_type { using type = void; }; template<class T> struct is_member_pointSizeRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pointSizeRangeBitPatternMin),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pointSizeRangeBitPatternMin); }; } template<class T> struct has_member_pointSizeRangeBitPatternMin { const static e_member_presence value = (e_member_presence)(impl::is_member_pointSizeRangeBitPatternMin<T>::value + 2*impl::is_static_member_pointSizeRangeBitPatternMin<T>::value + 4*is_const<typename impl::is_member_pointSizeRangeBitPatternMin<T>::type>::value); }; template<class T, class F> struct has_member_pointSizeRangeBitPatternMin_with_type : bool_constant<has_member_pointSizeRangeBitPatternMin<T>::value && is_same<typename impl::is_member_pointSizeRangeBitPatternMin<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pointSizeRangeBitPatternMax: false_type { }; template<class T> struct is_static_member_pointSizeRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(T::pointSizeRangeBitPatternMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pointSizeRangeBitPatternMax: false_type { using type = void; }; template<class T> struct is_member_pointSizeRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pointSizeRangeBitPatternMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pointSizeRangeBitPatternMax); }; } template<class T> struct has_member_pointSizeRangeBitPatternMax { const static e_member_presence value = (e_member_presence)(impl::is_member_pointSizeRangeBitPatternMax<T>::value + 2*impl::is_static_member_pointSizeRangeBitPatternMax<T>::value + 4*is_const<typename impl::is_member_pointSizeRangeBitPatternMax<T>::type>::value); }; template<class T, class F> struct has_member_pointSizeRangeBitPatternMax_with_type : bool_constant<has_member_pointSizeRangeBitPatternMax<T>::value && is_same<typename impl::is_member_pointSizeRangeBitPatternMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_lineWidthRangeBitPatternMin: false_type { }; template<class T> struct is_static_member_lineWidthRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(T::lineWidthRangeBitPatternMin),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_lineWidthRangeBitPatternMin: false_type { using type = void; }; template<class T> struct is_member_lineWidthRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().lineWidthRangeBitPatternMin),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().lineWidthRangeBitPatternMin); }; } template<class T> struct has_member_lineWidthRangeBitPatternMin { const static e_member_presence value = (e_member_presence)(impl::is_member_lineWidthRangeBitPatternMin<T>::value + 2*impl::is_static_member_lineWidthRangeBitPatternMin<T>::value + 4*is_const<typename impl::is_member_lineWidthRangeBitPatternMin<T>::type>::value); }; template<class T, class F> struct has_member_lineWidthRangeBitPatternMin_with_type : bool_constant<has_member_lineWidthRangeBitPatternMin<T>::value && is_same<typename impl::is_member_lineWidthRangeBitPatternMin<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_lineWidthRangeBitPatternMax: false_type { }; template<class T> struct is_static_member_lineWidthRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(T::lineWidthRangeBitPatternMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_lineWidthRangeBitPatternMax: false_type { using type = void; }; template<class T> struct is_member_lineWidthRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().lineWidthRangeBitPatternMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().lineWidthRangeBitPatternMax); }; } template<class T> struct has_member_lineWidthRangeBitPatternMax { const static e_member_presence value = (e_member_presence)(impl::is_member_lineWidthRangeBitPatternMax<T>::value + 2*impl::is_static_member_lineWidthRangeBitPatternMax<T>::value + 4*is_const<typename impl::is_member_lineWidthRangeBitPatternMax<T>::type>::value); }; template<class T, class F> struct has_member_lineWidthRangeBitPatternMax_with_type : bool_constant<has_member_lineWidthRangeBitPatternMax<T>::value && is_same<typename impl::is_member_lineWidthRangeBitPatternMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pointSizeGranularityBitPattern: false_type { }; template<class T> struct is_static_member_pointSizeGranularityBitPattern<T,typename enable_if<!is_same<__decltype(T::pointSizeGranularityBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pointSizeGranularityBitPattern: false_type { using type = void; }; template<class T> struct is_member_pointSizeGranularityBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pointSizeGranularityBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pointSizeGranularityBitPattern); }; } template<class T> struct has_member_pointSizeGranularityBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_pointSizeGranularityBitPattern<T>::value + 2*impl::is_static_member_pointSizeGranularityBitPattern<T>::value + 4*is_const<typename impl::is_member_pointSizeGranularityBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_pointSizeGranularityBitPattern_with_type : bool_constant<has_member_pointSizeGranularityBitPattern<T>::value && is_same<typename impl::is_member_pointSizeGranularityBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_lineWidthGranularityBitPattern: false_type { }; template<class T> struct is_static_member_lineWidthGranularityBitPattern<T,typename enable_if<!is_same<__decltype(T::lineWidthGranularityBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_lineWidthGranularityBitPattern: false_type { using type = void; }; template<class T> struct is_member_lineWidthGranularityBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().lineWidthGranularityBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().lineWidthGranularityBitPattern); }; } template<class T> struct has_member_lineWidthGranularityBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_lineWidthGranularityBitPattern<T>::value + 2*impl::is_static_member_lineWidthGranularityBitPattern<T>::value + 4*is_const<typename impl::is_member_lineWidthGranularityBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_lineWidthGranularityBitPattern_with_type : bool_constant<has_member_lineWidthGranularityBitPattern<T>::value && is_same<typename impl::is_member_lineWidthGranularityBitPattern<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_strictLines: false_type { }; template<class T> struct is_static_member_strictLines<T,typename enable_if<!is_same<__decltype(T::strictLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_strictLines: false_type { using type = void; }; template<class T> struct is_member_strictLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().strictLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().strictLines); }; } template<class T> struct has_member_strictLines { const static e_member_presence value = (e_member_presence)(impl::is_member_strictLines<T>::value + 2*impl::is_static_member_strictLines<T>::value + 4*is_const<typename impl::is_member_strictLines<T>::type>::value); }; template<class T, class F> struct has_member_strictLines_with_type : bool_constant<has_member_strictLines<T>::value && is_same<typename impl::is_member_strictLines<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_standardSampleLocations: false_type { }; template<class T> struct is_static_member_standardSampleLocations<T,typename enable_if<!is_same<__decltype(T::standardSampleLocations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_standardSampleLocations: false_type { using type = void; }; template<class T> struct is_member_standardSampleLocations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().standardSampleLocations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().standardSampleLocations); }; } template<class T> struct has_member_standardSampleLocations { const static e_member_presence value = (e_member_presence)(impl::is_member_standardSampleLocations<T>::value + 2*impl::is_static_member_standardSampleLocations<T>::value + 4*is_const<typename impl::is_member_standardSampleLocations<T>::type>::value); }; template<class T, class F> struct has_member_standardSampleLocations_with_type : bool_constant<has_member_standardSampleLocations<T>::value && is_same<typename impl::is_member_standardSampleLocations<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_optimalBufferCopyOffsetAlignment: false_type { }; template<class T> struct is_static_member_optimalBufferCopyOffsetAlignment<T,typename enable_if<!is_same<__decltype(T::optimalBufferCopyOffsetAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_optimalBufferCopyOffsetAlignment: false_type { using type = void; }; template<class T> struct is_member_optimalBufferCopyOffsetAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().optimalBufferCopyOffsetAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().optimalBufferCopyOffsetAlignment); }; } template<class T> struct has_member_optimalBufferCopyOffsetAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_optimalBufferCopyOffsetAlignment<T>::value + 2*impl::is_static_member_optimalBufferCopyOffsetAlignment<T>::value + 4*is_const<typename impl::is_member_optimalBufferCopyOffsetAlignment<T>::type>::value); }; template<class T, class F> struct has_member_optimalBufferCopyOffsetAlignment_with_type : bool_constant<has_member_optimalBufferCopyOffsetAlignment<T>::value && is_same<typename impl::is_member_optimalBufferCopyOffsetAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_optimalBufferCopyRowPitchAlignment: false_type { }; template<class T> struct is_static_member_optimalBufferCopyRowPitchAlignment<T,typename enable_if<!is_same<__decltype(T::optimalBufferCopyRowPitchAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_optimalBufferCopyRowPitchAlignment: false_type { using type = void; }; template<class T> struct is_member_optimalBufferCopyRowPitchAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().optimalBufferCopyRowPitchAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().optimalBufferCopyRowPitchAlignment); }; } template<class T> struct has_member_optimalBufferCopyRowPitchAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_optimalBufferCopyRowPitchAlignment<T>::value + 2*impl::is_static_member_optimalBufferCopyRowPitchAlignment<T>::value + 4*is_const<typename impl::is_member_optimalBufferCopyRowPitchAlignment<T>::type>::value); }; template<class T, class F> struct has_member_optimalBufferCopyRowPitchAlignment_with_type : bool_constant<has_member_optimalBufferCopyRowPitchAlignment<T>::value && is_same<typename impl::is_member_optimalBufferCopyRowPitchAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_nonCoherentAtomSize: false_type { }; template<class T> struct is_static_member_nonCoherentAtomSize<T,typename enable_if<!is_same<__decltype(T::nonCoherentAtomSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_nonCoherentAtomSize: false_type { using type = void; }; template<class T> struct is_member_nonCoherentAtomSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().nonCoherentAtomSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().nonCoherentAtomSize); }; } template<class T> struct has_member_nonCoherentAtomSize { const static e_member_presence value = (e_member_presence)(impl::is_member_nonCoherentAtomSize<T>::value + 2*impl::is_static_member_nonCoherentAtomSize<T>::value + 4*is_const<typename impl::is_member_nonCoherentAtomSize<T>::type>::value); }; template<class T, class F> struct has_member_nonCoherentAtomSize_with_type : bool_constant<has_member_nonCoherentAtomSize<T>::value && is_same<typename impl::is_member_nonCoherentAtomSize<T>::type, F>::value> {}; } };

// VK 1.1
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_subgroupSize: false_type { }; template<class T> struct is_static_member_subgroupSize<T,typename enable_if<!is_same<__decltype(T::subgroupSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_subgroupSize: false_type { using type = void; }; template<class T> struct is_member_subgroupSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().subgroupSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().subgroupSize); }; } template<class T> struct has_member_subgroupSize { const static e_member_presence value = (e_member_presence)(impl::is_member_subgroupSize<T>::value + 2*impl::is_static_member_subgroupSize<T>::value + 4*is_const<typename impl::is_member_subgroupSize<T>::type>::value); }; template<class T, class F> struct has_member_subgroupSize_with_type : bool_constant<has_member_subgroupSize<T>::value && is_same<typename impl::is_member_subgroupSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_subgroupOpsShaderStagesBitPattern: false_type { }; template<class T> struct is_static_member_subgroupOpsShaderStagesBitPattern<T,typename enable_if<!is_same<__decltype(T::subgroupOpsShaderStagesBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_subgroupOpsShaderStagesBitPattern: false_type { using type = void; }; template<class T> struct is_member_subgroupOpsShaderStagesBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().subgroupOpsShaderStagesBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().subgroupOpsShaderStagesBitPattern); }; } template<class T> struct has_member_subgroupOpsShaderStagesBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_subgroupOpsShaderStagesBitPattern<T>::value + 2*impl::is_static_member_subgroupOpsShaderStagesBitPattern<T>::value + 4*is_const<typename impl::is_member_subgroupOpsShaderStagesBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_subgroupOpsShaderStagesBitPattern_with_type : bool_constant<has_member_subgroupOpsShaderStagesBitPattern<T>::value && is_same<typename impl::is_member_subgroupOpsShaderStagesBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSubgroupClustered: false_type { }; template<class T> struct is_static_member_shaderSubgroupClustered<T,typename enable_if<!is_same<__decltype(T::shaderSubgroupClustered),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSubgroupClustered: false_type { using type = void; }; template<class T> struct is_member_shaderSubgroupClustered<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSubgroupClustered),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSubgroupClustered); }; } template<class T> struct has_member_shaderSubgroupClustered { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSubgroupClustered<T>::value + 2*impl::is_static_member_shaderSubgroupClustered<T>::value + 4*is_const<typename impl::is_member_shaderSubgroupClustered<T>::type>::value); }; template<class T, class F> struct has_member_shaderSubgroupClustered_with_type : bool_constant<has_member_shaderSubgroupClustered<T>::value && is_same<typename impl::is_member_shaderSubgroupClustered<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSubgroupArithmetic: false_type { }; template<class T> struct is_static_member_shaderSubgroupArithmetic<T,typename enable_if<!is_same<__decltype(T::shaderSubgroupArithmetic),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSubgroupArithmetic: false_type { using type = void; }; template<class T> struct is_member_shaderSubgroupArithmetic<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSubgroupArithmetic),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSubgroupArithmetic); }; } template<class T> struct has_member_shaderSubgroupArithmetic { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSubgroupArithmetic<T>::value + 2*impl::is_static_member_shaderSubgroupArithmetic<T>::value + 4*is_const<typename impl::is_member_shaderSubgroupArithmetic<T>::type>::value); }; template<class T, class F> struct has_member_shaderSubgroupArithmetic_with_type : bool_constant<has_member_shaderSubgroupArithmetic<T>::value && is_same<typename impl::is_member_shaderSubgroupArithmetic<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSubgroupQuad: false_type { }; template<class T> struct is_static_member_shaderSubgroupQuad<T,typename enable_if<!is_same<__decltype(T::shaderSubgroupQuad),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSubgroupQuad: false_type { using type = void; }; template<class T> struct is_member_shaderSubgroupQuad<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSubgroupQuad),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSubgroupQuad); }; } template<class T> struct has_member_shaderSubgroupQuad { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSubgroupQuad<T>::value + 2*impl::is_static_member_shaderSubgroupQuad<T>::value + 4*is_const<typename impl::is_member_shaderSubgroupQuad<T>::type>::value); }; template<class T, class F> struct has_member_shaderSubgroupQuad_with_type : bool_constant<has_member_shaderSubgroupQuad<T>::value && is_same<typename impl::is_member_shaderSubgroupQuad<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSubgroupQuadAllStages: false_type { }; template<class T> struct is_static_member_shaderSubgroupQuadAllStages<T,typename enable_if<!is_same<__decltype(T::shaderSubgroupQuadAllStages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSubgroupQuadAllStages: false_type { using type = void; }; template<class T> struct is_member_shaderSubgroupQuadAllStages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSubgroupQuadAllStages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSubgroupQuadAllStages); }; } template<class T> struct has_member_shaderSubgroupQuadAllStages { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSubgroupQuadAllStages<T>::value + 2*impl::is_static_member_shaderSubgroupQuadAllStages<T>::value + 4*is_const<typename impl::is_member_shaderSubgroupQuadAllStages<T>::type>::value); }; template<class T, class F> struct has_member_shaderSubgroupQuadAllStages_with_type : bool_constant<has_member_shaderSubgroupQuadAllStages<T>::value && is_same<typename impl::is_member_shaderSubgroupQuadAllStages<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pointClippingBehaviorBitPattern: false_type { }; template<class T> struct is_static_member_pointClippingBehaviorBitPattern<T,typename enable_if<!is_same<__decltype(T::pointClippingBehaviorBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pointClippingBehaviorBitPattern: false_type { using type = void; }; template<class T> struct is_member_pointClippingBehaviorBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pointClippingBehaviorBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pointClippingBehaviorBitPattern); }; } template<class T> struct has_member_pointClippingBehaviorBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_pointClippingBehaviorBitPattern<T>::value + 2*impl::is_static_member_pointClippingBehaviorBitPattern<T>::value + 4*is_const<typename impl::is_member_pointClippingBehaviorBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_pointClippingBehaviorBitPattern_with_type : bool_constant<has_member_pointClippingBehaviorBitPattern<T>::value && is_same<typename impl::is_member_pointClippingBehaviorBitPattern<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxMultiviewViewCount: false_type { }; template<class T> struct is_static_member_maxMultiviewViewCount<T,typename enable_if<!is_same<__decltype(T::maxMultiviewViewCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxMultiviewViewCount: false_type { using type = void; }; template<class T> struct is_member_maxMultiviewViewCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxMultiviewViewCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxMultiviewViewCount); }; } template<class T> struct has_member_maxMultiviewViewCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxMultiviewViewCount<T>::value + 2*impl::is_static_member_maxMultiviewViewCount<T>::value + 4*is_const<typename impl::is_member_maxMultiviewViewCount<T>::type>::value); }; template<class T, class F> struct has_member_maxMultiviewViewCount_with_type : bool_constant<has_member_maxMultiviewViewCount<T>::value && is_same<typename impl::is_member_maxMultiviewViewCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxMultiviewInstanceIndex: false_type { }; template<class T> struct is_static_member_maxMultiviewInstanceIndex<T,typename enable_if<!is_same<__decltype(T::maxMultiviewInstanceIndex),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxMultiviewInstanceIndex: false_type { using type = void; }; template<class T> struct is_member_maxMultiviewInstanceIndex<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxMultiviewInstanceIndex),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxMultiviewInstanceIndex); }; } template<class T> struct has_member_maxMultiviewInstanceIndex { const static e_member_presence value = (e_member_presence)(impl::is_member_maxMultiviewInstanceIndex<T>::value + 2*impl::is_static_member_maxMultiviewInstanceIndex<T>::value + 4*is_const<typename impl::is_member_maxMultiviewInstanceIndex<T>::type>::value); }; template<class T, class F> struct has_member_maxMultiviewInstanceIndex_with_type : bool_constant<has_member_maxMultiviewInstanceIndex<T>::value && is_same<typename impl::is_member_maxMultiviewInstanceIndex<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerSetDescriptors: false_type { }; template<class T> struct is_static_member_maxPerSetDescriptors<T,typename enable_if<!is_same<__decltype(T::maxPerSetDescriptors),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerSetDescriptors: false_type { using type = void; }; template<class T> struct is_member_maxPerSetDescriptors<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerSetDescriptors),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerSetDescriptors); }; } template<class T> struct has_member_maxPerSetDescriptors { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerSetDescriptors<T>::value + 2*impl::is_static_member_maxPerSetDescriptors<T>::value + 4*is_const<typename impl::is_member_maxPerSetDescriptors<T>::type>::value); }; template<class T, class F> struct has_member_maxPerSetDescriptors_with_type : bool_constant<has_member_maxPerSetDescriptors<T>::value && is_same<typename impl::is_member_maxPerSetDescriptors<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxMemoryAllocationSize: false_type { }; template<class T> struct is_static_member_maxMemoryAllocationSize<T,typename enable_if<!is_same<__decltype(T::maxMemoryAllocationSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxMemoryAllocationSize: false_type { using type = void; }; template<class T> struct is_member_maxMemoryAllocationSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxMemoryAllocationSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxMemoryAllocationSize); }; } template<class T> struct has_member_maxMemoryAllocationSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxMemoryAllocationSize<T>::value + 2*impl::is_static_member_maxMemoryAllocationSize<T>::value + 4*is_const<typename impl::is_member_maxMemoryAllocationSize<T>::type>::value); }; template<class T, class F> struct has_member_maxMemoryAllocationSize_with_type : bool_constant<has_member_maxMemoryAllocationSize<T>::value && is_same<typename impl::is_member_maxMemoryAllocationSize<T>::type, F>::value> {}; } };

// VK 1.2
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSignedZeroInfNanPreserveFloat64: false_type { }; template<class T> struct is_static_member_shaderSignedZeroInfNanPreserveFloat64<T,typename enable_if<!is_same<__decltype(T::shaderSignedZeroInfNanPreserveFloat64),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSignedZeroInfNanPreserveFloat64: false_type { using type = void; }; template<class T> struct is_member_shaderSignedZeroInfNanPreserveFloat64<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSignedZeroInfNanPreserveFloat64),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSignedZeroInfNanPreserveFloat64); }; } template<class T> struct has_member_shaderSignedZeroInfNanPreserveFloat64 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSignedZeroInfNanPreserveFloat64<T>::value + 2*impl::is_static_member_shaderSignedZeroInfNanPreserveFloat64<T>::value + 4*is_const<typename impl::is_member_shaderSignedZeroInfNanPreserveFloat64<T>::type>::value); }; template<class T, class F> struct has_member_shaderSignedZeroInfNanPreserveFloat64_with_type : bool_constant<has_member_shaderSignedZeroInfNanPreserveFloat64<T>::value && is_same<typename impl::is_member_shaderSignedZeroInfNanPreserveFloat64<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDenormPreserveFloat16: false_type { }; template<class T> struct is_static_member_shaderDenormPreserveFloat16<T,typename enable_if<!is_same<__decltype(T::shaderDenormPreserveFloat16),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDenormPreserveFloat16: false_type { using type = void; }; template<class T> struct is_member_shaderDenormPreserveFloat16<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDenormPreserveFloat16),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDenormPreserveFloat16); }; } template<class T> struct has_member_shaderDenormPreserveFloat16 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDenormPreserveFloat16<T>::value + 2*impl::is_static_member_shaderDenormPreserveFloat16<T>::value + 4*is_const<typename impl::is_member_shaderDenormPreserveFloat16<T>::type>::value); }; template<class T, class F> struct has_member_shaderDenormPreserveFloat16_with_type : bool_constant<has_member_shaderDenormPreserveFloat16<T>::value && is_same<typename impl::is_member_shaderDenormPreserveFloat16<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDenormPreserveFloat32: false_type { }; template<class T> struct is_static_member_shaderDenormPreserveFloat32<T,typename enable_if<!is_same<__decltype(T::shaderDenormPreserveFloat32),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDenormPreserveFloat32: false_type { using type = void; }; template<class T> struct is_member_shaderDenormPreserveFloat32<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDenormPreserveFloat32),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDenormPreserveFloat32); }; } template<class T> struct has_member_shaderDenormPreserveFloat32 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDenormPreserveFloat32<T>::value + 2*impl::is_static_member_shaderDenormPreserveFloat32<T>::value + 4*is_const<typename impl::is_member_shaderDenormPreserveFloat32<T>::type>::value); }; template<class T, class F> struct has_member_shaderDenormPreserveFloat32_with_type : bool_constant<has_member_shaderDenormPreserveFloat32<T>::value && is_same<typename impl::is_member_shaderDenormPreserveFloat32<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDenormPreserveFloat64: false_type { }; template<class T> struct is_static_member_shaderDenormPreserveFloat64<T,typename enable_if<!is_same<__decltype(T::shaderDenormPreserveFloat64),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDenormPreserveFloat64: false_type { using type = void; }; template<class T> struct is_member_shaderDenormPreserveFloat64<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDenormPreserveFloat64),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDenormPreserveFloat64); }; } template<class T> struct has_member_shaderDenormPreserveFloat64 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDenormPreserveFloat64<T>::value + 2*impl::is_static_member_shaderDenormPreserveFloat64<T>::value + 4*is_const<typename impl::is_member_shaderDenormPreserveFloat64<T>::type>::value); }; template<class T, class F> struct has_member_shaderDenormPreserveFloat64_with_type : bool_constant<has_member_shaderDenormPreserveFloat64<T>::value && is_same<typename impl::is_member_shaderDenormPreserveFloat64<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDenormFlushToZeroFloat16: false_type { }; template<class T> struct is_static_member_shaderDenormFlushToZeroFloat16<T,typename enable_if<!is_same<__decltype(T::shaderDenormFlushToZeroFloat16),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDenormFlushToZeroFloat16: false_type { using type = void; }; template<class T> struct is_member_shaderDenormFlushToZeroFloat16<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDenormFlushToZeroFloat16),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDenormFlushToZeroFloat16); }; } template<class T> struct has_member_shaderDenormFlushToZeroFloat16 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDenormFlushToZeroFloat16<T>::value + 2*impl::is_static_member_shaderDenormFlushToZeroFloat16<T>::value + 4*is_const<typename impl::is_member_shaderDenormFlushToZeroFloat16<T>::type>::value); }; template<class T, class F> struct has_member_shaderDenormFlushToZeroFloat16_with_type : bool_constant<has_member_shaderDenormFlushToZeroFloat16<T>::value && is_same<typename impl::is_member_shaderDenormFlushToZeroFloat16<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDenormFlushToZeroFloat32: false_type { }; template<class T> struct is_static_member_shaderDenormFlushToZeroFloat32<T,typename enable_if<!is_same<__decltype(T::shaderDenormFlushToZeroFloat32),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDenormFlushToZeroFloat32: false_type { using type = void; }; template<class T> struct is_member_shaderDenormFlushToZeroFloat32<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDenormFlushToZeroFloat32),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDenormFlushToZeroFloat32); }; } template<class T> struct has_member_shaderDenormFlushToZeroFloat32 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDenormFlushToZeroFloat32<T>::value + 2*impl::is_static_member_shaderDenormFlushToZeroFloat32<T>::value + 4*is_const<typename impl::is_member_shaderDenormFlushToZeroFloat32<T>::type>::value); }; template<class T, class F> struct has_member_shaderDenormFlushToZeroFloat32_with_type : bool_constant<has_member_shaderDenormFlushToZeroFloat32<T>::value && is_same<typename impl::is_member_shaderDenormFlushToZeroFloat32<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDenormFlushToZeroFloat64: false_type { }; template<class T> struct is_static_member_shaderDenormFlushToZeroFloat64<T,typename enable_if<!is_same<__decltype(T::shaderDenormFlushToZeroFloat64),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDenormFlushToZeroFloat64: false_type { using type = void; }; template<class T> struct is_member_shaderDenormFlushToZeroFloat64<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDenormFlushToZeroFloat64),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDenormFlushToZeroFloat64); }; } template<class T> struct has_member_shaderDenormFlushToZeroFloat64 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDenormFlushToZeroFloat64<T>::value + 2*impl::is_static_member_shaderDenormFlushToZeroFloat64<T>::value + 4*is_const<typename impl::is_member_shaderDenormFlushToZeroFloat64<T>::type>::value); }; template<class T, class F> struct has_member_shaderDenormFlushToZeroFloat64_with_type : bool_constant<has_member_shaderDenormFlushToZeroFloat64<T>::value && is_same<typename impl::is_member_shaderDenormFlushToZeroFloat64<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderRoundingModeRTEFloat16: false_type { }; template<class T> struct is_static_member_shaderRoundingModeRTEFloat16<T,typename enable_if<!is_same<__decltype(T::shaderRoundingModeRTEFloat16),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderRoundingModeRTEFloat16: false_type { using type = void; }; template<class T> struct is_member_shaderRoundingModeRTEFloat16<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderRoundingModeRTEFloat16),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderRoundingModeRTEFloat16); }; } template<class T> struct has_member_shaderRoundingModeRTEFloat16 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderRoundingModeRTEFloat16<T>::value + 2*impl::is_static_member_shaderRoundingModeRTEFloat16<T>::value + 4*is_const<typename impl::is_member_shaderRoundingModeRTEFloat16<T>::type>::value); }; template<class T, class F> struct has_member_shaderRoundingModeRTEFloat16_with_type : bool_constant<has_member_shaderRoundingModeRTEFloat16<T>::value && is_same<typename impl::is_member_shaderRoundingModeRTEFloat16<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderRoundingModeRTEFloat32: false_type { }; template<class T> struct is_static_member_shaderRoundingModeRTEFloat32<T,typename enable_if<!is_same<__decltype(T::shaderRoundingModeRTEFloat32),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderRoundingModeRTEFloat32: false_type { using type = void; }; template<class T> struct is_member_shaderRoundingModeRTEFloat32<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderRoundingModeRTEFloat32),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderRoundingModeRTEFloat32); }; } template<class T> struct has_member_shaderRoundingModeRTEFloat32 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderRoundingModeRTEFloat32<T>::value + 2*impl::is_static_member_shaderRoundingModeRTEFloat32<T>::value + 4*is_const<typename impl::is_member_shaderRoundingModeRTEFloat32<T>::type>::value); }; template<class T, class F> struct has_member_shaderRoundingModeRTEFloat32_with_type : bool_constant<has_member_shaderRoundingModeRTEFloat32<T>::value && is_same<typename impl::is_member_shaderRoundingModeRTEFloat32<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderRoundingModeRTEFloat64: false_type { }; template<class T> struct is_static_member_shaderRoundingModeRTEFloat64<T,typename enable_if<!is_same<__decltype(T::shaderRoundingModeRTEFloat64),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderRoundingModeRTEFloat64: false_type { using type = void; }; template<class T> struct is_member_shaderRoundingModeRTEFloat64<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderRoundingModeRTEFloat64),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderRoundingModeRTEFloat64); }; } template<class T> struct has_member_shaderRoundingModeRTEFloat64 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderRoundingModeRTEFloat64<T>::value + 2*impl::is_static_member_shaderRoundingModeRTEFloat64<T>::value + 4*is_const<typename impl::is_member_shaderRoundingModeRTEFloat64<T>::type>::value); }; template<class T, class F> struct has_member_shaderRoundingModeRTEFloat64_with_type : bool_constant<has_member_shaderRoundingModeRTEFloat64<T>::value && is_same<typename impl::is_member_shaderRoundingModeRTEFloat64<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderRoundingModeRTZFloat16: false_type { }; template<class T> struct is_static_member_shaderRoundingModeRTZFloat16<T,typename enable_if<!is_same<__decltype(T::shaderRoundingModeRTZFloat16),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderRoundingModeRTZFloat16: false_type { using type = void; }; template<class T> struct is_member_shaderRoundingModeRTZFloat16<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderRoundingModeRTZFloat16),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderRoundingModeRTZFloat16); }; } template<class T> struct has_member_shaderRoundingModeRTZFloat16 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderRoundingModeRTZFloat16<T>::value + 2*impl::is_static_member_shaderRoundingModeRTZFloat16<T>::value + 4*is_const<typename impl::is_member_shaderRoundingModeRTZFloat16<T>::type>::value); }; template<class T, class F> struct has_member_shaderRoundingModeRTZFloat16_with_type : bool_constant<has_member_shaderRoundingModeRTZFloat16<T>::value && is_same<typename impl::is_member_shaderRoundingModeRTZFloat16<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderRoundingModeRTZFloat32: false_type { }; template<class T> struct is_static_member_shaderRoundingModeRTZFloat32<T,typename enable_if<!is_same<__decltype(T::shaderRoundingModeRTZFloat32),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderRoundingModeRTZFloat32: false_type { using type = void; }; template<class T> struct is_member_shaderRoundingModeRTZFloat32<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderRoundingModeRTZFloat32),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderRoundingModeRTZFloat32); }; } template<class T> struct has_member_shaderRoundingModeRTZFloat32 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderRoundingModeRTZFloat32<T>::value + 2*impl::is_static_member_shaderRoundingModeRTZFloat32<T>::value + 4*is_const<typename impl::is_member_shaderRoundingModeRTZFloat32<T>::type>::value); }; template<class T, class F> struct has_member_shaderRoundingModeRTZFloat32_with_type : bool_constant<has_member_shaderRoundingModeRTZFloat32<T>::value && is_same<typename impl::is_member_shaderRoundingModeRTZFloat32<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderRoundingModeRTZFloat64: false_type { }; template<class T> struct is_static_member_shaderRoundingModeRTZFloat64<T,typename enable_if<!is_same<__decltype(T::shaderRoundingModeRTZFloat64),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderRoundingModeRTZFloat64: false_type { using type = void; }; template<class T> struct is_member_shaderRoundingModeRTZFloat64<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderRoundingModeRTZFloat64),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderRoundingModeRTZFloat64); }; } template<class T> struct has_member_shaderRoundingModeRTZFloat64 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderRoundingModeRTZFloat64<T>::value + 2*impl::is_static_member_shaderRoundingModeRTZFloat64<T>::value + 4*is_const<typename impl::is_member_shaderRoundingModeRTZFloat64<T>::type>::value); }; template<class T, class F> struct has_member_shaderRoundingModeRTZFloat64_with_type : bool_constant<has_member_shaderRoundingModeRTZFloat64<T>::value && is_same<typename impl::is_member_shaderRoundingModeRTZFloat64<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxUpdateAfterBindDescriptorsInAllPools: false_type { }; template<class T> struct is_static_member_maxUpdateAfterBindDescriptorsInAllPools<T,typename enable_if<!is_same<__decltype(T::maxUpdateAfterBindDescriptorsInAllPools),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxUpdateAfterBindDescriptorsInAllPools: false_type { using type = void; }; template<class T> struct is_member_maxUpdateAfterBindDescriptorsInAllPools<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxUpdateAfterBindDescriptorsInAllPools),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxUpdateAfterBindDescriptorsInAllPools); }; } template<class T> struct has_member_maxUpdateAfterBindDescriptorsInAllPools { const static e_member_presence value = (e_member_presence)(impl::is_member_maxUpdateAfterBindDescriptorsInAllPools<T>::value + 2*impl::is_static_member_maxUpdateAfterBindDescriptorsInAllPools<T>::value + 4*is_const<typename impl::is_member_maxUpdateAfterBindDescriptorsInAllPools<T>::type>::value); }; template<class T, class F> struct has_member_maxUpdateAfterBindDescriptorsInAllPools_with_type : bool_constant<has_member_maxUpdateAfterBindDescriptorsInAllPools<T>::value && is_same<typename impl::is_member_maxUpdateAfterBindDescriptorsInAllPools<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderUniformBufferArrayNonUniformIndexingNative: false_type { }; template<class T> struct is_static_member_shaderUniformBufferArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(T::shaderUniformBufferArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderUniformBufferArrayNonUniformIndexingNative: false_type { using type = void; }; template<class T> struct is_member_shaderUniformBufferArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderUniformBufferArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderUniformBufferArrayNonUniformIndexingNative); }; } template<class T> struct has_member_shaderUniformBufferArrayNonUniformIndexingNative { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderUniformBufferArrayNonUniformIndexingNative<T>::value + 2*impl::is_static_member_shaderUniformBufferArrayNonUniformIndexingNative<T>::value + 4*is_const<typename impl::is_member_shaderUniformBufferArrayNonUniformIndexingNative<T>::type>::value); }; template<class T, class F> struct has_member_shaderUniformBufferArrayNonUniformIndexingNative_with_type : bool_constant<has_member_shaderUniformBufferArrayNonUniformIndexingNative<T>::value && is_same<typename impl::is_member_shaderUniformBufferArrayNonUniformIndexingNative<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSampledImageArrayNonUniformIndexingNative: false_type { }; template<class T> struct is_static_member_shaderSampledImageArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(T::shaderSampledImageArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSampledImageArrayNonUniformIndexingNative: false_type { using type = void; }; template<class T> struct is_member_shaderSampledImageArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSampledImageArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSampledImageArrayNonUniformIndexingNative); }; } template<class T> struct has_member_shaderSampledImageArrayNonUniformIndexingNative { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSampledImageArrayNonUniformIndexingNative<T>::value + 2*impl::is_static_member_shaderSampledImageArrayNonUniformIndexingNative<T>::value + 4*is_const<typename impl::is_member_shaderSampledImageArrayNonUniformIndexingNative<T>::type>::value); }; template<class T, class F> struct has_member_shaderSampledImageArrayNonUniformIndexingNative_with_type : bool_constant<has_member_shaderSampledImageArrayNonUniformIndexingNative<T>::value && is_same<typename impl::is_member_shaderSampledImageArrayNonUniformIndexingNative<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderStorageBufferArrayNonUniformIndexingNative: false_type { }; template<class T> struct is_static_member_shaderStorageBufferArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(T::shaderStorageBufferArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderStorageBufferArrayNonUniformIndexingNative: false_type { using type = void; }; template<class T> struct is_member_shaderStorageBufferArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderStorageBufferArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderStorageBufferArrayNonUniformIndexingNative); }; } template<class T> struct has_member_shaderStorageBufferArrayNonUniformIndexingNative { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderStorageBufferArrayNonUniformIndexingNative<T>::value + 2*impl::is_static_member_shaderStorageBufferArrayNonUniformIndexingNative<T>::value + 4*is_const<typename impl::is_member_shaderStorageBufferArrayNonUniformIndexingNative<T>::type>::value); }; template<class T, class F> struct has_member_shaderStorageBufferArrayNonUniformIndexingNative_with_type : bool_constant<has_member_shaderStorageBufferArrayNonUniformIndexingNative<T>::value && is_same<typename impl::is_member_shaderStorageBufferArrayNonUniformIndexingNative<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderStorageImageArrayNonUniformIndexingNative: false_type { }; template<class T> struct is_static_member_shaderStorageImageArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(T::shaderStorageImageArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderStorageImageArrayNonUniformIndexingNative: false_type { using type = void; }; template<class T> struct is_member_shaderStorageImageArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderStorageImageArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderStorageImageArrayNonUniformIndexingNative); }; } template<class T> struct has_member_shaderStorageImageArrayNonUniformIndexingNative { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderStorageImageArrayNonUniformIndexingNative<T>::value + 2*impl::is_static_member_shaderStorageImageArrayNonUniformIndexingNative<T>::value + 4*is_const<typename impl::is_member_shaderStorageImageArrayNonUniformIndexingNative<T>::type>::value); }; template<class T, class F> struct has_member_shaderStorageImageArrayNonUniformIndexingNative_with_type : bool_constant<has_member_shaderStorageImageArrayNonUniformIndexingNative<T>::value && is_same<typename impl::is_member_shaderStorageImageArrayNonUniformIndexingNative<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderInputAttachmentArrayNonUniformIndexingNative: false_type { }; template<class T> struct is_static_member_shaderInputAttachmentArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(T::shaderInputAttachmentArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderInputAttachmentArrayNonUniformIndexingNative: false_type { using type = void; }; template<class T> struct is_member_shaderInputAttachmentArrayNonUniformIndexingNative<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderInputAttachmentArrayNonUniformIndexingNative),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderInputAttachmentArrayNonUniformIndexingNative); }; } template<class T> struct has_member_shaderInputAttachmentArrayNonUniformIndexingNative { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderInputAttachmentArrayNonUniformIndexingNative<T>::value + 2*impl::is_static_member_shaderInputAttachmentArrayNonUniformIndexingNative<T>::value + 4*is_const<typename impl::is_member_shaderInputAttachmentArrayNonUniformIndexingNative<T>::type>::value); }; template<class T, class F> struct has_member_shaderInputAttachmentArrayNonUniformIndexingNative_with_type : bool_constant<has_member_shaderInputAttachmentArrayNonUniformIndexingNative<T>::value && is_same<typename impl::is_member_shaderInputAttachmentArrayNonUniformIndexingNative<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_robustBufferAccessUpdateAfterBind: false_type { }; template<class T> struct is_static_member_robustBufferAccessUpdateAfterBind<T,typename enable_if<!is_same<__decltype(T::robustBufferAccessUpdateAfterBind),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_robustBufferAccessUpdateAfterBind: false_type { using type = void; }; template<class T> struct is_member_robustBufferAccessUpdateAfterBind<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().robustBufferAccessUpdateAfterBind),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().robustBufferAccessUpdateAfterBind); }; } template<class T> struct has_member_robustBufferAccessUpdateAfterBind { const static e_member_presence value = (e_member_presence)(impl::is_member_robustBufferAccessUpdateAfterBind<T>::value + 2*impl::is_static_member_robustBufferAccessUpdateAfterBind<T>::value + 4*is_const<typename impl::is_member_robustBufferAccessUpdateAfterBind<T>::type>::value); }; template<class T, class F> struct has_member_robustBufferAccessUpdateAfterBind_with_type : bool_constant<has_member_robustBufferAccessUpdateAfterBind<T>::value && is_same<typename impl::is_member_robustBufferAccessUpdateAfterBind<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_quadDivergentImplicitLod: false_type { }; template<class T> struct is_static_member_quadDivergentImplicitLod<T,typename enable_if<!is_same<__decltype(T::quadDivergentImplicitLod),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_quadDivergentImplicitLod: false_type { using type = void; }; template<class T> struct is_member_quadDivergentImplicitLod<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().quadDivergentImplicitLod),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().quadDivergentImplicitLod); }; } template<class T> struct has_member_quadDivergentImplicitLod { const static e_member_presence value = (e_member_presence)(impl::is_member_quadDivergentImplicitLod<T>::value + 2*impl::is_static_member_quadDivergentImplicitLod<T>::value + 4*is_const<typename impl::is_member_quadDivergentImplicitLod<T>::type>::value); }; template<class T, class F> struct has_member_quadDivergentImplicitLod_with_type : bool_constant<has_member_quadDivergentImplicitLod<T>::value && is_same<typename impl::is_member_quadDivergentImplicitLod<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUpdateAfterBindSamplers: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUpdateAfterBindSamplers<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUpdateAfterBindSamplers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUpdateAfterBindSamplers: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUpdateAfterBindSamplers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindSamplers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindSamplers); }; } template<class T> struct has_member_maxPerStageDescriptorUpdateAfterBindSamplers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUpdateAfterBindSamplers<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUpdateAfterBindSamplers<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindSamplers<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUpdateAfterBindSamplers_with_type : bool_constant<has_member_maxPerStageDescriptorUpdateAfterBindSamplers<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindSamplers<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUpdateAfterBindUBOs: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUpdateAfterBindUBOs<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUpdateAfterBindUBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUpdateAfterBindUBOs: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUpdateAfterBindUBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindUBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindUBOs); }; } template<class T> struct has_member_maxPerStageDescriptorUpdateAfterBindUBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUpdateAfterBindUBOs<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUpdateAfterBindUBOs<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindUBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUpdateAfterBindUBOs_with_type : bool_constant<has_member_maxPerStageDescriptorUpdateAfterBindUBOs<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindUBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUpdateAfterBindSSBOs: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUpdateAfterBindSSBOs<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUpdateAfterBindSSBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUpdateAfterBindSSBOs: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUpdateAfterBindSSBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindSSBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindSSBOs); }; } template<class T> struct has_member_maxPerStageDescriptorUpdateAfterBindSSBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUpdateAfterBindSSBOs<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUpdateAfterBindSSBOs<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindSSBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUpdateAfterBindSSBOs_with_type : bool_constant<has_member_maxPerStageDescriptorUpdateAfterBindSSBOs<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindSSBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUpdateAfterBindImages: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUpdateAfterBindImages<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUpdateAfterBindImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUpdateAfterBindImages: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUpdateAfterBindImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindImages); }; } template<class T> struct has_member_maxPerStageDescriptorUpdateAfterBindImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUpdateAfterBindImages<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUpdateAfterBindImages<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindImages<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUpdateAfterBindImages_with_type : bool_constant<has_member_maxPerStageDescriptorUpdateAfterBindImages<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUpdateAfterBindStorageImages: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUpdateAfterBindStorageImages<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUpdateAfterBindStorageImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUpdateAfterBindStorageImages: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUpdateAfterBindStorageImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindStorageImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindStorageImages); }; } template<class T> struct has_member_maxPerStageDescriptorUpdateAfterBindStorageImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUpdateAfterBindStorageImages<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUpdateAfterBindStorageImages<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindStorageImages<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUpdateAfterBindStorageImages_with_type : bool_constant<has_member_maxPerStageDescriptorUpdateAfterBindStorageImages<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindStorageImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUpdateAfterBindInputAttachments: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUpdateAfterBindInputAttachments),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUpdateAfterBindInputAttachments: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindInputAttachments),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindInputAttachments); }; } template<class T> struct has_member_maxPerStageDescriptorUpdateAfterBindInputAttachments { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUpdateAfterBindInputAttachments_with_type : bool_constant<has_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageUpdateAfterBindResources: false_type { }; template<class T> struct is_static_member_maxPerStageUpdateAfterBindResources<T,typename enable_if<!is_same<__decltype(T::maxPerStageUpdateAfterBindResources),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageUpdateAfterBindResources: false_type { using type = void; }; template<class T> struct is_member_maxPerStageUpdateAfterBindResources<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageUpdateAfterBindResources),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageUpdateAfterBindResources); }; } template<class T> struct has_member_maxPerStageUpdateAfterBindResources { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageUpdateAfterBindResources<T>::value + 2*impl::is_static_member_maxPerStageUpdateAfterBindResources<T>::value + 4*is_const<typename impl::is_member_maxPerStageUpdateAfterBindResources<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageUpdateAfterBindResources_with_type : bool_constant<has_member_maxPerStageUpdateAfterBindResources<T>::value && is_same<typename impl::is_member_maxPerStageUpdateAfterBindResources<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindSamplers: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindSamplers<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindSamplers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindSamplers: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindSamplers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindSamplers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindSamplers); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindSamplers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindSamplers<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindSamplers<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindSamplers<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindSamplers_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindSamplers<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindSamplers<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindUBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindUBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindUBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindUBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindUBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindUBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindUBOs); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindUBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindUBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindUBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindUBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindUBOs_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindUBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindUBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindSSBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindSSBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindSSBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindSSBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindSSBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindSSBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindSSBOs); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindSSBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindSSBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindSSBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindSSBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindSSBOs_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindSSBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindSSBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindImages: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindImages<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindImages: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindImages); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindImages<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindImages<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindImages<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindImages_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindImages<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindStorageImages: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindStorageImages<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindStorageImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindStorageImages: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindStorageImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindStorageImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindStorageImages); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindStorageImages { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindStorageImages<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindStorageImages<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindStorageImages<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindStorageImages_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindStorageImages<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindStorageImages<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindInputAttachments: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindInputAttachments<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindInputAttachments),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindInputAttachments: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindInputAttachments<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindInputAttachments),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindInputAttachments); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindInputAttachments { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindInputAttachments<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindInputAttachments<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindInputAttachments<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindInputAttachments_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindInputAttachments<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindInputAttachments<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_supportedDepthResolveModesBitPattern: false_type { }; template<class T> struct is_static_member_supportedDepthResolveModesBitPattern<T,typename enable_if<!is_same<__decltype(T::supportedDepthResolveModesBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_supportedDepthResolveModesBitPattern: false_type { using type = void; }; template<class T> struct is_member_supportedDepthResolveModesBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().supportedDepthResolveModesBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().supportedDepthResolveModesBitPattern); }; } template<class T> struct has_member_supportedDepthResolveModesBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_supportedDepthResolveModesBitPattern<T>::value + 2*impl::is_static_member_supportedDepthResolveModesBitPattern<T>::value + 4*is_const<typename impl::is_member_supportedDepthResolveModesBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_supportedDepthResolveModesBitPattern_with_type : bool_constant<has_member_supportedDepthResolveModesBitPattern<T>::value && is_same<typename impl::is_member_supportedDepthResolveModesBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_supportedStencilResolveModesBitPattern: false_type { }; template<class T> struct is_static_member_supportedStencilResolveModesBitPattern<T,typename enable_if<!is_same<__decltype(T::supportedStencilResolveModesBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_supportedStencilResolveModesBitPattern: false_type { using type = void; }; template<class T> struct is_member_supportedStencilResolveModesBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().supportedStencilResolveModesBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().supportedStencilResolveModesBitPattern); }; } template<class T> struct has_member_supportedStencilResolveModesBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_supportedStencilResolveModesBitPattern<T>::value + 2*impl::is_static_member_supportedStencilResolveModesBitPattern<T>::value + 4*is_const<typename impl::is_member_supportedStencilResolveModesBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_supportedStencilResolveModesBitPattern_with_type : bool_constant<has_member_supportedStencilResolveModesBitPattern<T>::value && is_same<typename impl::is_member_supportedStencilResolveModesBitPattern<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_filterMinmaxImageComponentMapping: false_type { }; template<class T> struct is_static_member_filterMinmaxImageComponentMapping<T,typename enable_if<!is_same<__decltype(T::filterMinmaxImageComponentMapping),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_filterMinmaxImageComponentMapping: false_type { using type = void; }; template<class T> struct is_member_filterMinmaxImageComponentMapping<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().filterMinmaxImageComponentMapping),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().filterMinmaxImageComponentMapping); }; } template<class T> struct has_member_filterMinmaxImageComponentMapping { const static e_member_presence value = (e_member_presence)(impl::is_member_filterMinmaxImageComponentMapping<T>::value + 2*impl::is_static_member_filterMinmaxImageComponentMapping<T>::value + 4*is_const<typename impl::is_member_filterMinmaxImageComponentMapping<T>::type>::value); }; template<class T, class F> struct has_member_filterMinmaxImageComponentMapping_with_type : bool_constant<has_member_filterMinmaxImageComponentMapping<T>::value && is_same<typename impl::is_member_filterMinmaxImageComponentMapping<T>::type, F>::value> {}; } };

// VK 1.3
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minSubgroupSize: false_type { }; template<class T> struct is_static_member_minSubgroupSize<T,typename enable_if<!is_same<__decltype(T::minSubgroupSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minSubgroupSize: false_type { using type = void; }; template<class T> struct is_member_minSubgroupSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minSubgroupSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minSubgroupSize); }; } template<class T> struct has_member_minSubgroupSize { const static e_member_presence value = (e_member_presence)(impl::is_member_minSubgroupSize<T>::value + 2*impl::is_static_member_minSubgroupSize<T>::value + 4*is_const<typename impl::is_member_minSubgroupSize<T>::type>::value); }; template<class T, class F> struct has_member_minSubgroupSize_with_type : bool_constant<has_member_minSubgroupSize<T>::value && is_same<typename impl::is_member_minSubgroupSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSubgroupSize: false_type { }; template<class T> struct is_static_member_maxSubgroupSize<T,typename enable_if<!is_same<__decltype(T::maxSubgroupSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSubgroupSize: false_type { using type = void; }; template<class T> struct is_member_maxSubgroupSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSubgroupSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSubgroupSize); }; } template<class T> struct has_member_maxSubgroupSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSubgroupSize<T>::value + 2*impl::is_static_member_maxSubgroupSize<T>::value + 4*is_const<typename impl::is_member_maxSubgroupSize<T>::type>::value); }; template<class T, class F> struct has_member_maxSubgroupSize_with_type : bool_constant<has_member_maxSubgroupSize<T>::value && is_same<typename impl::is_member_maxSubgroupSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxComputeWorkgroupSubgroups: false_type { }; template<class T> struct is_static_member_maxComputeWorkgroupSubgroups<T,typename enable_if<!is_same<__decltype(T::maxComputeWorkgroupSubgroups),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxComputeWorkgroupSubgroups: false_type { using type = void; }; template<class T> struct is_member_maxComputeWorkgroupSubgroups<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxComputeWorkgroupSubgroups),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxComputeWorkgroupSubgroups); }; } template<class T> struct has_member_maxComputeWorkgroupSubgroups { const static e_member_presence value = (e_member_presence)(impl::is_member_maxComputeWorkgroupSubgroups<T>::value + 2*impl::is_static_member_maxComputeWorkgroupSubgroups<T>::value + 4*is_const<typename impl::is_member_maxComputeWorkgroupSubgroups<T>::type>::value); }; template<class T, class F> struct has_member_maxComputeWorkgroupSubgroups_with_type : bool_constant<has_member_maxComputeWorkgroupSubgroups<T>::value && is_same<typename impl::is_member_maxComputeWorkgroupSubgroups<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_requiredSubgroupSizeStagesBitPattern: false_type { }; template<class T> struct is_static_member_requiredSubgroupSizeStagesBitPattern<T,typename enable_if<!is_same<__decltype(T::requiredSubgroupSizeStagesBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_requiredSubgroupSizeStagesBitPattern: false_type { using type = void; }; template<class T> struct is_member_requiredSubgroupSizeStagesBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().requiredSubgroupSizeStagesBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().requiredSubgroupSizeStagesBitPattern); }; } template<class T> struct has_member_requiredSubgroupSizeStagesBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_requiredSubgroupSizeStagesBitPattern<T>::value + 2*impl::is_static_member_requiredSubgroupSizeStagesBitPattern<T>::value + 4*is_const<typename impl::is_member_requiredSubgroupSizeStagesBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_requiredSubgroupSizeStagesBitPattern_with_type : bool_constant<has_member_requiredSubgroupSizeStagesBitPattern<T>::value && is_same<typename impl::is_member_requiredSubgroupSizeStagesBitPattern<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct8BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct8BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct8BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct8BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct8BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct8BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct8BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProduct8BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct8BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct8BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct8BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct8BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProduct8BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct8BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct8BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct8BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct8BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct8BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct8BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct8BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct8BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProduct8BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct8BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct8BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct8BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct8BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProduct8BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct8BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct8BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct8BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct8BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct8BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct8BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct8BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct8BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProduct8BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct8BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct8BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct8BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct8BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProduct8BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct8BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct4x8BitPackedUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct4x8BitPackedUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct4x8BitPackedUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct4x8BitPackedUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct4x8BitPackedUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct4x8BitPackedUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct4x8BitPackedUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProduct4x8BitPackedUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct4x8BitPackedUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct4x8BitPackedUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct4x8BitPackedUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct4x8BitPackedUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProduct4x8BitPackedUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct4x8BitPackedUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct4x8BitPackedSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct4x8BitPackedSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct4x8BitPackedSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct4x8BitPackedSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct4x8BitPackedSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct4x8BitPackedSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct4x8BitPackedSignedAccelerated); }; } template<class T> struct has_member_integerDotProduct4x8BitPackedSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct4x8BitPackedSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct4x8BitPackedSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct4x8BitPackedSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct4x8BitPackedSignedAccelerated_with_type : bool_constant<has_member_integerDotProduct4x8BitPackedSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct4x8BitPackedSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct4x8BitPackedMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct4x8BitPackedMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct4x8BitPackedMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct16BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct16BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct16BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct16BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct16BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct16BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct16BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProduct16BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct16BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct16BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct16BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct16BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProduct16BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct16BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct16BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct16BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct16BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct16BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct16BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct16BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct16BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProduct16BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct16BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct16BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct16BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct16BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProduct16BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct16BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct16BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct16BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct16BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct16BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct16BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct16BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct16BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProduct16BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct16BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct16BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct16BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct16BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProduct16BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct16BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct32BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct32BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct32BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct32BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct32BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct32BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct32BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProduct32BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct32BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct32BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct32BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct32BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProduct32BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct32BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct32BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct32BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct32BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct32BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct32BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct32BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct32BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProduct32BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct32BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct32BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct32BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct32BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProduct32BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct32BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct32BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct32BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct32BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct32BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct32BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct32BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct32BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProduct32BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct32BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct32BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct32BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct32BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProduct32BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct32BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct64BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct64BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct64BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct64BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct64BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct64BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct64BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProduct64BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct64BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct64BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct64BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct64BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProduct64BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct64BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct64BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct64BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct64BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct64BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct64BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct64BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct64BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProduct64BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct64BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct64BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct64BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct64BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProduct64BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct64BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProduct64BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProduct64BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProduct64BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProduct64BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProduct64BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProduct64BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProduct64BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProduct64BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProduct64BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProduct64BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProduct64BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProduct64BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProduct64BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProduct64BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating8BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating8BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating8BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating8BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating8BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating8BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating16BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating16BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating16BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating16BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating16BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating16BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating32BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating32BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating32BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating32BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating32BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating32BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating64BitUnsignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating64BitUnsignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating64BitUnsignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating64BitSignedAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating64BitSignedAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating64BitSignedAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: false_type { }; template<class T> struct is_static_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(T::integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: false_type { using type = void; }; template<class T> struct is_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated); }; } template<class T> struct has_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated { const static e_member_presence value = (e_member_presence)(impl::is_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<T>::value + 2*impl::is_static_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<T>::value + 4*is_const<typename impl::is_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<T>::type>::value); }; template<class T, class F> struct has_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_with_type : bool_constant<has_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<T>::value && is_same<typename impl::is_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_storageTexelBufferOffsetAlignmentBytes: false_type { }; template<class T> struct is_static_member_storageTexelBufferOffsetAlignmentBytes<T,typename enable_if<!is_same<__decltype(T::storageTexelBufferOffsetAlignmentBytes),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_storageTexelBufferOffsetAlignmentBytes: false_type { using type = void; }; template<class T> struct is_member_storageTexelBufferOffsetAlignmentBytes<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().storageTexelBufferOffsetAlignmentBytes),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().storageTexelBufferOffsetAlignmentBytes); }; } template<class T> struct has_member_storageTexelBufferOffsetAlignmentBytes { const static e_member_presence value = (e_member_presence)(impl::is_member_storageTexelBufferOffsetAlignmentBytes<T>::value + 2*impl::is_static_member_storageTexelBufferOffsetAlignmentBytes<T>::value + 4*is_const<typename impl::is_member_storageTexelBufferOffsetAlignmentBytes<T>::type>::value); }; template<class T, class F> struct has_member_storageTexelBufferOffsetAlignmentBytes_with_type : bool_constant<has_member_storageTexelBufferOffsetAlignmentBytes<T>::value && is_same<typename impl::is_member_storageTexelBufferOffsetAlignmentBytes<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_uniformTexelBufferOffsetAlignmentBytes: false_type { }; template<class T> struct is_static_member_uniformTexelBufferOffsetAlignmentBytes<T,typename enable_if<!is_same<__decltype(T::uniformTexelBufferOffsetAlignmentBytes),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_uniformTexelBufferOffsetAlignmentBytes: false_type { using type = void; }; template<class T> struct is_member_uniformTexelBufferOffsetAlignmentBytes<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().uniformTexelBufferOffsetAlignmentBytes),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().uniformTexelBufferOffsetAlignmentBytes); }; } template<class T> struct has_member_uniformTexelBufferOffsetAlignmentBytes { const static e_member_presence value = (e_member_presence)(impl::is_member_uniformTexelBufferOffsetAlignmentBytes<T>::value + 2*impl::is_static_member_uniformTexelBufferOffsetAlignmentBytes<T>::value + 4*is_const<typename impl::is_member_uniformTexelBufferOffsetAlignmentBytes<T>::type>::value); }; template<class T, class F> struct has_member_uniformTexelBufferOffsetAlignmentBytes_with_type : bool_constant<has_member_uniformTexelBufferOffsetAlignmentBytes<T>::value && is_same<typename impl::is_member_uniformTexelBufferOffsetAlignmentBytes<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxBufferSize: false_type { }; template<class T> struct is_static_member_maxBufferSize<T,typename enable_if<!is_same<__decltype(T::maxBufferSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxBufferSize: false_type { using type = void; }; template<class T> struct is_member_maxBufferSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxBufferSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxBufferSize); }; } template<class T> struct has_member_maxBufferSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxBufferSize<T>::value + 2*impl::is_static_member_maxBufferSize<T>::value + 4*is_const<typename impl::is_member_maxBufferSize<T>::type>::value); }; template<class T, class F> struct has_member_maxBufferSize_with_type : bool_constant<has_member_maxBufferSize<T>::value && is_same<typename impl::is_member_maxBufferSize<T>::type, F>::value> {}; } };

// Nabla Core Extensions
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minImportedHostPointerAlignment: false_type { }; template<class T> struct is_static_member_minImportedHostPointerAlignment<T,typename enable_if<!is_same<__decltype(T::minImportedHostPointerAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minImportedHostPointerAlignment: false_type { using type = void; }; template<class T> struct is_member_minImportedHostPointerAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minImportedHostPointerAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minImportedHostPointerAlignment); }; } template<class T> struct has_member_minImportedHostPointerAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_minImportedHostPointerAlignment<T>::value + 2*impl::is_static_member_minImportedHostPointerAlignment<T>::value + 4*is_const<typename impl::is_member_minImportedHostPointerAlignment<T>::type>::value); }; template<class T, class F> struct has_member_minImportedHostPointerAlignment_with_type : bool_constant<has_member_minImportedHostPointerAlignment<T>::value && is_same<typename impl::is_member_minImportedHostPointerAlignment<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat32AtomicAdd: false_type { }; template<class T> struct is_static_member_shaderBufferFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat32AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat32AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat32AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat32AtomicAdd); }; } template<class T> struct has_member_shaderBufferFloat32AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat32AtomicAdd<T>::value + 2*impl::is_static_member_shaderBufferFloat32AtomicAdd<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat32AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat32AtomicAdd_with_type : bool_constant<has_member_shaderBufferFloat32AtomicAdd<T>::value && is_same<typename impl::is_member_shaderBufferFloat32AtomicAdd<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat64Atomics: false_type { }; template<class T> struct is_static_member_shaderBufferFloat64Atomics<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat64Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat64Atomics: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat64Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat64Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat64Atomics); }; } template<class T> struct has_member_shaderBufferFloat64Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat64Atomics<T>::value + 2*impl::is_static_member_shaderBufferFloat64Atomics<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat64Atomics<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat64Atomics_with_type : bool_constant<has_member_shaderBufferFloat64Atomics<T>::value && is_same<typename impl::is_member_shaderBufferFloat64Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat64AtomicAdd: false_type { }; template<class T> struct is_static_member_shaderBufferFloat64AtomicAdd<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat64AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat64AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat64AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat64AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat64AtomicAdd); }; } template<class T> struct has_member_shaderBufferFloat64AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat64AtomicAdd<T>::value + 2*impl::is_static_member_shaderBufferFloat64AtomicAdd<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat64AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat64AtomicAdd_with_type : bool_constant<has_member_shaderBufferFloat64AtomicAdd<T>::value && is_same<typename impl::is_member_shaderBufferFloat64AtomicAdd<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat32AtomicAdd: false_type { }; template<class T> struct is_static_member_shaderSharedFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat32AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat32AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat32AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat32AtomicAdd); }; } template<class T> struct has_member_shaderSharedFloat32AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat32AtomicAdd<T>::value + 2*impl::is_static_member_shaderSharedFloat32AtomicAdd<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat32AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat32AtomicAdd_with_type : bool_constant<has_member_shaderSharedFloat32AtomicAdd<T>::value && is_same<typename impl::is_member_shaderSharedFloat32AtomicAdd<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat64Atomics: false_type { }; template<class T> struct is_static_member_shaderSharedFloat64Atomics<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat64Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat64Atomics: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat64Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat64Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat64Atomics); }; } template<class T> struct has_member_shaderSharedFloat64Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat64Atomics<T>::value + 2*impl::is_static_member_shaderSharedFloat64Atomics<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat64Atomics<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat64Atomics_with_type : bool_constant<has_member_shaderSharedFloat64Atomics<T>::value && is_same<typename impl::is_member_shaderSharedFloat64Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat64AtomicAdd: false_type { }; template<class T> struct is_static_member_shaderSharedFloat64AtomicAdd<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat64AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat64AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat64AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat64AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat64AtomicAdd); }; } template<class T> struct has_member_shaderSharedFloat64AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat64AtomicAdd<T>::value + 2*impl::is_static_member_shaderSharedFloat64AtomicAdd<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat64AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat64AtomicAdd_with_type : bool_constant<has_member_shaderSharedFloat64AtomicAdd<T>::value && is_same<typename impl::is_member_shaderSharedFloat64AtomicAdd<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderImageFloat32AtomicAdd: false_type { }; template<class T> struct is_static_member_shaderImageFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(T::shaderImageFloat32AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderImageFloat32AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_shaderImageFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderImageFloat32AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderImageFloat32AtomicAdd); }; } template<class T> struct has_member_shaderImageFloat32AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderImageFloat32AtomicAdd<T>::value + 2*impl::is_static_member_shaderImageFloat32AtomicAdd<T>::value + 4*is_const<typename impl::is_member_shaderImageFloat32AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_shaderImageFloat32AtomicAdd_with_type : bool_constant<has_member_shaderImageFloat32AtomicAdd<T>::value && is_same<typename impl::is_member_shaderImageFloat32AtomicAdd<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sparseImageFloat32Atomics: false_type { }; template<class T> struct is_static_member_sparseImageFloat32Atomics<T,typename enable_if<!is_same<__decltype(T::sparseImageFloat32Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sparseImageFloat32Atomics: false_type { using type = void; }; template<class T> struct is_member_sparseImageFloat32Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sparseImageFloat32Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sparseImageFloat32Atomics); }; } template<class T> struct has_member_sparseImageFloat32Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_sparseImageFloat32Atomics<T>::value + 2*impl::is_static_member_sparseImageFloat32Atomics<T>::value + 4*is_const<typename impl::is_member_sparseImageFloat32Atomics<T>::type>::value); }; template<class T, class F> struct has_member_sparseImageFloat32Atomics_with_type : bool_constant<has_member_sparseImageFloat32Atomics<T>::value && is_same<typename impl::is_member_sparseImageFloat32Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sparseImageFloat32AtomicAdd: false_type { }; template<class T> struct is_static_member_sparseImageFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(T::sparseImageFloat32AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sparseImageFloat32AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_sparseImageFloat32AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sparseImageFloat32AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sparseImageFloat32AtomicAdd); }; } template<class T> struct has_member_sparseImageFloat32AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_sparseImageFloat32AtomicAdd<T>::value + 2*impl::is_static_member_sparseImageFloat32AtomicAdd<T>::value + 4*is_const<typename impl::is_member_sparseImageFloat32AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_sparseImageFloat32AtomicAdd_with_type : bool_constant<has_member_sparseImageFloat32AtomicAdd<T>::value && is_same<typename impl::is_member_sparseImageFloat32AtomicAdd<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_robustStorageBufferAccessSizeAlignment: false_type { }; template<class T> struct is_static_member_robustStorageBufferAccessSizeAlignment<T,typename enable_if<!is_same<__decltype(T::robustStorageBufferAccessSizeAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_robustStorageBufferAccessSizeAlignment: false_type { using type = void; }; template<class T> struct is_member_robustStorageBufferAccessSizeAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().robustStorageBufferAccessSizeAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().robustStorageBufferAccessSizeAlignment); }; } template<class T> struct has_member_robustStorageBufferAccessSizeAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_robustStorageBufferAccessSizeAlignment<T>::value + 2*impl::is_static_member_robustStorageBufferAccessSizeAlignment<T>::value + 4*is_const<typename impl::is_member_robustStorageBufferAccessSizeAlignment<T>::type>::value); }; template<class T, class F> struct has_member_robustStorageBufferAccessSizeAlignment_with_type : bool_constant<has_member_robustStorageBufferAccessSizeAlignment<T>::value && is_same<typename impl::is_member_robustStorageBufferAccessSizeAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_robustUniformBufferAccessSizeAlignment: false_type { }; template<class T> struct is_static_member_robustUniformBufferAccessSizeAlignment<T,typename enable_if<!is_same<__decltype(T::robustUniformBufferAccessSizeAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_robustUniformBufferAccessSizeAlignment: false_type { using type = void; }; template<class T> struct is_member_robustUniformBufferAccessSizeAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().robustUniformBufferAccessSizeAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().robustUniformBufferAccessSizeAlignment); }; } template<class T> struct has_member_robustUniformBufferAccessSizeAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_robustUniformBufferAccessSizeAlignment<T>::value + 2*impl::is_static_member_robustUniformBufferAccessSizeAlignment<T>::value + 4*is_const<typename impl::is_member_robustUniformBufferAccessSizeAlignment<T>::type>::value); }; template<class T, class F> struct has_member_robustUniformBufferAccessSizeAlignment_with_type : bool_constant<has_member_robustUniformBufferAccessSizeAlignment<T>::value && is_same<typename impl::is_member_robustUniformBufferAccessSizeAlignment<T>::type, F>::value> {}; } };

// Extensions
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderTrinaryMinmax: false_type { }; template<class T> struct is_static_member_shaderTrinaryMinmax<T,typename enable_if<!is_same<__decltype(T::shaderTrinaryMinmax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderTrinaryMinmax: false_type { using type = void; }; template<class T> struct is_member_shaderTrinaryMinmax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderTrinaryMinmax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderTrinaryMinmax); }; } template<class T> struct has_member_shaderTrinaryMinmax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderTrinaryMinmax<T>::value + 2*impl::is_static_member_shaderTrinaryMinmax<T>::value + 4*is_const<typename impl::is_member_shaderTrinaryMinmax<T>::type>::value); }; template<class T, class F> struct has_member_shaderTrinaryMinmax_with_type : bool_constant<has_member_shaderTrinaryMinmax<T>::value && is_same<typename impl::is_member_shaderTrinaryMinmax<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderExplicitVertexParameter: false_type { }; template<class T> struct is_static_member_shaderExplicitVertexParameter<T,typename enable_if<!is_same<__decltype(T::shaderExplicitVertexParameter),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderExplicitVertexParameter: false_type { using type = void; }; template<class T> struct is_member_shaderExplicitVertexParameter<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderExplicitVertexParameter),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderExplicitVertexParameter); }; } template<class T> struct has_member_shaderExplicitVertexParameter { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderExplicitVertexParameter<T>::value + 2*impl::is_static_member_shaderExplicitVertexParameter<T>::value + 4*is_const<typename impl::is_member_shaderExplicitVertexParameter<T>::type>::value); }; template<class T, class F> struct has_member_shaderExplicitVertexParameter_with_type : bool_constant<has_member_shaderExplicitVertexParameter<T>::value && is_same<typename impl::is_member_shaderExplicitVertexParameter<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_gpuShaderHalfFloatAMD: false_type { }; template<class T> struct is_static_member_gpuShaderHalfFloatAMD<T,typename enable_if<!is_same<__decltype(T::gpuShaderHalfFloatAMD),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_gpuShaderHalfFloatAMD: false_type { using type = void; }; template<class T> struct is_member_gpuShaderHalfFloatAMD<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().gpuShaderHalfFloatAMD),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().gpuShaderHalfFloatAMD); }; } template<class T> struct has_member_gpuShaderHalfFloatAMD { const static e_member_presence value = (e_member_presence)(impl::is_member_gpuShaderHalfFloatAMD<T>::value + 2*impl::is_static_member_gpuShaderHalfFloatAMD<T>::value + 4*is_const<typename impl::is_member_gpuShaderHalfFloatAMD<T>::type>::value); }; template<class T, class F> struct has_member_gpuShaderHalfFloatAMD_with_type : bool_constant<has_member_gpuShaderHalfFloatAMD<T>::value && is_same<typename impl::is_member_gpuShaderHalfFloatAMD<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderImageLoadStoreLod: false_type { }; template<class T> struct is_static_member_shaderImageLoadStoreLod<T,typename enable_if<!is_same<__decltype(T::shaderImageLoadStoreLod),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderImageLoadStoreLod: false_type { using type = void; }; template<class T> struct is_member_shaderImageLoadStoreLod<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderImageLoadStoreLod),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderImageLoadStoreLod); }; } template<class T> struct has_member_shaderImageLoadStoreLod { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderImageLoadStoreLod<T>::value + 2*impl::is_static_member_shaderImageLoadStoreLod<T>::value + 4*is_const<typename impl::is_member_shaderImageLoadStoreLod<T>::type>::value); }; template<class T, class F> struct has_member_shaderImageLoadStoreLod_with_type : bool_constant<has_member_shaderImageLoadStoreLod<T>::value && is_same<typename impl::is_member_shaderImageLoadStoreLod<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_displayTiming: false_type { }; template<class T> struct is_static_member_displayTiming<T,typename enable_if<!is_same<__decltype(T::displayTiming),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_displayTiming: false_type { using type = void; }; template<class T> struct is_member_displayTiming<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().displayTiming),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().displayTiming); }; } template<class T> struct has_member_displayTiming { const static e_member_presence value = (e_member_presence)(impl::is_member_displayTiming<T>::value + 2*impl::is_static_member_displayTiming<T>::value + 4*is_const<typename impl::is_member_displayTiming<T>::type>::value); }; template<class T, class F> struct has_member_displayTiming_with_type : bool_constant<has_member_displayTiming<T>::value && is_same<typename impl::is_member_displayTiming<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDiscardRectangles: false_type { }; template<class T> struct is_static_member_maxDiscardRectangles<T,typename enable_if<!is_same<__decltype(T::maxDiscardRectangles),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDiscardRectangles: false_type { using type = void; }; template<class T> struct is_member_maxDiscardRectangles<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDiscardRectangles),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDiscardRectangles); }; } template<class T> struct has_member_maxDiscardRectangles { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDiscardRectangles<T>::value + 2*impl::is_static_member_maxDiscardRectangles<T>::value + 4*is_const<typename impl::is_member_maxDiscardRectangles<T>::type>::value); }; template<class T, class F> struct has_member_maxDiscardRectangles_with_type : bool_constant<has_member_maxDiscardRectangles<T>::value && is_same<typename impl::is_member_maxDiscardRectangles<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_primitiveOverestimationSizeBitPattern: false_type { }; template<class T> struct is_static_member_primitiveOverestimationSizeBitPattern<T,typename enable_if<!is_same<__decltype(T::primitiveOverestimationSizeBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_primitiveOverestimationSizeBitPattern: false_type { using type = void; }; template<class T> struct is_member_primitiveOverestimationSizeBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().primitiveOverestimationSizeBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().primitiveOverestimationSizeBitPattern); }; } template<class T> struct has_member_primitiveOverestimationSizeBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_primitiveOverestimationSizeBitPattern<T>::value + 2*impl::is_static_member_primitiveOverestimationSizeBitPattern<T>::value + 4*is_const<typename impl::is_member_primitiveOverestimationSizeBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_primitiveOverestimationSizeBitPattern_with_type : bool_constant<has_member_primitiveOverestimationSizeBitPattern<T>::value && is_same<typename impl::is_member_primitiveOverestimationSizeBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxExtraPrimitiveOverestimationSizeBitPattern: false_type { }; template<class T> struct is_static_member_maxExtraPrimitiveOverestimationSizeBitPattern<T,typename enable_if<!is_same<__decltype(T::maxExtraPrimitiveOverestimationSizeBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxExtraPrimitiveOverestimationSizeBitPattern: false_type { using type = void; }; template<class T> struct is_member_maxExtraPrimitiveOverestimationSizeBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxExtraPrimitiveOverestimationSizeBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxExtraPrimitiveOverestimationSizeBitPattern); }; } template<class T> struct has_member_maxExtraPrimitiveOverestimationSizeBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_maxExtraPrimitiveOverestimationSizeBitPattern<T>::value + 2*impl::is_static_member_maxExtraPrimitiveOverestimationSizeBitPattern<T>::value + 4*is_const<typename impl::is_member_maxExtraPrimitiveOverestimationSizeBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_maxExtraPrimitiveOverestimationSizeBitPattern_with_type : bool_constant<has_member_maxExtraPrimitiveOverestimationSizeBitPattern<T>::value && is_same<typename impl::is_member_maxExtraPrimitiveOverestimationSizeBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_extraPrimitiveOverestimationSizeGranularityBitPattern: false_type { }; template<class T> struct is_static_member_extraPrimitiveOverestimationSizeGranularityBitPattern<T,typename enable_if<!is_same<__decltype(T::extraPrimitiveOverestimationSizeGranularityBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_extraPrimitiveOverestimationSizeGranularityBitPattern: false_type { using type = void; }; template<class T> struct is_member_extraPrimitiveOverestimationSizeGranularityBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().extraPrimitiveOverestimationSizeGranularityBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().extraPrimitiveOverestimationSizeGranularityBitPattern); }; } template<class T> struct has_member_extraPrimitiveOverestimationSizeGranularityBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_extraPrimitiveOverestimationSizeGranularityBitPattern<T>::value + 2*impl::is_static_member_extraPrimitiveOverestimationSizeGranularityBitPattern<T>::value + 4*is_const<typename impl::is_member_extraPrimitiveOverestimationSizeGranularityBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_extraPrimitiveOverestimationSizeGranularityBitPattern_with_type : bool_constant<has_member_extraPrimitiveOverestimationSizeGranularityBitPattern<T>::value && is_same<typename impl::is_member_extraPrimitiveOverestimationSizeGranularityBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_primitiveUnderestimation: false_type { }; template<class T> struct is_static_member_primitiveUnderestimation<T,typename enable_if<!is_same<__decltype(T::primitiveUnderestimation),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_primitiveUnderestimation: false_type { using type = void; }; template<class T> struct is_member_primitiveUnderestimation<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().primitiveUnderestimation),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().primitiveUnderestimation); }; } template<class T> struct has_member_primitiveUnderestimation { const static e_member_presence value = (e_member_presence)(impl::is_member_primitiveUnderestimation<T>::value + 2*impl::is_static_member_primitiveUnderestimation<T>::value + 4*is_const<typename impl::is_member_primitiveUnderestimation<T>::type>::value); }; template<class T, class F> struct has_member_primitiveUnderestimation_with_type : bool_constant<has_member_primitiveUnderestimation<T>::value && is_same<typename impl::is_member_primitiveUnderestimation<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_conservativePointAndLineRasterization: false_type { }; template<class T> struct is_static_member_conservativePointAndLineRasterization<T,typename enable_if<!is_same<__decltype(T::conservativePointAndLineRasterization),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_conservativePointAndLineRasterization: false_type { using type = void; }; template<class T> struct is_member_conservativePointAndLineRasterization<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().conservativePointAndLineRasterization),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().conservativePointAndLineRasterization); }; } template<class T> struct has_member_conservativePointAndLineRasterization { const static e_member_presence value = (e_member_presence)(impl::is_member_conservativePointAndLineRasterization<T>::value + 2*impl::is_static_member_conservativePointAndLineRasterization<T>::value + 4*is_const<typename impl::is_member_conservativePointAndLineRasterization<T>::type>::value); }; template<class T, class F> struct has_member_conservativePointAndLineRasterization_with_type : bool_constant<has_member_conservativePointAndLineRasterization<T>::value && is_same<typename impl::is_member_conservativePointAndLineRasterization<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_degenerateTrianglesRasterized: false_type { }; template<class T> struct is_static_member_degenerateTrianglesRasterized<T,typename enable_if<!is_same<__decltype(T::degenerateTrianglesRasterized),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_degenerateTrianglesRasterized: false_type { using type = void; }; template<class T> struct is_member_degenerateTrianglesRasterized<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().degenerateTrianglesRasterized),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().degenerateTrianglesRasterized); }; } template<class T> struct has_member_degenerateTrianglesRasterized { const static e_member_presence value = (e_member_presence)(impl::is_member_degenerateTrianglesRasterized<T>::value + 2*impl::is_static_member_degenerateTrianglesRasterized<T>::value + 4*is_const<typename impl::is_member_degenerateTrianglesRasterized<T>::type>::value); }; template<class T, class F> struct has_member_degenerateTrianglesRasterized_with_type : bool_constant<has_member_degenerateTrianglesRasterized<T>::value && is_same<typename impl::is_member_degenerateTrianglesRasterized<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_degenerateLinesRasterized: false_type { }; template<class T> struct is_static_member_degenerateLinesRasterized<T,typename enable_if<!is_same<__decltype(T::degenerateLinesRasterized),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_degenerateLinesRasterized: false_type { using type = void; }; template<class T> struct is_member_degenerateLinesRasterized<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().degenerateLinesRasterized),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().degenerateLinesRasterized); }; } template<class T> struct has_member_degenerateLinesRasterized { const static e_member_presence value = (e_member_presence)(impl::is_member_degenerateLinesRasterized<T>::value + 2*impl::is_static_member_degenerateLinesRasterized<T>::value + 4*is_const<typename impl::is_member_degenerateLinesRasterized<T>::type>::value); }; template<class T, class F> struct has_member_degenerateLinesRasterized_with_type : bool_constant<has_member_degenerateLinesRasterized<T>::value && is_same<typename impl::is_member_degenerateLinesRasterized<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fullyCoveredFragmentShaderInputVariable: false_type { }; template<class T> struct is_static_member_fullyCoveredFragmentShaderInputVariable<T,typename enable_if<!is_same<__decltype(T::fullyCoveredFragmentShaderInputVariable),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fullyCoveredFragmentShaderInputVariable: false_type { using type = void; }; template<class T> struct is_member_fullyCoveredFragmentShaderInputVariable<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fullyCoveredFragmentShaderInputVariable),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fullyCoveredFragmentShaderInputVariable); }; } template<class T> struct has_member_fullyCoveredFragmentShaderInputVariable { const static e_member_presence value = (e_member_presence)(impl::is_member_fullyCoveredFragmentShaderInputVariable<T>::value + 2*impl::is_static_member_fullyCoveredFragmentShaderInputVariable<T>::value + 4*is_const<typename impl::is_member_fullyCoveredFragmentShaderInputVariable<T>::type>::value); }; template<class T, class F> struct has_member_fullyCoveredFragmentShaderInputVariable_with_type : bool_constant<has_member_fullyCoveredFragmentShaderInputVariable<T>::value && is_same<typename impl::is_member_fullyCoveredFragmentShaderInputVariable<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_conservativeRasterizationPostDepthCoverage: false_type { }; template<class T> struct is_static_member_conservativeRasterizationPostDepthCoverage<T,typename enable_if<!is_same<__decltype(T::conservativeRasterizationPostDepthCoverage),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_conservativeRasterizationPostDepthCoverage: false_type { using type = void; }; template<class T> struct is_member_conservativeRasterizationPostDepthCoverage<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().conservativeRasterizationPostDepthCoverage),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().conservativeRasterizationPostDepthCoverage); }; } template<class T> struct has_member_conservativeRasterizationPostDepthCoverage { const static e_member_presence value = (e_member_presence)(impl::is_member_conservativeRasterizationPostDepthCoverage<T>::value + 2*impl::is_static_member_conservativeRasterizationPostDepthCoverage<T>::value + 4*is_const<typename impl::is_member_conservativeRasterizationPostDepthCoverage<T>::type>::value); }; template<class T, class F> struct has_member_conservativeRasterizationPostDepthCoverage_with_type : bool_constant<has_member_conservativeRasterizationPostDepthCoverage<T>::value && is_same<typename impl::is_member_conservativeRasterizationPostDepthCoverage<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_queueFamilyForeign: false_type { }; template<class T> struct is_static_member_queueFamilyForeign<T,typename enable_if<!is_same<__decltype(T::queueFamilyForeign),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_queueFamilyForeign: false_type { using type = void; }; template<class T> struct is_member_queueFamilyForeign<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().queueFamilyForeign),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().queueFamilyForeign); }; } template<class T> struct has_member_queueFamilyForeign { const static e_member_presence value = (e_member_presence)(impl::is_member_queueFamilyForeign<T>::value + 2*impl::is_static_member_queueFamilyForeign<T>::value + 4*is_const<typename impl::is_member_queueFamilyForeign<T>::type>::value); }; template<class T, class F> struct has_member_queueFamilyForeign_with_type : bool_constant<has_member_queueFamilyForeign<T>::value && is_same<typename impl::is_member_queueFamilyForeign<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderStencilExport: false_type { }; template<class T> struct is_static_member_shaderStencilExport<T,typename enable_if<!is_same<__decltype(T::shaderStencilExport),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderStencilExport: false_type { using type = void; }; template<class T> struct is_member_shaderStencilExport<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderStencilExport),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderStencilExport); }; } template<class T> struct has_member_shaderStencilExport { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderStencilExport<T>::value + 2*impl::is_static_member_shaderStencilExport<T>::value + 4*is_const<typename impl::is_member_shaderStencilExport<T>::type>::value); }; template<class T, class F> struct has_member_shaderStencilExport_with_type : bool_constant<has_member_shaderStencilExport<T>::value && is_same<typename impl::is_member_shaderStencilExport<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_variableSampleLocations: false_type { }; template<class T> struct is_static_member_variableSampleLocations<T,typename enable_if<!is_same<__decltype(T::variableSampleLocations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_variableSampleLocations: false_type { using type = void; }; template<class T> struct is_member_variableSampleLocations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().variableSampleLocations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().variableSampleLocations); }; } template<class T> struct has_member_variableSampleLocations { const static e_member_presence value = (e_member_presence)(impl::is_member_variableSampleLocations<T>::value + 2*impl::is_static_member_variableSampleLocations<T>::value + 4*is_const<typename impl::is_member_variableSampleLocations<T>::type>::value); }; template<class T, class F> struct has_member_variableSampleLocations_with_type : bool_constant<has_member_variableSampleLocations<T>::value && is_same<typename impl::is_member_variableSampleLocations<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sampleLocationSubPixelBits: false_type { }; template<class T> struct is_static_member_sampleLocationSubPixelBits<T,typename enable_if<!is_same<__decltype(T::sampleLocationSubPixelBits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sampleLocationSubPixelBits: false_type { using type = void; }; template<class T> struct is_member_sampleLocationSubPixelBits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sampleLocationSubPixelBits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sampleLocationSubPixelBits); }; } template<class T> struct has_member_sampleLocationSubPixelBits { const static e_member_presence value = (e_member_presence)(impl::is_member_sampleLocationSubPixelBits<T>::value + 2*impl::is_static_member_sampleLocationSubPixelBits<T>::value + 4*is_const<typename impl::is_member_sampleLocationSubPixelBits<T>::type>::value); }; template<class T, class F> struct has_member_sampleLocationSubPixelBits_with_type : bool_constant<has_member_sampleLocationSubPixelBits<T>::value && is_same<typename impl::is_member_sampleLocationSubPixelBits<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sampleLocationSampleCountsBitPattern: false_type { }; template<class T> struct is_static_member_sampleLocationSampleCountsBitPattern<T,typename enable_if<!is_same<__decltype(T::sampleLocationSampleCountsBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sampleLocationSampleCountsBitPattern: false_type { using type = void; }; template<class T> struct is_member_sampleLocationSampleCountsBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sampleLocationSampleCountsBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sampleLocationSampleCountsBitPattern); }; } template<class T> struct has_member_sampleLocationSampleCountsBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_sampleLocationSampleCountsBitPattern<T>::value + 2*impl::is_static_member_sampleLocationSampleCountsBitPattern<T>::value + 4*is_const<typename impl::is_member_sampleLocationSampleCountsBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_sampleLocationSampleCountsBitPattern_with_type : bool_constant<has_member_sampleLocationSampleCountsBitPattern<T>::value && is_same<typename impl::is_member_sampleLocationSampleCountsBitPattern<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSampleLocationGridSizeX: false_type { }; template<class T> struct is_static_member_maxSampleLocationGridSizeX<T,typename enable_if<!is_same<__decltype(T::maxSampleLocationGridSizeX),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSampleLocationGridSizeX: false_type { using type = void; }; template<class T> struct is_member_maxSampleLocationGridSizeX<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSampleLocationGridSizeX),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSampleLocationGridSizeX); }; } template<class T> struct has_member_maxSampleLocationGridSizeX { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSampleLocationGridSizeX<T>::value + 2*impl::is_static_member_maxSampleLocationGridSizeX<T>::value + 4*is_const<typename impl::is_member_maxSampleLocationGridSizeX<T>::type>::value); }; template<class T, class F> struct has_member_maxSampleLocationGridSizeX_with_type : bool_constant<has_member_maxSampleLocationGridSizeX<T>::value && is_same<typename impl::is_member_maxSampleLocationGridSizeX<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSampleLocationGridSizeY: false_type { }; template<class T> struct is_static_member_maxSampleLocationGridSizeY<T,typename enable_if<!is_same<__decltype(T::maxSampleLocationGridSizeY),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSampleLocationGridSizeY: false_type { using type = void; }; template<class T> struct is_member_maxSampleLocationGridSizeY<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSampleLocationGridSizeY),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSampleLocationGridSizeY); }; } template<class T> struct has_member_maxSampleLocationGridSizeY { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSampleLocationGridSizeY<T>::value + 2*impl::is_static_member_maxSampleLocationGridSizeY<T>::value + 4*is_const<typename impl::is_member_maxSampleLocationGridSizeY<T>::type>::value); }; template<class T, class F> struct has_member_maxSampleLocationGridSizeY_with_type : bool_constant<has_member_maxSampleLocationGridSizeY<T>::value && is_same<typename impl::is_member_maxSampleLocationGridSizeY<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sampleLocationCoordinateRangeBitPatternMin: false_type { }; template<class T> struct is_static_member_sampleLocationCoordinateRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(T::sampleLocationCoordinateRangeBitPatternMin),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sampleLocationCoordinateRangeBitPatternMin: false_type { using type = void; }; template<class T> struct is_member_sampleLocationCoordinateRangeBitPatternMin<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sampleLocationCoordinateRangeBitPatternMin),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sampleLocationCoordinateRangeBitPatternMin); }; } template<class T> struct has_member_sampleLocationCoordinateRangeBitPatternMin { const static e_member_presence value = (e_member_presence)(impl::is_member_sampleLocationCoordinateRangeBitPatternMin<T>::value + 2*impl::is_static_member_sampleLocationCoordinateRangeBitPatternMin<T>::value + 4*is_const<typename impl::is_member_sampleLocationCoordinateRangeBitPatternMin<T>::type>::value); }; template<class T, class F> struct has_member_sampleLocationCoordinateRangeBitPatternMin_with_type : bool_constant<has_member_sampleLocationCoordinateRangeBitPatternMin<T>::value && is_same<typename impl::is_member_sampleLocationCoordinateRangeBitPatternMin<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sampleLocationCoordinateRangeBitPatternMax: false_type { }; template<class T> struct is_static_member_sampleLocationCoordinateRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(T::sampleLocationCoordinateRangeBitPatternMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sampleLocationCoordinateRangeBitPatternMax: false_type { using type = void; }; template<class T> struct is_member_sampleLocationCoordinateRangeBitPatternMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sampleLocationCoordinateRangeBitPatternMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sampleLocationCoordinateRangeBitPatternMax); }; } template<class T> struct has_member_sampleLocationCoordinateRangeBitPatternMax { const static e_member_presence value = (e_member_presence)(impl::is_member_sampleLocationCoordinateRangeBitPatternMax<T>::value + 2*impl::is_static_member_sampleLocationCoordinateRangeBitPatternMax<T>::value + 4*is_const<typename impl::is_member_sampleLocationCoordinateRangeBitPatternMax<T>::type>::value); }; template<class T, class F> struct has_member_sampleLocationCoordinateRangeBitPatternMax_with_type : bool_constant<has_member_sampleLocationCoordinateRangeBitPatternMax<T>::value && is_same<typename impl::is_member_sampleLocationCoordinateRangeBitPatternMax<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxAccelerationStructureGeometryCount: false_type { }; template<class T> struct is_static_member_maxAccelerationStructureGeometryCount<T,typename enable_if<!is_same<__decltype(T::maxAccelerationStructureGeometryCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxAccelerationStructureGeometryCount: false_type { using type = void; }; template<class T> struct is_member_maxAccelerationStructureGeometryCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxAccelerationStructureGeometryCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxAccelerationStructureGeometryCount); }; } template<class T> struct has_member_maxAccelerationStructureGeometryCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxAccelerationStructureGeometryCount<T>::value + 2*impl::is_static_member_maxAccelerationStructureGeometryCount<T>::value + 4*is_const<typename impl::is_member_maxAccelerationStructureGeometryCount<T>::type>::value); }; template<class T, class F> struct has_member_maxAccelerationStructureGeometryCount_with_type : bool_constant<has_member_maxAccelerationStructureGeometryCount<T>::value && is_same<typename impl::is_member_maxAccelerationStructureGeometryCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxAccelerationStructureInstanceCount: false_type { }; template<class T> struct is_static_member_maxAccelerationStructureInstanceCount<T,typename enable_if<!is_same<__decltype(T::maxAccelerationStructureInstanceCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxAccelerationStructureInstanceCount: false_type { using type = void; }; template<class T> struct is_member_maxAccelerationStructureInstanceCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxAccelerationStructureInstanceCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxAccelerationStructureInstanceCount); }; } template<class T> struct has_member_maxAccelerationStructureInstanceCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxAccelerationStructureInstanceCount<T>::value + 2*impl::is_static_member_maxAccelerationStructureInstanceCount<T>::value + 4*is_const<typename impl::is_member_maxAccelerationStructureInstanceCount<T>::type>::value); }; template<class T, class F> struct has_member_maxAccelerationStructureInstanceCount_with_type : bool_constant<has_member_maxAccelerationStructureInstanceCount<T>::value && is_same<typename impl::is_member_maxAccelerationStructureInstanceCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxAccelerationStructurePrimitiveCount: false_type { }; template<class T> struct is_static_member_maxAccelerationStructurePrimitiveCount<T,typename enable_if<!is_same<__decltype(T::maxAccelerationStructurePrimitiveCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxAccelerationStructurePrimitiveCount: false_type { using type = void; }; template<class T> struct is_member_maxAccelerationStructurePrimitiveCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxAccelerationStructurePrimitiveCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxAccelerationStructurePrimitiveCount); }; } template<class T> struct has_member_maxAccelerationStructurePrimitiveCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxAccelerationStructurePrimitiveCount<T>::value + 2*impl::is_static_member_maxAccelerationStructurePrimitiveCount<T>::value + 4*is_const<typename impl::is_member_maxAccelerationStructurePrimitiveCount<T>::type>::value); }; template<class T, class F> struct has_member_maxAccelerationStructurePrimitiveCount_with_type : bool_constant<has_member_maxAccelerationStructurePrimitiveCount<T>::value && is_same<typename impl::is_member_maxAccelerationStructurePrimitiveCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorAccelerationStructures: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorAccelerationStructures<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorAccelerationStructures),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorAccelerationStructures: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorAccelerationStructures<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorAccelerationStructures),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorAccelerationStructures); }; } template<class T> struct has_member_maxPerStageDescriptorAccelerationStructures { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorAccelerationStructures<T>::value + 2*impl::is_static_member_maxPerStageDescriptorAccelerationStructures<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorAccelerationStructures<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorAccelerationStructures_with_type : bool_constant<has_member_maxPerStageDescriptorAccelerationStructures<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorAccelerationStructures<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures: false_type { }; template<class T> struct is_static_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<T,typename enable_if<!is_same<__decltype(T::maxPerStageDescriptorUpdateAfterBindAccelerationStructures),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures: false_type { using type = void; }; template<class T> struct is_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindAccelerationStructures),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxPerStageDescriptorUpdateAfterBindAccelerationStructures); }; } template<class T> struct has_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures { const static e_member_presence value = (e_member_presence)(impl::is_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<T>::value + 2*impl::is_static_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<T>::value + 4*is_const<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<T>::type>::value); }; template<class T, class F> struct has_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures_with_type : bool_constant<has_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<T>::value && is_same<typename impl::is_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetAccelerationStructures: false_type { }; template<class T> struct is_static_member_maxDescriptorSetAccelerationStructures<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetAccelerationStructures),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetAccelerationStructures: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetAccelerationStructures<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetAccelerationStructures),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetAccelerationStructures); }; } template<class T> struct has_member_maxDescriptorSetAccelerationStructures { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetAccelerationStructures<T>::value + 2*impl::is_static_member_maxDescriptorSetAccelerationStructures<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetAccelerationStructures<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetAccelerationStructures_with_type : bool_constant<has_member_maxDescriptorSetAccelerationStructures<T>::value && is_same<typename impl::is_member_maxDescriptorSetAccelerationStructures<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetUpdateAfterBindAccelerationStructures: false_type { }; template<class T> struct is_static_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetUpdateAfterBindAccelerationStructures),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetUpdateAfterBindAccelerationStructures: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindAccelerationStructures),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetUpdateAfterBindAccelerationStructures); }; } template<class T> struct has_member_maxDescriptorSetUpdateAfterBindAccelerationStructures { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<T>::value + 2*impl::is_static_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetUpdateAfterBindAccelerationStructures_with_type : bool_constant<has_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<T>::value && is_same<typename impl::is_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minAccelerationStructureScratchOffsetAlignment: false_type { }; template<class T> struct is_static_member_minAccelerationStructureScratchOffsetAlignment<T,typename enable_if<!is_same<__decltype(T::minAccelerationStructureScratchOffsetAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minAccelerationStructureScratchOffsetAlignment: false_type { using type = void; }; template<class T> struct is_member_minAccelerationStructureScratchOffsetAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minAccelerationStructureScratchOffsetAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minAccelerationStructureScratchOffsetAlignment); }; } template<class T> struct has_member_minAccelerationStructureScratchOffsetAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_minAccelerationStructureScratchOffsetAlignment<T>::value + 2*impl::is_static_member_minAccelerationStructureScratchOffsetAlignment<T>::value + 4*is_const<typename impl::is_member_minAccelerationStructureScratchOffsetAlignment<T>::type>::value); }; template<class T, class F> struct has_member_minAccelerationStructureScratchOffsetAlignment_with_type : bool_constant<has_member_minAccelerationStructureScratchOffsetAlignment<T>::value && is_same<typename impl::is_member_minAccelerationStructureScratchOffsetAlignment<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxRayRecursionDepth: false_type { }; template<class T> struct is_static_member_maxRayRecursionDepth<T,typename enable_if<!is_same<__decltype(T::maxRayRecursionDepth),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxRayRecursionDepth: false_type { using type = void; }; template<class T> struct is_member_maxRayRecursionDepth<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxRayRecursionDepth),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxRayRecursionDepth); }; } template<class T> struct has_member_maxRayRecursionDepth { const static e_member_presence value = (e_member_presence)(impl::is_member_maxRayRecursionDepth<T>::value + 2*impl::is_static_member_maxRayRecursionDepth<T>::value + 4*is_const<typename impl::is_member_maxRayRecursionDepth<T>::type>::value); }; template<class T, class F> struct has_member_maxRayRecursionDepth_with_type : bool_constant<has_member_maxRayRecursionDepth<T>::value && is_same<typename impl::is_member_maxRayRecursionDepth<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxShaderGroupStride: false_type { }; template<class T> struct is_static_member_maxShaderGroupStride<T,typename enable_if<!is_same<__decltype(T::maxShaderGroupStride),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxShaderGroupStride: false_type { using type = void; }; template<class T> struct is_member_maxShaderGroupStride<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxShaderGroupStride),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxShaderGroupStride); }; } template<class T> struct has_member_maxShaderGroupStride { const static e_member_presence value = (e_member_presence)(impl::is_member_maxShaderGroupStride<T>::value + 2*impl::is_static_member_maxShaderGroupStride<T>::value + 4*is_const<typename impl::is_member_maxShaderGroupStride<T>::type>::value); }; template<class T, class F> struct has_member_maxShaderGroupStride_with_type : bool_constant<has_member_maxShaderGroupStride<T>::value && is_same<typename impl::is_member_maxShaderGroupStride<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderGroupBaseAlignment: false_type { }; template<class T> struct is_static_member_shaderGroupBaseAlignment<T,typename enable_if<!is_same<__decltype(T::shaderGroupBaseAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderGroupBaseAlignment: false_type { using type = void; }; template<class T> struct is_member_shaderGroupBaseAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderGroupBaseAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderGroupBaseAlignment); }; } template<class T> struct has_member_shaderGroupBaseAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderGroupBaseAlignment<T>::value + 2*impl::is_static_member_shaderGroupBaseAlignment<T>::value + 4*is_const<typename impl::is_member_shaderGroupBaseAlignment<T>::type>::value); }; template<class T, class F> struct has_member_shaderGroupBaseAlignment_with_type : bool_constant<has_member_shaderGroupBaseAlignment<T>::value && is_same<typename impl::is_member_shaderGroupBaseAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxRayDispatchInvocationCount: false_type { }; template<class T> struct is_static_member_maxRayDispatchInvocationCount<T,typename enable_if<!is_same<__decltype(T::maxRayDispatchInvocationCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxRayDispatchInvocationCount: false_type { using type = void; }; template<class T> struct is_member_maxRayDispatchInvocationCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxRayDispatchInvocationCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxRayDispatchInvocationCount); }; } template<class T> struct has_member_maxRayDispatchInvocationCount { const static e_member_presence value = (e_member_presence)(impl::is_member_maxRayDispatchInvocationCount<T>::value + 2*impl::is_static_member_maxRayDispatchInvocationCount<T>::value + 4*is_const<typename impl::is_member_maxRayDispatchInvocationCount<T>::type>::value); }; template<class T, class F> struct has_member_maxRayDispatchInvocationCount_with_type : bool_constant<has_member_maxRayDispatchInvocationCount<T>::value && is_same<typename impl::is_member_maxRayDispatchInvocationCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderGroupHandleAlignment: false_type { }; template<class T> struct is_static_member_shaderGroupHandleAlignment<T,typename enable_if<!is_same<__decltype(T::shaderGroupHandleAlignment),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderGroupHandleAlignment: false_type { using type = void; }; template<class T> struct is_member_shaderGroupHandleAlignment<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderGroupHandleAlignment),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderGroupHandleAlignment); }; } template<class T> struct has_member_shaderGroupHandleAlignment { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderGroupHandleAlignment<T>::value + 2*impl::is_static_member_shaderGroupHandleAlignment<T>::value + 4*is_const<typename impl::is_member_shaderGroupHandleAlignment<T>::type>::value); }; template<class T, class F> struct has_member_shaderGroupHandleAlignment_with_type : bool_constant<has_member_shaderGroupHandleAlignment<T>::value && is_same<typename impl::is_member_shaderGroupHandleAlignment<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxRayHitAttributeSize: false_type { }; template<class T> struct is_static_member_maxRayHitAttributeSize<T,typename enable_if<!is_same<__decltype(T::maxRayHitAttributeSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxRayHitAttributeSize: false_type { using type = void; }; template<class T> struct is_member_maxRayHitAttributeSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxRayHitAttributeSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxRayHitAttributeSize); }; } template<class T> struct has_member_maxRayHitAttributeSize { const static e_member_presence value = (e_member_presence)(impl::is_member_maxRayHitAttributeSize<T>::value + 2*impl::is_static_member_maxRayHitAttributeSize<T>::value + 4*is_const<typename impl::is_member_maxRayHitAttributeSize<T>::type>::value); }; template<class T, class F> struct has_member_maxRayHitAttributeSize_with_type : bool_constant<has_member_maxRayHitAttributeSize<T>::value && is_same<typename impl::is_member_maxRayHitAttributeSize<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSMBuiltins: false_type { }; template<class T> struct is_static_member_shaderSMBuiltins<T,typename enable_if<!is_same<__decltype(T::shaderSMBuiltins),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSMBuiltins: false_type { using type = void; }; template<class T> struct is_member_shaderSMBuiltins<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSMBuiltins),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSMBuiltins); }; } template<class T> struct has_member_shaderSMBuiltins { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSMBuiltins<T>::value + 2*impl::is_static_member_shaderSMBuiltins<T>::value + 4*is_const<typename impl::is_member_shaderSMBuiltins<T>::type>::value); }; template<class T, class F> struct has_member_shaderSMBuiltins_with_type : bool_constant<has_member_shaderSMBuiltins<T>::value && is_same<typename impl::is_member_shaderSMBuiltins<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_postDepthCoverage: false_type { }; template<class T> struct is_static_member_postDepthCoverage<T,typename enable_if<!is_same<__decltype(T::postDepthCoverage),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_postDepthCoverage: false_type { using type = void; }; template<class T> struct is_member_postDepthCoverage<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().postDepthCoverage),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().postDepthCoverage); }; } template<class T> struct has_member_postDepthCoverage { const static e_member_presence value = (e_member_presence)(impl::is_member_postDepthCoverage<T>::value + 2*impl::is_static_member_postDepthCoverage<T>::value + 4*is_const<typename impl::is_member_postDepthCoverage<T>::type>::value); }; template<class T, class F> struct has_member_postDepthCoverage_with_type : bool_constant<has_member_postDepthCoverage<T>::value && is_same<typename impl::is_member_postDepthCoverage<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_computeDerivativeGroupQuads: false_type { }; template<class T> struct is_static_member_computeDerivativeGroupQuads<T,typename enable_if<!is_same<__decltype(T::computeDerivativeGroupQuads),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_computeDerivativeGroupQuads: false_type { using type = void; }; template<class T> struct is_member_computeDerivativeGroupQuads<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().computeDerivativeGroupQuads),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().computeDerivativeGroupQuads); }; } template<class T> struct has_member_computeDerivativeGroupQuads { const static e_member_presence value = (e_member_presence)(impl::is_member_computeDerivativeGroupQuads<T>::value + 2*impl::is_static_member_computeDerivativeGroupQuads<T>::value + 4*is_const<typename impl::is_member_computeDerivativeGroupQuads<T>::type>::value); }; template<class T, class F> struct has_member_computeDerivativeGroupQuads_with_type : bool_constant<has_member_computeDerivativeGroupQuads<T>::value && is_same<typename impl::is_member_computeDerivativeGroupQuads<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_computeDerivativeGroupLinear: false_type { }; template<class T> struct is_static_member_computeDerivativeGroupLinear<T,typename enable_if<!is_same<__decltype(T::computeDerivativeGroupLinear),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_computeDerivativeGroupLinear: false_type { using type = void; }; template<class T> struct is_member_computeDerivativeGroupLinear<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().computeDerivativeGroupLinear),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().computeDerivativeGroupLinear); }; } template<class T> struct has_member_computeDerivativeGroupLinear { const static e_member_presence value = (e_member_presence)(impl::is_member_computeDerivativeGroupLinear<T>::value + 2*impl::is_static_member_computeDerivativeGroupLinear<T>::value + 4*is_const<typename impl::is_member_computeDerivativeGroupLinear<T>::type>::value); }; template<class T, class F> struct has_member_computeDerivativeGroupLinear_with_type : bool_constant<has_member_computeDerivativeGroupLinear<T>::value && is_same<typename impl::is_member_computeDerivativeGroupLinear<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pciDomain: false_type { }; template<class T> struct is_static_member_pciDomain<T,typename enable_if<!is_same<__decltype(T::pciDomain),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pciDomain: false_type { using type = void; }; template<class T> struct is_member_pciDomain<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pciDomain),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pciDomain); }; } template<class T> struct has_member_pciDomain { const static e_member_presence value = (e_member_presence)(impl::is_member_pciDomain<T>::value + 2*impl::is_static_member_pciDomain<T>::value + 4*is_const<typename impl::is_member_pciDomain<T>::type>::value); }; template<class T, class F> struct has_member_pciDomain_with_type : bool_constant<has_member_pciDomain<T>::value && is_same<typename impl::is_member_pciDomain<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pciBus: false_type { }; template<class T> struct is_static_member_pciBus<T,typename enable_if<!is_same<__decltype(T::pciBus),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pciBus: false_type { using type = void; }; template<class T> struct is_member_pciBus<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pciBus),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pciBus); }; } template<class T> struct has_member_pciBus { const static e_member_presence value = (e_member_presence)(impl::is_member_pciBus<T>::value + 2*impl::is_static_member_pciBus<T>::value + 4*is_const<typename impl::is_member_pciBus<T>::type>::value); }; template<class T, class F> struct has_member_pciBus_with_type : bool_constant<has_member_pciBus<T>::value && is_same<typename impl::is_member_pciBus<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pciDevice: false_type { }; template<class T> struct is_static_member_pciDevice<T,typename enable_if<!is_same<__decltype(T::pciDevice),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pciDevice: false_type { using type = void; }; template<class T> struct is_member_pciDevice<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pciDevice),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pciDevice); }; } template<class T> struct has_member_pciDevice { const static e_member_presence value = (e_member_presence)(impl::is_member_pciDevice<T>::value + 2*impl::is_static_member_pciDevice<T>::value + 4*is_const<typename impl::is_member_pciDevice<T>::type>::value); }; template<class T, class F> struct has_member_pciDevice_with_type : bool_constant<has_member_pciDevice<T>::value && is_same<typename impl::is_member_pciDevice<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pciFunction: false_type { }; template<class T> struct is_static_member_pciFunction<T,typename enable_if<!is_same<__decltype(T::pciFunction),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pciFunction: false_type { using type = void; }; template<class T> struct is_member_pciFunction<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pciFunction),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pciFunction); }; } template<class T> struct has_member_pciFunction { const static e_member_presence value = (e_member_presence)(impl::is_member_pciFunction<T>::value + 2*impl::is_static_member_pciFunction<T>::value + 4*is_const<typename impl::is_member_pciFunction<T>::type>::value); }; template<class T, class F> struct has_member_pciFunction_with_type : bool_constant<has_member_pciFunction<T>::value && is_same<typename impl::is_member_pciFunction<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minFragmentDensityTexelSizeX: false_type { }; template<class T> struct is_static_member_minFragmentDensityTexelSizeX<T,typename enable_if<!is_same<__decltype(T::minFragmentDensityTexelSizeX),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minFragmentDensityTexelSizeX: false_type { using type = void; }; template<class T> struct is_member_minFragmentDensityTexelSizeX<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minFragmentDensityTexelSizeX),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minFragmentDensityTexelSizeX); }; } template<class T> struct has_member_minFragmentDensityTexelSizeX { const static e_member_presence value = (e_member_presence)(impl::is_member_minFragmentDensityTexelSizeX<T>::value + 2*impl::is_static_member_minFragmentDensityTexelSizeX<T>::value + 4*is_const<typename impl::is_member_minFragmentDensityTexelSizeX<T>::type>::value); }; template<class T, class F> struct has_member_minFragmentDensityTexelSizeX_with_type : bool_constant<has_member_minFragmentDensityTexelSizeX<T>::value && is_same<typename impl::is_member_minFragmentDensityTexelSizeX<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_minFragmentDensityTexelSizeY: false_type { }; template<class T> struct is_static_member_minFragmentDensityTexelSizeY<T,typename enable_if<!is_same<__decltype(T::minFragmentDensityTexelSizeY),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_minFragmentDensityTexelSizeY: false_type { using type = void; }; template<class T> struct is_member_minFragmentDensityTexelSizeY<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().minFragmentDensityTexelSizeY),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().minFragmentDensityTexelSizeY); }; } template<class T> struct has_member_minFragmentDensityTexelSizeY { const static e_member_presence value = (e_member_presence)(impl::is_member_minFragmentDensityTexelSizeY<T>::value + 2*impl::is_static_member_minFragmentDensityTexelSizeY<T>::value + 4*is_const<typename impl::is_member_minFragmentDensityTexelSizeY<T>::type>::value); }; template<class T, class F> struct has_member_minFragmentDensityTexelSizeY_with_type : bool_constant<has_member_minFragmentDensityTexelSizeY<T>::value && is_same<typename impl::is_member_minFragmentDensityTexelSizeY<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFragmentDensityTexelSizeX: false_type { }; template<class T> struct is_static_member_maxFragmentDensityTexelSizeX<T,typename enable_if<!is_same<__decltype(T::maxFragmentDensityTexelSizeX),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFragmentDensityTexelSizeX: false_type { using type = void; }; template<class T> struct is_member_maxFragmentDensityTexelSizeX<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFragmentDensityTexelSizeX),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFragmentDensityTexelSizeX); }; } template<class T> struct has_member_maxFragmentDensityTexelSizeX { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFragmentDensityTexelSizeX<T>::value + 2*impl::is_static_member_maxFragmentDensityTexelSizeX<T>::value + 4*is_const<typename impl::is_member_maxFragmentDensityTexelSizeX<T>::type>::value); }; template<class T, class F> struct has_member_maxFragmentDensityTexelSizeX_with_type : bool_constant<has_member_maxFragmentDensityTexelSizeX<T>::value && is_same<typename impl::is_member_maxFragmentDensityTexelSizeX<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxFragmentDensityTexelSizeY: false_type { }; template<class T> struct is_static_member_maxFragmentDensityTexelSizeY<T,typename enable_if<!is_same<__decltype(T::maxFragmentDensityTexelSizeY),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxFragmentDensityTexelSizeY: false_type { using type = void; }; template<class T> struct is_member_maxFragmentDensityTexelSizeY<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxFragmentDensityTexelSizeY),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxFragmentDensityTexelSizeY); }; } template<class T> struct has_member_maxFragmentDensityTexelSizeY { const static e_member_presence value = (e_member_presence)(impl::is_member_maxFragmentDensityTexelSizeY<T>::value + 2*impl::is_static_member_maxFragmentDensityTexelSizeY<T>::value + 4*is_const<typename impl::is_member_maxFragmentDensityTexelSizeY<T>::type>::value); }; template<class T, class F> struct has_member_maxFragmentDensityTexelSizeY_with_type : bool_constant<has_member_maxFragmentDensityTexelSizeY<T>::value && is_same<typename impl::is_member_maxFragmentDensityTexelSizeY<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentDensityInvocations: false_type { }; template<class T> struct is_static_member_fragmentDensityInvocations<T,typename enable_if<!is_same<__decltype(T::fragmentDensityInvocations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentDensityInvocations: false_type { using type = void; }; template<class T> struct is_member_fragmentDensityInvocations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentDensityInvocations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentDensityInvocations); }; } template<class T> struct has_member_fragmentDensityInvocations { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentDensityInvocations<T>::value + 2*impl::is_static_member_fragmentDensityInvocations<T>::value + 4*is_const<typename impl::is_member_fragmentDensityInvocations<T>::type>::value); }; template<class T, class F> struct has_member_fragmentDensityInvocations_with_type : bool_constant<has_member_fragmentDensityInvocations<T>::value && is_same<typename impl::is_member_fragmentDensityInvocations<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_decorateString: false_type { }; template<class T> struct is_static_member_decorateString<T,typename enable_if<!is_same<__decltype(T::decorateString),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_decorateString: false_type { using type = void; }; template<class T> struct is_member_decorateString<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().decorateString),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().decorateString); }; } template<class T> struct has_member_decorateString { const static e_member_presence value = (e_member_presence)(impl::is_member_decorateString<T>::value + 2*impl::is_static_member_decorateString<T>::value + 4*is_const<typename impl::is_member_decorateString<T>::type>::value); }; template<class T, class F> struct has_member_decorateString_with_type : bool_constant<has_member_decorateString<T>::value && is_same<typename impl::is_member_decorateString<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderImageInt64Atomics: false_type { }; template<class T> struct is_static_member_shaderImageInt64Atomics<T,typename enable_if<!is_same<__decltype(T::shaderImageInt64Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderImageInt64Atomics: false_type { using type = void; }; template<class T> struct is_member_shaderImageInt64Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderImageInt64Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderImageInt64Atomics); }; } template<class T> struct has_member_shaderImageInt64Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderImageInt64Atomics<T>::value + 2*impl::is_static_member_shaderImageInt64Atomics<T>::value + 4*is_const<typename impl::is_member_shaderImageInt64Atomics<T>::type>::value); }; template<class T, class F> struct has_member_shaderImageInt64Atomics_with_type : bool_constant<has_member_shaderImageInt64Atomics<T>::value && is_same<typename impl::is_member_shaderImageInt64Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sparseImageInt64Atomics: false_type { }; template<class T> struct is_static_member_sparseImageInt64Atomics<T,typename enable_if<!is_same<__decltype(T::sparseImageInt64Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sparseImageInt64Atomics: false_type { using type = void; }; template<class T> struct is_member_sparseImageInt64Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sparseImageInt64Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sparseImageInt64Atomics); }; } template<class T> struct has_member_sparseImageInt64Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_sparseImageInt64Atomics<T>::value + 2*impl::is_static_member_sparseImageInt64Atomics<T>::value + 4*is_const<typename impl::is_member_sparseImageInt64Atomics<T>::type>::value); }; template<class T, class F> struct has_member_sparseImageInt64Atomics_with_type : bool_constant<has_member_sparseImageInt64Atomics<T>::value && is_same<typename impl::is_member_sparseImageInt64Atomics<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_lineSubPixelPrecisionBits: false_type { }; template<class T> struct is_static_member_lineSubPixelPrecisionBits<T,typename enable_if<!is_same<__decltype(T::lineSubPixelPrecisionBits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_lineSubPixelPrecisionBits: false_type { using type = void; }; template<class T> struct is_member_lineSubPixelPrecisionBits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().lineSubPixelPrecisionBits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().lineSubPixelPrecisionBits); }; } template<class T> struct has_member_lineSubPixelPrecisionBits { const static e_member_presence value = (e_member_presence)(impl::is_member_lineSubPixelPrecisionBits<T>::value + 2*impl::is_static_member_lineSubPixelPrecisionBits<T>::value + 4*is_const<typename impl::is_member_lineSubPixelPrecisionBits<T>::type>::value); }; template<class T, class F> struct has_member_lineSubPixelPrecisionBits_with_type : bool_constant<has_member_lineSubPixelPrecisionBits<T>::value && is_same<typename impl::is_member_lineSubPixelPrecisionBits<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat16Atomics: false_type { }; template<class T> struct is_static_member_shaderBufferFloat16Atomics<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat16Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat16Atomics: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat16Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat16Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat16Atomics); }; } template<class T> struct has_member_shaderBufferFloat16Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat16Atomics<T>::value + 2*impl::is_static_member_shaderBufferFloat16Atomics<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat16Atomics<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat16Atomics_with_type : bool_constant<has_member_shaderBufferFloat16Atomics<T>::value && is_same<typename impl::is_member_shaderBufferFloat16Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat16AtomicAdd: false_type { }; template<class T> struct is_static_member_shaderBufferFloat16AtomicAdd<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat16AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat16AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat16AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat16AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat16AtomicAdd); }; } template<class T> struct has_member_shaderBufferFloat16AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat16AtomicAdd<T>::value + 2*impl::is_static_member_shaderBufferFloat16AtomicAdd<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat16AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat16AtomicAdd_with_type : bool_constant<has_member_shaderBufferFloat16AtomicAdd<T>::value && is_same<typename impl::is_member_shaderBufferFloat16AtomicAdd<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat16AtomicMinMax: false_type { }; template<class T> struct is_static_member_shaderBufferFloat16AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat16AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat16AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat16AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat16AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat16AtomicMinMax); }; } template<class T> struct has_member_shaderBufferFloat16AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat16AtomicMinMax<T>::value + 2*impl::is_static_member_shaderBufferFloat16AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat16AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat16AtomicMinMax_with_type : bool_constant<has_member_shaderBufferFloat16AtomicMinMax<T>::value && is_same<typename impl::is_member_shaderBufferFloat16AtomicMinMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat32AtomicMinMax: false_type { }; template<class T> struct is_static_member_shaderBufferFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat32AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat32AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat32AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat32AtomicMinMax); }; } template<class T> struct has_member_shaderBufferFloat32AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat32AtomicMinMax<T>::value + 2*impl::is_static_member_shaderBufferFloat32AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat32AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat32AtomicMinMax_with_type : bool_constant<has_member_shaderBufferFloat32AtomicMinMax<T>::value && is_same<typename impl::is_member_shaderBufferFloat32AtomicMinMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferFloat64AtomicMinMax: false_type { }; template<class T> struct is_static_member_shaderBufferFloat64AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::shaderBufferFloat64AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferFloat64AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_shaderBufferFloat64AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferFloat64AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferFloat64AtomicMinMax); }; } template<class T> struct has_member_shaderBufferFloat64AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferFloat64AtomicMinMax<T>::value + 2*impl::is_static_member_shaderBufferFloat64AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_shaderBufferFloat64AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferFloat64AtomicMinMax_with_type : bool_constant<has_member_shaderBufferFloat64AtomicMinMax<T>::value && is_same<typename impl::is_member_shaderBufferFloat64AtomicMinMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat16Atomics: false_type { }; template<class T> struct is_static_member_shaderSharedFloat16Atomics<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat16Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat16Atomics: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat16Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat16Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat16Atomics); }; } template<class T> struct has_member_shaderSharedFloat16Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat16Atomics<T>::value + 2*impl::is_static_member_shaderSharedFloat16Atomics<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat16Atomics<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat16Atomics_with_type : bool_constant<has_member_shaderSharedFloat16Atomics<T>::value && is_same<typename impl::is_member_shaderSharedFloat16Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat16AtomicAdd: false_type { }; template<class T> struct is_static_member_shaderSharedFloat16AtomicAdd<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat16AtomicAdd),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat16AtomicAdd: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat16AtomicAdd<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat16AtomicAdd),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat16AtomicAdd); }; } template<class T> struct has_member_shaderSharedFloat16AtomicAdd { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat16AtomicAdd<T>::value + 2*impl::is_static_member_shaderSharedFloat16AtomicAdd<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat16AtomicAdd<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat16AtomicAdd_with_type : bool_constant<has_member_shaderSharedFloat16AtomicAdd<T>::value && is_same<typename impl::is_member_shaderSharedFloat16AtomicAdd<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat16AtomicMinMax: false_type { }; template<class T> struct is_static_member_shaderSharedFloat16AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat16AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat16AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat16AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat16AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat16AtomicMinMax); }; } template<class T> struct has_member_shaderSharedFloat16AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat16AtomicMinMax<T>::value + 2*impl::is_static_member_shaderSharedFloat16AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat16AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat16AtomicMinMax_with_type : bool_constant<has_member_shaderSharedFloat16AtomicMinMax<T>::value && is_same<typename impl::is_member_shaderSharedFloat16AtomicMinMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat32AtomicMinMax: false_type { }; template<class T> struct is_static_member_shaderSharedFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat32AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat32AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat32AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat32AtomicMinMax); }; } template<class T> struct has_member_shaderSharedFloat32AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat32AtomicMinMax<T>::value + 2*impl::is_static_member_shaderSharedFloat32AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat32AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat32AtomicMinMax_with_type : bool_constant<has_member_shaderSharedFloat32AtomicMinMax<T>::value && is_same<typename impl::is_member_shaderSharedFloat32AtomicMinMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedFloat64AtomicMinMax: false_type { }; template<class T> struct is_static_member_shaderSharedFloat64AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::shaderSharedFloat64AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedFloat64AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_shaderSharedFloat64AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedFloat64AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedFloat64AtomicMinMax); }; } template<class T> struct has_member_shaderSharedFloat64AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedFloat64AtomicMinMax<T>::value + 2*impl::is_static_member_shaderSharedFloat64AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_shaderSharedFloat64AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedFloat64AtomicMinMax_with_type : bool_constant<has_member_shaderSharedFloat64AtomicMinMax<T>::value && is_same<typename impl::is_member_shaderSharedFloat64AtomicMinMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderImageFloat32AtomicMinMax: false_type { }; template<class T> struct is_static_member_shaderImageFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::shaderImageFloat32AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderImageFloat32AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_shaderImageFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderImageFloat32AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderImageFloat32AtomicMinMax); }; } template<class T> struct has_member_shaderImageFloat32AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderImageFloat32AtomicMinMax<T>::value + 2*impl::is_static_member_shaderImageFloat32AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_shaderImageFloat32AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_shaderImageFloat32AtomicMinMax_with_type : bool_constant<has_member_shaderImageFloat32AtomicMinMax<T>::value && is_same<typename impl::is_member_shaderImageFloat32AtomicMinMax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_sparseImageFloat32AtomicMinMax: false_type { }; template<class T> struct is_static_member_sparseImageFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(T::sparseImageFloat32AtomicMinMax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_sparseImageFloat32AtomicMinMax: false_type { using type = void; }; template<class T> struct is_member_sparseImageFloat32AtomicMinMax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().sparseImageFloat32AtomicMinMax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().sparseImageFloat32AtomicMinMax); }; } template<class T> struct has_member_sparseImageFloat32AtomicMinMax { const static e_member_presence value = (e_member_presence)(impl::is_member_sparseImageFloat32AtomicMinMax<T>::value + 2*impl::is_static_member_sparseImageFloat32AtomicMinMax<T>::value + 4*is_const<typename impl::is_member_sparseImageFloat32AtomicMinMax<T>::type>::value); }; template<class T, class F> struct has_member_sparseImageFloat32AtomicMinMax_with_type : bool_constant<has_member_sparseImageFloat32AtomicMinMax<T>::value && is_same<typename impl::is_member_sparseImageFloat32AtomicMinMax<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_deviceMemoryReport: false_type { }; template<class T> struct is_static_member_deviceMemoryReport<T,typename enable_if<!is_same<__decltype(T::deviceMemoryReport),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_deviceMemoryReport: false_type { using type = void; }; template<class T> struct is_member_deviceMemoryReport<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().deviceMemoryReport),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().deviceMemoryReport); }; } template<class T> struct has_member_deviceMemoryReport { const static e_member_presence value = (e_member_presence)(impl::is_member_deviceMemoryReport<T>::value + 2*impl::is_static_member_deviceMemoryReport<T>::value + 4*is_const<typename impl::is_member_deviceMemoryReport<T>::type>::value); }; template<class T, class F> struct has_member_deviceMemoryReport_with_type : bool_constant<has_member_deviceMemoryReport<T>::value && is_same<typename impl::is_member_deviceMemoryReport<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderNonSemanticInfo: false_type { }; template<class T> struct is_static_member_shaderNonSemanticInfo<T,typename enable_if<!is_same<__decltype(T::shaderNonSemanticInfo),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderNonSemanticInfo: false_type { using type = void; }; template<class T> struct is_member_shaderNonSemanticInfo<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderNonSemanticInfo),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderNonSemanticInfo); }; } template<class T> struct has_member_shaderNonSemanticInfo { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderNonSemanticInfo<T>::value + 2*impl::is_static_member_shaderNonSemanticInfo<T>::value + 4*is_const<typename impl::is_member_shaderNonSemanticInfo<T>::type>::value); }; template<class T, class F> struct has_member_shaderNonSemanticInfo_with_type : bool_constant<has_member_shaderNonSemanticInfo<T>::value && is_same<typename impl::is_member_shaderNonSemanticInfo<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentShaderBarycentric: false_type { }; template<class T> struct is_static_member_fragmentShaderBarycentric<T,typename enable_if<!is_same<__decltype(T::fragmentShaderBarycentric),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentShaderBarycentric: false_type { using type = void; }; template<class T> struct is_member_fragmentShaderBarycentric<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentShaderBarycentric),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentShaderBarycentric); }; } template<class T> struct has_member_fragmentShaderBarycentric { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentShaderBarycentric<T>::value + 2*impl::is_static_member_fragmentShaderBarycentric<T>::value + 4*is_const<typename impl::is_member_fragmentShaderBarycentric<T>::type>::value); }; template<class T, class F> struct has_member_fragmentShaderBarycentric_with_type : bool_constant<has_member_fragmentShaderBarycentric<T>::value && is_same<typename impl::is_member_fragmentShaderBarycentric<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSubgroupUniformControlFlow: false_type { }; template<class T> struct is_static_member_shaderSubgroupUniformControlFlow<T,typename enable_if<!is_same<__decltype(T::shaderSubgroupUniformControlFlow),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSubgroupUniformControlFlow: false_type { using type = void; }; template<class T> struct is_member_shaderSubgroupUniformControlFlow<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSubgroupUniformControlFlow),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSubgroupUniformControlFlow); }; } template<class T> struct has_member_shaderSubgroupUniformControlFlow { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSubgroupUniformControlFlow<T>::value + 2*impl::is_static_member_shaderSubgroupUniformControlFlow<T>::value + 4*is_const<typename impl::is_member_shaderSubgroupUniformControlFlow<T>::type>::value); }; template<class T, class F> struct has_member_shaderSubgroupUniformControlFlow_with_type : bool_constant<has_member_shaderSubgroupUniformControlFlow<T>::value && is_same<typename impl::is_member_shaderSubgroupUniformControlFlow<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_subsampledLoads: false_type { }; template<class T> struct is_static_member_subsampledLoads<T,typename enable_if<!is_same<__decltype(T::subsampledLoads),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_subsampledLoads: false_type { using type = void; }; template<class T> struct is_member_subsampledLoads<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().subsampledLoads),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().subsampledLoads); }; } template<class T> struct has_member_subsampledLoads { const static e_member_presence value = (e_member_presence)(impl::is_member_subsampledLoads<T>::value + 2*impl::is_static_member_subsampledLoads<T>::value + 4*is_const<typename impl::is_member_subsampledLoads<T>::type>::value); }; template<class T, class F> struct has_member_subsampledLoads_with_type : bool_constant<has_member_subsampledLoads<T>::value && is_same<typename impl::is_member_subsampledLoads<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_subsampledCoarseReconstructionEarlyAccess: false_type { }; template<class T> struct is_static_member_subsampledCoarseReconstructionEarlyAccess<T,typename enable_if<!is_same<__decltype(T::subsampledCoarseReconstructionEarlyAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_subsampledCoarseReconstructionEarlyAccess: false_type { using type = void; }; template<class T> struct is_member_subsampledCoarseReconstructionEarlyAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().subsampledCoarseReconstructionEarlyAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().subsampledCoarseReconstructionEarlyAccess); }; } template<class T> struct has_member_subsampledCoarseReconstructionEarlyAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_subsampledCoarseReconstructionEarlyAccess<T>::value + 2*impl::is_static_member_subsampledCoarseReconstructionEarlyAccess<T>::value + 4*is_const<typename impl::is_member_subsampledCoarseReconstructionEarlyAccess<T>::type>::value); }; template<class T, class F> struct has_member_subsampledCoarseReconstructionEarlyAccess_with_type : bool_constant<has_member_subsampledCoarseReconstructionEarlyAccess<T>::value && is_same<typename impl::is_member_subsampledCoarseReconstructionEarlyAccess<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxSubsampledArrayLayers: false_type { }; template<class T> struct is_static_member_maxSubsampledArrayLayers<T,typename enable_if<!is_same<__decltype(T::maxSubsampledArrayLayers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxSubsampledArrayLayers: false_type { using type = void; }; template<class T> struct is_member_maxSubsampledArrayLayers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxSubsampledArrayLayers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxSubsampledArrayLayers); }; } template<class T> struct has_member_maxSubsampledArrayLayers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxSubsampledArrayLayers<T>::value + 2*impl::is_static_member_maxSubsampledArrayLayers<T>::value + 4*is_const<typename impl::is_member_maxSubsampledArrayLayers<T>::type>::value); }; template<class T, class F> struct has_member_maxSubsampledArrayLayers_with_type : bool_constant<has_member_maxSubsampledArrayLayers<T>::value && is_same<typename impl::is_member_maxSubsampledArrayLayers<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxDescriptorSetSubsampledSamplers: false_type { }; template<class T> struct is_static_member_maxDescriptorSetSubsampledSamplers<T,typename enable_if<!is_same<__decltype(T::maxDescriptorSetSubsampledSamplers),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxDescriptorSetSubsampledSamplers: false_type { using type = void; }; template<class T> struct is_member_maxDescriptorSetSubsampledSamplers<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxDescriptorSetSubsampledSamplers),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxDescriptorSetSubsampledSamplers); }; } template<class T> struct has_member_maxDescriptorSetSubsampledSamplers { const static e_member_presence value = (e_member_presence)(impl::is_member_maxDescriptorSetSubsampledSamplers<T>::value + 2*impl::is_static_member_maxDescriptorSetSubsampledSamplers<T>::value + 4*is_const<typename impl::is_member_maxDescriptorSetSubsampledSamplers<T>::type>::value); }; template<class T, class F> struct has_member_maxDescriptorSetSubsampledSamplers_with_type : bool_constant<has_member_maxDescriptorSetSubsampledSamplers<T>::value && is_same<typename impl::is_member_maxDescriptorSetSubsampledSamplers<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_workgroupMemoryExplicitLayout: false_type { }; template<class T> struct is_static_member_workgroupMemoryExplicitLayout<T,typename enable_if<!is_same<__decltype(T::workgroupMemoryExplicitLayout),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_workgroupMemoryExplicitLayout: false_type { using type = void; }; template<class T> struct is_member_workgroupMemoryExplicitLayout<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().workgroupMemoryExplicitLayout),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().workgroupMemoryExplicitLayout); }; } template<class T> struct has_member_workgroupMemoryExplicitLayout { const static e_member_presence value = (e_member_presence)(impl::is_member_workgroupMemoryExplicitLayout<T>::value + 2*impl::is_static_member_workgroupMemoryExplicitLayout<T>::value + 4*is_const<typename impl::is_member_workgroupMemoryExplicitLayout<T>::type>::value); }; template<class T, class F> struct has_member_workgroupMemoryExplicitLayout_with_type : bool_constant<has_member_workgroupMemoryExplicitLayout<T>::value && is_same<typename impl::is_member_workgroupMemoryExplicitLayout<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_workgroupMemoryExplicitLayoutScalarBlockLayout: false_type { }; template<class T> struct is_static_member_workgroupMemoryExplicitLayoutScalarBlockLayout<T,typename enable_if<!is_same<__decltype(T::workgroupMemoryExplicitLayoutScalarBlockLayout),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_workgroupMemoryExplicitLayoutScalarBlockLayout: false_type { using type = void; }; template<class T> struct is_member_workgroupMemoryExplicitLayoutScalarBlockLayout<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().workgroupMemoryExplicitLayoutScalarBlockLayout),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().workgroupMemoryExplicitLayoutScalarBlockLayout); }; } template<class T> struct has_member_workgroupMemoryExplicitLayoutScalarBlockLayout { const static e_member_presence value = (e_member_presence)(impl::is_member_workgroupMemoryExplicitLayoutScalarBlockLayout<T>::value + 2*impl::is_static_member_workgroupMemoryExplicitLayoutScalarBlockLayout<T>::value + 4*is_const<typename impl::is_member_workgroupMemoryExplicitLayoutScalarBlockLayout<T>::type>::value); }; template<class T, class F> struct has_member_workgroupMemoryExplicitLayoutScalarBlockLayout_with_type : bool_constant<has_member_workgroupMemoryExplicitLayoutScalarBlockLayout<T>::value && is_same<typename impl::is_member_workgroupMemoryExplicitLayoutScalarBlockLayout<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_workgroupMemoryExplicitLayout8BitAccess: false_type { }; template<class T> struct is_static_member_workgroupMemoryExplicitLayout8BitAccess<T,typename enable_if<!is_same<__decltype(T::workgroupMemoryExplicitLayout8BitAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_workgroupMemoryExplicitLayout8BitAccess: false_type { using type = void; }; template<class T> struct is_member_workgroupMemoryExplicitLayout8BitAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().workgroupMemoryExplicitLayout8BitAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().workgroupMemoryExplicitLayout8BitAccess); }; } template<class T> struct has_member_workgroupMemoryExplicitLayout8BitAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_workgroupMemoryExplicitLayout8BitAccess<T>::value + 2*impl::is_static_member_workgroupMemoryExplicitLayout8BitAccess<T>::value + 4*is_const<typename impl::is_member_workgroupMemoryExplicitLayout8BitAccess<T>::type>::value); }; template<class T, class F> struct has_member_workgroupMemoryExplicitLayout8BitAccess_with_type : bool_constant<has_member_workgroupMemoryExplicitLayout8BitAccess<T>::value && is_same<typename impl::is_member_workgroupMemoryExplicitLayout8BitAccess<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_workgroupMemoryExplicitLayout16BitAccess: false_type { }; template<class T> struct is_static_member_workgroupMemoryExplicitLayout16BitAccess<T,typename enable_if<!is_same<__decltype(T::workgroupMemoryExplicitLayout16BitAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_workgroupMemoryExplicitLayout16BitAccess: false_type { using type = void; }; template<class T> struct is_member_workgroupMemoryExplicitLayout16BitAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().workgroupMemoryExplicitLayout16BitAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().workgroupMemoryExplicitLayout16BitAccess); }; } template<class T> struct has_member_workgroupMemoryExplicitLayout16BitAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_workgroupMemoryExplicitLayout16BitAccess<T>::value + 2*impl::is_static_member_workgroupMemoryExplicitLayout16BitAccess<T>::value + 4*is_const<typename impl::is_member_workgroupMemoryExplicitLayout16BitAccess<T>::type>::value); }; template<class T, class F> struct has_member_workgroupMemoryExplicitLayout16BitAccess_with_type : bool_constant<has_member_workgroupMemoryExplicitLayout16BitAccess<T>::value && is_same<typename impl::is_member_workgroupMemoryExplicitLayout16BitAccess<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_colorWriteEnable: false_type { }; template<class T> struct is_static_member_colorWriteEnable<T,typename enable_if<!is_same<__decltype(T::colorWriteEnable),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_colorWriteEnable: false_type { using type = void; }; template<class T> struct is_member_colorWriteEnable<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().colorWriteEnable),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().colorWriteEnable); }; } template<class T> struct has_member_colorWriteEnable { const static e_member_presence value = (e_member_presence)(impl::is_member_colorWriteEnable<T>::value + 2*impl::is_static_member_colorWriteEnable<T>::value + 4*is_const<typename impl::is_member_colorWriteEnable<T>::type>::value); }; template<class T, class F> struct has_member_colorWriteEnable_with_type : bool_constant<has_member_colorWriteEnable<T>::value && is_same<typename impl::is_member_colorWriteEnable<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_cooperativeMatrixSupportedStagesBitPattern: false_type { }; template<class T> struct is_static_member_cooperativeMatrixSupportedStagesBitPattern<T,typename enable_if<!is_same<__decltype(T::cooperativeMatrixSupportedStagesBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_cooperativeMatrixSupportedStagesBitPattern: false_type { using type = void; }; template<class T> struct is_member_cooperativeMatrixSupportedStagesBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().cooperativeMatrixSupportedStagesBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().cooperativeMatrixSupportedStagesBitPattern); }; } template<class T> struct has_member_cooperativeMatrixSupportedStagesBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_cooperativeMatrixSupportedStagesBitPattern<T>::value + 2*impl::is_static_member_cooperativeMatrixSupportedStagesBitPattern<T>::value + 4*is_const<typename impl::is_member_cooperativeMatrixSupportedStagesBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_cooperativeMatrixSupportedStagesBitPattern_with_type : bool_constant<has_member_cooperativeMatrixSupportedStagesBitPattern<T>::value && is_same<typename impl::is_member_cooperativeMatrixSupportedStagesBitPattern<T>::type, F>::value> {}; } };

// Nabla
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_computeUnits: false_type { }; template<class T> struct is_static_member_computeUnits<T,typename enable_if<!is_same<__decltype(T::computeUnits),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_computeUnits: false_type { using type = void; }; template<class T> struct is_member_computeUnits<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().computeUnits),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().computeUnits); }; } template<class T> struct has_member_computeUnits { const static e_member_presence value = (e_member_presence)(impl::is_member_computeUnits<T>::value + 2*impl::is_static_member_computeUnits<T>::value + 4*is_const<typename impl::is_member_computeUnits<T>::type>::value); }; template<class T, class F> struct has_member_computeUnits_with_type : bool_constant<has_member_computeUnits<T>::value && is_same<typename impl::is_member_computeUnits<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_dispatchBase: false_type { }; template<class T> struct is_static_member_dispatchBase<T,typename enable_if<!is_same<__decltype(T::dispatchBase),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_dispatchBase: false_type { using type = void; }; template<class T> struct is_member_dispatchBase<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().dispatchBase),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().dispatchBase); }; } template<class T> struct has_member_dispatchBase { const static e_member_presence value = (e_member_presence)(impl::is_member_dispatchBase<T>::value + 2*impl::is_static_member_dispatchBase<T>::value + 4*is_const<typename impl::is_member_dispatchBase<T>::type>::value); }; template<class T, class F> struct has_member_dispatchBase_with_type : bool_constant<has_member_dispatchBase<T>::value && is_same<typename impl::is_member_dispatchBase<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_allowCommandBufferQueryCopies: false_type { }; template<class T> struct is_static_member_allowCommandBufferQueryCopies<T,typename enable_if<!is_same<__decltype(T::allowCommandBufferQueryCopies),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_allowCommandBufferQueryCopies: false_type { using type = void; }; template<class T> struct is_member_allowCommandBufferQueryCopies<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().allowCommandBufferQueryCopies),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().allowCommandBufferQueryCopies); }; } template<class T> struct has_member_allowCommandBufferQueryCopies { const static e_member_presence value = (e_member_presence)(impl::is_member_allowCommandBufferQueryCopies<T>::value + 2*impl::is_static_member_allowCommandBufferQueryCopies<T>::value + 4*is_const<typename impl::is_member_allowCommandBufferQueryCopies<T>::type>::value); }; template<class T, class F> struct has_member_allowCommandBufferQueryCopies_with_type : bool_constant<has_member_allowCommandBufferQueryCopies<T>::value && is_same<typename impl::is_member_allowCommandBufferQueryCopies<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxOptimallyResidentWorkgroupInvocations: false_type { }; template<class T> struct is_static_member_maxOptimallyResidentWorkgroupInvocations<T,typename enable_if<!is_same<__decltype(T::maxOptimallyResidentWorkgroupInvocations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxOptimallyResidentWorkgroupInvocations: false_type { using type = void; }; template<class T> struct is_member_maxOptimallyResidentWorkgroupInvocations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxOptimallyResidentWorkgroupInvocations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxOptimallyResidentWorkgroupInvocations); }; } template<class T> struct has_member_maxOptimallyResidentWorkgroupInvocations { const static e_member_presence value = (e_member_presence)(impl::is_member_maxOptimallyResidentWorkgroupInvocations<T>::value + 2*impl::is_static_member_maxOptimallyResidentWorkgroupInvocations<T>::value + 4*is_const<typename impl::is_member_maxOptimallyResidentWorkgroupInvocations<T>::type>::value); }; template<class T, class F> struct has_member_maxOptimallyResidentWorkgroupInvocations_with_type : bool_constant<has_member_maxOptimallyResidentWorkgroupInvocations<T>::value && is_same<typename impl::is_member_maxOptimallyResidentWorkgroupInvocations<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_maxResidentInvocations: false_type { }; template<class T> struct is_static_member_maxResidentInvocations<T,typename enable_if<!is_same<__decltype(T::maxResidentInvocations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_maxResidentInvocations: false_type { using type = void; }; template<class T> struct is_member_maxResidentInvocations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().maxResidentInvocations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().maxResidentInvocations); }; } template<class T> struct has_member_maxResidentInvocations { const static e_member_presence value = (e_member_presence)(impl::is_member_maxResidentInvocations<T>::value + 2*impl::is_static_member_maxResidentInvocations<T>::value + 4*is_const<typename impl::is_member_maxResidentInvocations<T>::type>::value); }; template<class T, class F> struct has_member_maxResidentInvocations_with_type : bool_constant<has_member_maxResidentInvocations<T>::value && is_same<typename impl::is_member_maxResidentInvocations<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_spirvVersionBitPattern: false_type { }; template<class T> struct is_static_member_spirvVersionBitPattern<T,typename enable_if<!is_same<__decltype(T::spirvVersionBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_spirvVersionBitPattern: false_type { using type = void; }; template<class T> struct is_member_spirvVersionBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().spirvVersionBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().spirvVersionBitPattern); }; } template<class T> struct has_member_spirvVersionBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_spirvVersionBitPattern<T>::value + 2*impl::is_static_member_spirvVersionBitPattern<T>::value + 4*is_const<typename impl::is_member_spirvVersionBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_spirvVersionBitPattern_with_type : bool_constant<has_member_spirvVersionBitPattern<T>::value && is_same<typename impl::is_member_spirvVersionBitPattern<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_logicOp: false_type { }; template<class T> struct is_static_member_logicOp<T,typename enable_if<!is_same<__decltype(T::logicOp),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_logicOp: false_type { using type = void; }; template<class T> struct is_member_logicOp<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().logicOp),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().logicOp); }; } template<class T> struct has_member_logicOp { const static e_member_presence value = (e_member_presence)(impl::is_member_logicOp<T>::value + 2*impl::is_static_member_logicOp<T>::value + 4*is_const<typename impl::is_member_logicOp<T>::type>::value); }; template<class T, class F> struct has_member_logicOp_with_type : bool_constant<has_member_logicOp<T>::value && is_same<typename impl::is_member_logicOp<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_vertexPipelineStoresAndAtomics: false_type { }; template<class T> struct is_static_member_vertexPipelineStoresAndAtomics<T,typename enable_if<!is_same<__decltype(T::vertexPipelineStoresAndAtomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_vertexPipelineStoresAndAtomics: false_type { using type = void; }; template<class T> struct is_member_vertexPipelineStoresAndAtomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().vertexPipelineStoresAndAtomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().vertexPipelineStoresAndAtomics); }; } template<class T> struct has_member_vertexPipelineStoresAndAtomics { const static e_member_presence value = (e_member_presence)(impl::is_member_vertexPipelineStoresAndAtomics<T>::value + 2*impl::is_static_member_vertexPipelineStoresAndAtomics<T>::value + 4*is_const<typename impl::is_member_vertexPipelineStoresAndAtomics<T>::type>::value); }; template<class T, class F> struct has_member_vertexPipelineStoresAndAtomics_with_type : bool_constant<has_member_vertexPipelineStoresAndAtomics<T>::value && is_same<typename impl::is_member_vertexPipelineStoresAndAtomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentStoresAndAtomics: false_type { }; template<class T> struct is_static_member_fragmentStoresAndAtomics<T,typename enable_if<!is_same<__decltype(T::fragmentStoresAndAtomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentStoresAndAtomics: false_type { using type = void; }; template<class T> struct is_member_fragmentStoresAndAtomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentStoresAndAtomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentStoresAndAtomics); }; } template<class T> struct has_member_fragmentStoresAndAtomics { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentStoresAndAtomics<T>::value + 2*impl::is_static_member_fragmentStoresAndAtomics<T>::value + 4*is_const<typename impl::is_member_fragmentStoresAndAtomics<T>::type>::value); }; template<class T, class F> struct has_member_fragmentStoresAndAtomics_with_type : bool_constant<has_member_fragmentStoresAndAtomics<T>::value && is_same<typename impl::is_member_fragmentStoresAndAtomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderTessellationAndGeometryPointSize: false_type { }; template<class T> struct is_static_member_shaderTessellationAndGeometryPointSize<T,typename enable_if<!is_same<__decltype(T::shaderTessellationAndGeometryPointSize),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderTessellationAndGeometryPointSize: false_type { using type = void; }; template<class T> struct is_member_shaderTessellationAndGeometryPointSize<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderTessellationAndGeometryPointSize),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderTessellationAndGeometryPointSize); }; } template<class T> struct has_member_shaderTessellationAndGeometryPointSize { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderTessellationAndGeometryPointSize<T>::value + 2*impl::is_static_member_shaderTessellationAndGeometryPointSize<T>::value + 4*is_const<typename impl::is_member_shaderTessellationAndGeometryPointSize<T>::type>::value); }; template<class T, class F> struct has_member_shaderTessellationAndGeometryPointSize_with_type : bool_constant<has_member_shaderTessellationAndGeometryPointSize<T>::value && is_same<typename impl::is_member_shaderTessellationAndGeometryPointSize<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderStorageImageMultisample: false_type { }; template<class T> struct is_static_member_shaderStorageImageMultisample<T,typename enable_if<!is_same<__decltype(T::shaderStorageImageMultisample),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderStorageImageMultisample: false_type { using type = void; }; template<class T> struct is_member_shaderStorageImageMultisample<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderStorageImageMultisample),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderStorageImageMultisample); }; } template<class T> struct has_member_shaderStorageImageMultisample { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderStorageImageMultisample<T>::value + 2*impl::is_static_member_shaderStorageImageMultisample<T>::value + 4*is_const<typename impl::is_member_shaderStorageImageMultisample<T>::type>::value); }; template<class T, class F> struct has_member_shaderStorageImageMultisample_with_type : bool_constant<has_member_shaderStorageImageMultisample<T>::value && is_same<typename impl::is_member_shaderStorageImageMultisample<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderStorageImageReadWithoutFormat: false_type { }; template<class T> struct is_static_member_shaderStorageImageReadWithoutFormat<T,typename enable_if<!is_same<__decltype(T::shaderStorageImageReadWithoutFormat),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderStorageImageReadWithoutFormat: false_type { using type = void; }; template<class T> struct is_member_shaderStorageImageReadWithoutFormat<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderStorageImageReadWithoutFormat),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderStorageImageReadWithoutFormat); }; } template<class T> struct has_member_shaderStorageImageReadWithoutFormat { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderStorageImageReadWithoutFormat<T>::value + 2*impl::is_static_member_shaderStorageImageReadWithoutFormat<T>::value + 4*is_const<typename impl::is_member_shaderStorageImageReadWithoutFormat<T>::type>::value); }; template<class T, class F> struct has_member_shaderStorageImageReadWithoutFormat_with_type : bool_constant<has_member_shaderStorageImageReadWithoutFormat<T>::value && is_same<typename impl::is_member_shaderStorageImageReadWithoutFormat<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderStorageImageArrayDynamicIndexing: false_type { }; template<class T> struct is_static_member_shaderStorageImageArrayDynamicIndexing<T,typename enable_if<!is_same<__decltype(T::shaderStorageImageArrayDynamicIndexing),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderStorageImageArrayDynamicIndexing: false_type { using type = void; }; template<class T> struct is_member_shaderStorageImageArrayDynamicIndexing<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderStorageImageArrayDynamicIndexing),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderStorageImageArrayDynamicIndexing); }; } template<class T> struct has_member_shaderStorageImageArrayDynamicIndexing { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderStorageImageArrayDynamicIndexing<T>::value + 2*impl::is_static_member_shaderStorageImageArrayDynamicIndexing<T>::value + 4*is_const<typename impl::is_member_shaderStorageImageArrayDynamicIndexing<T>::type>::value); }; template<class T, class F> struct has_member_shaderStorageImageArrayDynamicIndexing_with_type : bool_constant<has_member_shaderStorageImageArrayDynamicIndexing<T>::value && is_same<typename impl::is_member_shaderStorageImageArrayDynamicIndexing<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderFloat64: false_type { }; template<class T> struct is_static_member_shaderFloat64<T,typename enable_if<!is_same<__decltype(T::shaderFloat64),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderFloat64: false_type { using type = void; }; template<class T> struct is_member_shaderFloat64<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderFloat64),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderFloat64); }; } template<class T> struct has_member_shaderFloat64 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderFloat64<T>::value + 2*impl::is_static_member_shaderFloat64<T>::value + 4*is_const<typename impl::is_member_shaderFloat64<T>::type>::value); }; template<class T, class F> struct has_member_shaderFloat64_with_type : bool_constant<has_member_shaderFloat64<T>::value && is_same<typename impl::is_member_shaderFloat64<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_variableMultisampleRate: false_type { }; template<class T> struct is_static_member_variableMultisampleRate<T,typename enable_if<!is_same<__decltype(T::variableMultisampleRate),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_variableMultisampleRate: false_type { using type = void; }; template<class T> struct is_member_variableMultisampleRate<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().variableMultisampleRate),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().variableMultisampleRate); }; } template<class T> struct has_member_variableMultisampleRate { const static e_member_presence value = (e_member_presence)(impl::is_member_variableMultisampleRate<T>::value + 2*impl::is_static_member_variableMultisampleRate<T>::value + 4*is_const<typename impl::is_member_variableMultisampleRate<T>::type>::value); }; template<class T, class F> struct has_member_variableMultisampleRate_with_type : bool_constant<has_member_variableMultisampleRate<T>::value && is_same<typename impl::is_member_variableMultisampleRate<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_storagePushConstant16: false_type { }; template<class T> struct is_static_member_storagePushConstant16<T,typename enable_if<!is_same<__decltype(T::storagePushConstant16),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_storagePushConstant16: false_type { using type = void; }; template<class T> struct is_member_storagePushConstant16<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().storagePushConstant16),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().storagePushConstant16); }; } template<class T> struct has_member_storagePushConstant16 { const static e_member_presence value = (e_member_presence)(impl::is_member_storagePushConstant16<T>::value + 2*impl::is_static_member_storagePushConstant16<T>::value + 4*is_const<typename impl::is_member_storagePushConstant16<T>::type>::value); }; template<class T, class F> struct has_member_storagePushConstant16_with_type : bool_constant<has_member_storagePushConstant16<T>::value && is_same<typename impl::is_member_storagePushConstant16<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_storageInputOutput16: false_type { }; template<class T> struct is_static_member_storageInputOutput16<T,typename enable_if<!is_same<__decltype(T::storageInputOutput16),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_storageInputOutput16: false_type { using type = void; }; template<class T> struct is_member_storageInputOutput16<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().storageInputOutput16),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().storageInputOutput16); }; } template<class T> struct has_member_storageInputOutput16 { const static e_member_presence value = (e_member_presence)(impl::is_member_storageInputOutput16<T>::value + 2*impl::is_static_member_storageInputOutput16<T>::value + 4*is_const<typename impl::is_member_storageInputOutput16<T>::type>::value); }; template<class T, class F> struct has_member_storageInputOutput16_with_type : bool_constant<has_member_storageInputOutput16<T>::value && is_same<typename impl::is_member_storageInputOutput16<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_multiviewGeometryShader: false_type { }; template<class T> struct is_static_member_multiviewGeometryShader<T,typename enable_if<!is_same<__decltype(T::multiviewGeometryShader),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_multiviewGeometryShader: false_type { using type = void; }; template<class T> struct is_member_multiviewGeometryShader<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().multiviewGeometryShader),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().multiviewGeometryShader); }; } template<class T> struct has_member_multiviewGeometryShader { const static e_member_presence value = (e_member_presence)(impl::is_member_multiviewGeometryShader<T>::value + 2*impl::is_static_member_multiviewGeometryShader<T>::value + 4*is_const<typename impl::is_member_multiviewGeometryShader<T>::type>::value); }; template<class T, class F> struct has_member_multiviewGeometryShader_with_type : bool_constant<has_member_multiviewGeometryShader<T>::value && is_same<typename impl::is_member_multiviewGeometryShader<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_multiviewTessellationShader: false_type { }; template<class T> struct is_static_member_multiviewTessellationShader<T,typename enable_if<!is_same<__decltype(T::multiviewTessellationShader),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_multiviewTessellationShader: false_type { using type = void; }; template<class T> struct is_member_multiviewTessellationShader<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().multiviewTessellationShader),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().multiviewTessellationShader); }; } template<class T> struct has_member_multiviewTessellationShader { const static e_member_presence value = (e_member_presence)(impl::is_member_multiviewTessellationShader<T>::value + 2*impl::is_static_member_multiviewTessellationShader<T>::value + 4*is_const<typename impl::is_member_multiviewTessellationShader<T>::type>::value); }; template<class T, class F> struct has_member_multiviewTessellationShader_with_type : bool_constant<has_member_multiviewTessellationShader<T>::value && is_same<typename impl::is_member_multiviewTessellationShader<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_drawIndirectCount: false_type { }; template<class T> struct is_static_member_drawIndirectCount<T,typename enable_if<!is_same<__decltype(T::drawIndirectCount),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_drawIndirectCount: false_type { using type = void; }; template<class T> struct is_member_drawIndirectCount<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().drawIndirectCount),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().drawIndirectCount); }; } template<class T> struct has_member_drawIndirectCount { const static e_member_presence value = (e_member_presence)(impl::is_member_drawIndirectCount<T>::value + 2*impl::is_static_member_drawIndirectCount<T>::value + 4*is_const<typename impl::is_member_drawIndirectCount<T>::type>::value); }; template<class T, class F> struct has_member_drawIndirectCount_with_type : bool_constant<has_member_drawIndirectCount<T>::value && is_same<typename impl::is_member_drawIndirectCount<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_storagePushConstant8: false_type { }; template<class T> struct is_static_member_storagePushConstant8<T,typename enable_if<!is_same<__decltype(T::storagePushConstant8),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_storagePushConstant8: false_type { using type = void; }; template<class T> struct is_member_storagePushConstant8<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().storagePushConstant8),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().storagePushConstant8); }; } template<class T> struct has_member_storagePushConstant8 { const static e_member_presence value = (e_member_presence)(impl::is_member_storagePushConstant8<T>::value + 2*impl::is_static_member_storagePushConstant8<T>::value + 4*is_const<typename impl::is_member_storagePushConstant8<T>::type>::value); }; template<class T, class F> struct has_member_storagePushConstant8_with_type : bool_constant<has_member_storagePushConstant8<T>::value && is_same<typename impl::is_member_storagePushConstant8<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderBufferInt64Atomics: false_type { }; template<class T> struct is_static_member_shaderBufferInt64Atomics<T,typename enable_if<!is_same<__decltype(T::shaderBufferInt64Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderBufferInt64Atomics: false_type { using type = void; }; template<class T> struct is_member_shaderBufferInt64Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderBufferInt64Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderBufferInt64Atomics); }; } template<class T> struct has_member_shaderBufferInt64Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderBufferInt64Atomics<T>::value + 2*impl::is_static_member_shaderBufferInt64Atomics<T>::value + 4*is_const<typename impl::is_member_shaderBufferInt64Atomics<T>::type>::value); }; template<class T, class F> struct has_member_shaderBufferInt64Atomics_with_type : bool_constant<has_member_shaderBufferInt64Atomics<T>::value && is_same<typename impl::is_member_shaderBufferInt64Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSharedInt64Atomics: false_type { }; template<class T> struct is_static_member_shaderSharedInt64Atomics<T,typename enable_if<!is_same<__decltype(T::shaderSharedInt64Atomics),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSharedInt64Atomics: false_type { using type = void; }; template<class T> struct is_member_shaderSharedInt64Atomics<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSharedInt64Atomics),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSharedInt64Atomics); }; } template<class T> struct has_member_shaderSharedInt64Atomics { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSharedInt64Atomics<T>::value + 2*impl::is_static_member_shaderSharedInt64Atomics<T>::value + 4*is_const<typename impl::is_member_shaderSharedInt64Atomics<T>::type>::value); }; template<class T, class F> struct has_member_shaderSharedInt64Atomics_with_type : bool_constant<has_member_shaderSharedInt64Atomics<T>::value && is_same<typename impl::is_member_shaderSharedInt64Atomics<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderFloat16: false_type { }; template<class T> struct is_static_member_shaderFloat16<T,typename enable_if<!is_same<__decltype(T::shaderFloat16),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderFloat16: false_type { using type = void; }; template<class T> struct is_member_shaderFloat16<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderFloat16),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderFloat16); }; } template<class T> struct has_member_shaderFloat16 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderFloat16<T>::value + 2*impl::is_static_member_shaderFloat16<T>::value + 4*is_const<typename impl::is_member_shaderFloat16<T>::type>::value); }; template<class T, class F> struct has_member_shaderFloat16_with_type : bool_constant<has_member_shaderFloat16<T>::value && is_same<typename impl::is_member_shaderFloat16<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderInputAttachmentArrayDynamicIndexing: false_type { }; template<class T> struct is_static_member_shaderInputAttachmentArrayDynamicIndexing<T,typename enable_if<!is_same<__decltype(T::shaderInputAttachmentArrayDynamicIndexing),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderInputAttachmentArrayDynamicIndexing: false_type { using type = void; }; template<class T> struct is_member_shaderInputAttachmentArrayDynamicIndexing<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderInputAttachmentArrayDynamicIndexing),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderInputAttachmentArrayDynamicIndexing); }; } template<class T> struct has_member_shaderInputAttachmentArrayDynamicIndexing { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderInputAttachmentArrayDynamicIndexing<T>::value + 2*impl::is_static_member_shaderInputAttachmentArrayDynamicIndexing<T>::value + 4*is_const<typename impl::is_member_shaderInputAttachmentArrayDynamicIndexing<T>::type>::value); }; template<class T, class F> struct has_member_shaderInputAttachmentArrayDynamicIndexing_with_type : bool_constant<has_member_shaderInputAttachmentArrayDynamicIndexing<T>::value && is_same<typename impl::is_member_shaderInputAttachmentArrayDynamicIndexing<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderUniformBufferArrayNonUniformIndexing: false_type { }; template<class T> struct is_static_member_shaderUniformBufferArrayNonUniformIndexing<T,typename enable_if<!is_same<__decltype(T::shaderUniformBufferArrayNonUniformIndexing),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderUniformBufferArrayNonUniformIndexing: false_type { using type = void; }; template<class T> struct is_member_shaderUniformBufferArrayNonUniformIndexing<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderUniformBufferArrayNonUniformIndexing),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderUniformBufferArrayNonUniformIndexing); }; } template<class T> struct has_member_shaderUniformBufferArrayNonUniformIndexing { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderUniformBufferArrayNonUniformIndexing<T>::value + 2*impl::is_static_member_shaderUniformBufferArrayNonUniformIndexing<T>::value + 4*is_const<typename impl::is_member_shaderUniformBufferArrayNonUniformIndexing<T>::type>::value); }; template<class T, class F> struct has_member_shaderUniformBufferArrayNonUniformIndexing_with_type : bool_constant<has_member_shaderUniformBufferArrayNonUniformIndexing<T>::value && is_same<typename impl::is_member_shaderUniformBufferArrayNonUniformIndexing<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderInputAttachmentArrayNonUniformIndexing: false_type { }; template<class T> struct is_static_member_shaderInputAttachmentArrayNonUniformIndexing<T,typename enable_if<!is_same<__decltype(T::shaderInputAttachmentArrayNonUniformIndexing),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderInputAttachmentArrayNonUniformIndexing: false_type { using type = void; }; template<class T> struct is_member_shaderInputAttachmentArrayNonUniformIndexing<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderInputAttachmentArrayNonUniformIndexing),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderInputAttachmentArrayNonUniformIndexing); }; } template<class T> struct has_member_shaderInputAttachmentArrayNonUniformIndexing { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderInputAttachmentArrayNonUniformIndexing<T>::value + 2*impl::is_static_member_shaderInputAttachmentArrayNonUniformIndexing<T>::value + 4*is_const<typename impl::is_member_shaderInputAttachmentArrayNonUniformIndexing<T>::type>::value); }; template<class T, class F> struct has_member_shaderInputAttachmentArrayNonUniformIndexing_with_type : bool_constant<has_member_shaderInputAttachmentArrayNonUniformIndexing<T>::value && is_same<typename impl::is_member_shaderInputAttachmentArrayNonUniformIndexing<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_descriptorBindingUniformBufferUpdateAfterBind: false_type { }; template<class T> struct is_static_member_descriptorBindingUniformBufferUpdateAfterBind<T,typename enable_if<!is_same<__decltype(T::descriptorBindingUniformBufferUpdateAfterBind),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_descriptorBindingUniformBufferUpdateAfterBind: false_type { using type = void; }; template<class T> struct is_member_descriptorBindingUniformBufferUpdateAfterBind<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().descriptorBindingUniformBufferUpdateAfterBind),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().descriptorBindingUniformBufferUpdateAfterBind); }; } template<class T> struct has_member_descriptorBindingUniformBufferUpdateAfterBind { const static e_member_presence value = (e_member_presence)(impl::is_member_descriptorBindingUniformBufferUpdateAfterBind<T>::value + 2*impl::is_static_member_descriptorBindingUniformBufferUpdateAfterBind<T>::value + 4*is_const<typename impl::is_member_descriptorBindingUniformBufferUpdateAfterBind<T>::type>::value); }; template<class T, class F> struct has_member_descriptorBindingUniformBufferUpdateAfterBind_with_type : bool_constant<has_member_descriptorBindingUniformBufferUpdateAfterBind<T>::value && is_same<typename impl::is_member_descriptorBindingUniformBufferUpdateAfterBind<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_samplerFilterMinmax: false_type { }; template<class T> struct is_static_member_samplerFilterMinmax<T,typename enable_if<!is_same<__decltype(T::samplerFilterMinmax),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_samplerFilterMinmax: false_type { using type = void; }; template<class T> struct is_member_samplerFilterMinmax<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().samplerFilterMinmax),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().samplerFilterMinmax); }; } template<class T> struct has_member_samplerFilterMinmax { const static e_member_presence value = (e_member_presence)(impl::is_member_samplerFilterMinmax<T>::value + 2*impl::is_static_member_samplerFilterMinmax<T>::value + 4*is_const<typename impl::is_member_samplerFilterMinmax<T>::type>::value); }; template<class T, class F> struct has_member_samplerFilterMinmax_with_type : bool_constant<has_member_samplerFilterMinmax<T>::value && is_same<typename impl::is_member_samplerFilterMinmax<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_vulkanMemoryModelAvailabilityVisibilityChains: false_type { }; template<class T> struct is_static_member_vulkanMemoryModelAvailabilityVisibilityChains<T,typename enable_if<!is_same<__decltype(T::vulkanMemoryModelAvailabilityVisibilityChains),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_vulkanMemoryModelAvailabilityVisibilityChains: false_type { using type = void; }; template<class T> struct is_member_vulkanMemoryModelAvailabilityVisibilityChains<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().vulkanMemoryModelAvailabilityVisibilityChains),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().vulkanMemoryModelAvailabilityVisibilityChains); }; } template<class T> struct has_member_vulkanMemoryModelAvailabilityVisibilityChains { const static e_member_presence value = (e_member_presence)(impl::is_member_vulkanMemoryModelAvailabilityVisibilityChains<T>::value + 2*impl::is_static_member_vulkanMemoryModelAvailabilityVisibilityChains<T>::value + 4*is_const<typename impl::is_member_vulkanMemoryModelAvailabilityVisibilityChains<T>::type>::value); }; template<class T, class F> struct has_member_vulkanMemoryModelAvailabilityVisibilityChains_with_type : bool_constant<has_member_vulkanMemoryModelAvailabilityVisibilityChains<T>::value && is_same<typename impl::is_member_vulkanMemoryModelAvailabilityVisibilityChains<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderOutputViewportIndex: false_type { }; template<class T> struct is_static_member_shaderOutputViewportIndex<T,typename enable_if<!is_same<__decltype(T::shaderOutputViewportIndex),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderOutputViewportIndex: false_type { using type = void; }; template<class T> struct is_member_shaderOutputViewportIndex<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderOutputViewportIndex),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderOutputViewportIndex); }; } template<class T> struct has_member_shaderOutputViewportIndex { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderOutputViewportIndex<T>::value + 2*impl::is_static_member_shaderOutputViewportIndex<T>::value + 4*is_const<typename impl::is_member_shaderOutputViewportIndex<T>::type>::value); }; template<class T, class F> struct has_member_shaderOutputViewportIndex_with_type : bool_constant<has_member_shaderOutputViewportIndex<T>::value && is_same<typename impl::is_member_shaderOutputViewportIndex<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderOutputLayer: false_type { }; template<class T> struct is_static_member_shaderOutputLayer<T,typename enable_if<!is_same<__decltype(T::shaderOutputLayer),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderOutputLayer: false_type { using type = void; }; template<class T> struct is_member_shaderOutputLayer<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderOutputLayer),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderOutputLayer); }; } template<class T> struct has_member_shaderOutputLayer { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderOutputLayer<T>::value + 2*impl::is_static_member_shaderOutputLayer<T>::value + 4*is_const<typename impl::is_member_shaderOutputLayer<T>::type>::value); }; template<class T, class F> struct has_member_shaderOutputLayer_with_type : bool_constant<has_member_shaderOutputLayer<T>::value && is_same<typename impl::is_member_shaderOutputLayer<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDemoteToHelperInvocation: false_type { }; template<class T> struct is_static_member_shaderDemoteToHelperInvocation<T,typename enable_if<!is_same<__decltype(T::shaderDemoteToHelperInvocation),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDemoteToHelperInvocation: false_type { using type = void; }; template<class T> struct is_member_shaderDemoteToHelperInvocation<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDemoteToHelperInvocation),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDemoteToHelperInvocation); }; } template<class T> struct has_member_shaderDemoteToHelperInvocation { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDemoteToHelperInvocation<T>::value + 2*impl::is_static_member_shaderDemoteToHelperInvocation<T>::value + 4*is_const<typename impl::is_member_shaderDemoteToHelperInvocation<T>::type>::value); }; template<class T, class F> struct has_member_shaderDemoteToHelperInvocation_with_type : bool_constant<has_member_shaderDemoteToHelperInvocation<T>::value && is_same<typename impl::is_member_shaderDemoteToHelperInvocation<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderTerminateInvocation: false_type { }; template<class T> struct is_static_member_shaderTerminateInvocation<T,typename enable_if<!is_same<__decltype(T::shaderTerminateInvocation),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderTerminateInvocation: false_type { using type = void; }; template<class T> struct is_member_shaderTerminateInvocation<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderTerminateInvocation),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderTerminateInvocation); }; } template<class T> struct has_member_shaderTerminateInvocation { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderTerminateInvocation<T>::value + 2*impl::is_static_member_shaderTerminateInvocation<T>::value + 4*is_const<typename impl::is_member_shaderTerminateInvocation<T>::type>::value); }; template<class T, class F> struct has_member_shaderTerminateInvocation_with_type : bool_constant<has_member_shaderTerminateInvocation<T>::value && is_same<typename impl::is_member_shaderTerminateInvocation<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderZeroInitializeWorkgroupMemory: false_type { }; template<class T> struct is_static_member_shaderZeroInitializeWorkgroupMemory<T,typename enable_if<!is_same<__decltype(T::shaderZeroInitializeWorkgroupMemory),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderZeroInitializeWorkgroupMemory: false_type { using type = void; }; template<class T> struct is_member_shaderZeroInitializeWorkgroupMemory<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderZeroInitializeWorkgroupMemory),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderZeroInitializeWorkgroupMemory); }; } template<class T> struct has_member_shaderZeroInitializeWorkgroupMemory { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderZeroInitializeWorkgroupMemory<T>::value + 2*impl::is_static_member_shaderZeroInitializeWorkgroupMemory<T>::value + 4*is_const<typename impl::is_member_shaderZeroInitializeWorkgroupMemory<T>::type>::value); }; template<class T, class F> struct has_member_shaderZeroInitializeWorkgroupMemory_with_type : bool_constant<has_member_shaderZeroInitializeWorkgroupMemory<T>::value && is_same<typename impl::is_member_shaderZeroInitializeWorkgroupMemory<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderDeviceClock: false_type { }; template<class T> struct is_static_member_shaderDeviceClock<T,typename enable_if<!is_same<__decltype(T::shaderDeviceClock),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderDeviceClock: false_type { using type = void; }; template<class T> struct is_member_shaderDeviceClock<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderDeviceClock),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderDeviceClock); }; } template<class T> struct has_member_shaderDeviceClock { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderDeviceClock<T>::value + 2*impl::is_static_member_shaderDeviceClock<T>::value + 4*is_const<typename impl::is_member_shaderDeviceClock<T>::type>::value); }; template<class T, class F> struct has_member_shaderDeviceClock_with_type : bool_constant<has_member_shaderDeviceClock<T>::value && is_same<typename impl::is_member_shaderDeviceClock<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderSubgroupClock: false_type { }; template<class T> struct is_static_member_shaderSubgroupClock<T,typename enable_if<!is_same<__decltype(T::shaderSubgroupClock),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderSubgroupClock: false_type { using type = void; }; template<class T> struct is_member_shaderSubgroupClock<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderSubgroupClock),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderSubgroupClock); }; } template<class T> struct has_member_shaderSubgroupClock { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderSubgroupClock<T>::value + 2*impl::is_static_member_shaderSubgroupClock<T>::value + 4*is_const<typename impl::is_member_shaderSubgroupClock<T>::type>::value); }; template<class T, class F> struct has_member_shaderSubgroupClock_with_type : bool_constant<has_member_shaderSubgroupClock<T>::value && is_same<typename impl::is_member_shaderSubgroupClock<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_imageFootprint: false_type { }; template<class T> struct is_static_member_imageFootprint<T,typename enable_if<!is_same<__decltype(T::imageFootprint),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_imageFootprint: false_type { using type = void; }; template<class T> struct is_member_imageFootprint<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().imageFootprint),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().imageFootprint); }; } template<class T> struct has_member_imageFootprint { const static e_member_presence value = (e_member_presence)(impl::is_member_imageFootprint<T>::value + 2*impl::is_static_member_imageFootprint<T>::value + 4*is_const<typename impl::is_member_imageFootprint<T>::type>::value); }; template<class T, class F> struct has_member_imageFootprint_with_type : bool_constant<has_member_imageFootprint<T>::value && is_same<typename impl::is_member_imageFootprint<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderIntegerFunctions2: false_type { }; template<class T> struct is_static_member_shaderIntegerFunctions2<T,typename enable_if<!is_same<__decltype(T::shaderIntegerFunctions2),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderIntegerFunctions2: false_type { using type = void; }; template<class T> struct is_member_shaderIntegerFunctions2<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderIntegerFunctions2),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderIntegerFunctions2); }; } template<class T> struct has_member_shaderIntegerFunctions2 { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderIntegerFunctions2<T>::value + 2*impl::is_static_member_shaderIntegerFunctions2<T>::value + 4*is_const<typename impl::is_member_shaderIntegerFunctions2<T>::type>::value); }; template<class T, class F> struct has_member_shaderIntegerFunctions2_with_type : bool_constant<has_member_shaderIntegerFunctions2<T>::value && is_same<typename impl::is_member_shaderIntegerFunctions2<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderEarlyAndLateFragmentTests: false_type { }; template<class T> struct is_static_member_shaderEarlyAndLateFragmentTests<T,typename enable_if<!is_same<__decltype(T::shaderEarlyAndLateFragmentTests),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderEarlyAndLateFragmentTests: false_type { using type = void; }; template<class T> struct is_member_shaderEarlyAndLateFragmentTests<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderEarlyAndLateFragmentTests),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderEarlyAndLateFragmentTests); }; } template<class T> struct has_member_shaderEarlyAndLateFragmentTests { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderEarlyAndLateFragmentTests<T>::value + 2*impl::is_static_member_shaderEarlyAndLateFragmentTests<T>::value + 4*is_const<typename impl::is_member_shaderEarlyAndLateFragmentTests<T>::type>::value); }; template<class T, class F> struct has_member_shaderEarlyAndLateFragmentTests_with_type : bool_constant<has_member_shaderEarlyAndLateFragmentTests<T>::value && is_same<typename impl::is_member_shaderEarlyAndLateFragmentTests<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rayTracingPositionFetch: false_type { }; template<class T> struct is_static_member_rayTracingPositionFetch<T,typename enable_if<!is_same<__decltype(T::rayTracingPositionFetch),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rayTracingPositionFetch: false_type { using type = void; }; template<class T> struct is_member_rayTracingPositionFetch<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rayTracingPositionFetch),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rayTracingPositionFetch); }; } template<class T> struct has_member_rayTracingPositionFetch { const static e_member_presence value = (e_member_presence)(impl::is_member_rayTracingPositionFetch<T>::value + 2*impl::is_static_member_rayTracingPositionFetch<T>::value + 4*is_const<typename impl::is_member_rayTracingPositionFetch<T>::type>::value); }; template<class T, class F> struct has_member_rayTracingPositionFetch_with_type : bool_constant<has_member_rayTracingPositionFetch<T>::value && is_same<typename impl::is_member_rayTracingPositionFetch<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_cooperativeMatrix: false_type { }; template<class T> struct is_static_member_cooperativeMatrix<T,typename enable_if<!is_same<__decltype(T::cooperativeMatrix),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_cooperativeMatrix: false_type { using type = void; }; template<class T> struct is_member_cooperativeMatrix<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().cooperativeMatrix),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().cooperativeMatrix); }; } template<class T> struct has_member_cooperativeMatrix { const static e_member_presence value = (e_member_presence)(impl::is_member_cooperativeMatrix<T>::value + 2*impl::is_static_member_cooperativeMatrix<T>::value + 4*is_const<typename impl::is_member_cooperativeMatrix<T>::type>::value); }; template<class T, class F> struct has_member_cooperativeMatrix_with_type : bool_constant<has_member_cooperativeMatrix<T>::value && is_same<typename impl::is_member_cooperativeMatrix<T>::type, F>::value> {}; } };

// Features Testers
// VK 1.0
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_robustBufferAccess: false_type { }; template<class T> struct is_static_member_robustBufferAccess<T,typename enable_if<!is_same<__decltype(T::robustBufferAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_robustBufferAccess: false_type { using type = void; }; template<class T> struct is_member_robustBufferAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().robustBufferAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().robustBufferAccess); }; } template<class T> struct has_member_robustBufferAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_robustBufferAccess<T>::value + 2*impl::is_static_member_robustBufferAccess<T>::value + 4*is_const<typename impl::is_member_robustBufferAccess<T>::type>::value); }; template<class T, class F> struct has_member_robustBufferAccess_with_type : bool_constant<has_member_robustBufferAccess<T>::value && is_same<typename impl::is_member_robustBufferAccess<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_geometryShader: false_type { }; template<class T> struct is_static_member_geometryShader<T,typename enable_if<!is_same<__decltype(T::geometryShader),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_geometryShader: false_type { using type = void; }; template<class T> struct is_member_geometryShader<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().geometryShader),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().geometryShader); }; } template<class T> struct has_member_geometryShader { const static e_member_presence value = (e_member_presence)(impl::is_member_geometryShader<T>::value + 2*impl::is_static_member_geometryShader<T>::value + 4*is_const<typename impl::is_member_geometryShader<T>::type>::value); }; template<class T, class F> struct has_member_geometryShader_with_type : bool_constant<has_member_geometryShader<T>::value && is_same<typename impl::is_member_geometryShader<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_tessellationShader: false_type { }; template<class T> struct is_static_member_tessellationShader<T,typename enable_if<!is_same<__decltype(T::tessellationShader),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_tessellationShader: false_type { using type = void; }; template<class T> struct is_member_tessellationShader<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().tessellationShader),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().tessellationShader); }; } template<class T> struct has_member_tessellationShader { const static e_member_presence value = (e_member_presence)(impl::is_member_tessellationShader<T>::value + 2*impl::is_static_member_tessellationShader<T>::value + 4*is_const<typename impl::is_member_tessellationShader<T>::type>::value); }; template<class T, class F> struct has_member_tessellationShader_with_type : bool_constant<has_member_tessellationShader<T>::value && is_same<typename impl::is_member_tessellationShader<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_depthBounds: false_type { }; template<class T> struct is_static_member_depthBounds<T,typename enable_if<!is_same<__decltype(T::depthBounds),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_depthBounds: false_type { using type = void; }; template<class T> struct is_member_depthBounds<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().depthBounds),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().depthBounds); }; } template<class T> struct has_member_depthBounds { const static e_member_presence value = (e_member_presence)(impl::is_member_depthBounds<T>::value + 2*impl::is_static_member_depthBounds<T>::value + 4*is_const<typename impl::is_member_depthBounds<T>::type>::value); }; template<class T, class F> struct has_member_depthBounds_with_type : bool_constant<has_member_depthBounds<T>::value && is_same<typename impl::is_member_depthBounds<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_wideLines: false_type { }; template<class T> struct is_static_member_wideLines<T,typename enable_if<!is_same<__decltype(T::wideLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_wideLines: false_type { using type = void; }; template<class T> struct is_member_wideLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().wideLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().wideLines); }; } template<class T> struct has_member_wideLines { const static e_member_presence value = (e_member_presence)(impl::is_member_wideLines<T>::value + 2*impl::is_static_member_wideLines<T>::value + 4*is_const<typename impl::is_member_wideLines<T>::type>::value); }; template<class T, class F> struct has_member_wideLines_with_type : bool_constant<has_member_wideLines<T>::value && is_same<typename impl::is_member_wideLines<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_largePoints: false_type { }; template<class T> struct is_static_member_largePoints<T,typename enable_if<!is_same<__decltype(T::largePoints),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_largePoints: false_type { using type = void; }; template<class T> struct is_member_largePoints<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().largePoints),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().largePoints); }; } template<class T> struct has_member_largePoints { const static e_member_presence value = (e_member_presence)(impl::is_member_largePoints<T>::value + 2*impl::is_static_member_largePoints<T>::value + 4*is_const<typename impl::is_member_largePoints<T>::type>::value); }; template<class T, class F> struct has_member_largePoints_with_type : bool_constant<has_member_largePoints<T>::value && is_same<typename impl::is_member_largePoints<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_alphaToOne: false_type { }; template<class T> struct is_static_member_alphaToOne<T,typename enable_if<!is_same<__decltype(T::alphaToOne),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_alphaToOne: false_type { using type = void; }; template<class T> struct is_member_alphaToOne<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().alphaToOne),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().alphaToOne); }; } template<class T> struct has_member_alphaToOne { const static e_member_presence value = (e_member_presence)(impl::is_member_alphaToOne<T>::value + 2*impl::is_static_member_alphaToOne<T>::value + 4*is_const<typename impl::is_member_alphaToOne<T>::type>::value); }; template<class T, class F> struct has_member_alphaToOne_with_type : bool_constant<has_member_alphaToOne<T>::value && is_same<typename impl::is_member_alphaToOne<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pipelineStatisticsQuery: false_type { }; template<class T> struct is_static_member_pipelineStatisticsQuery<T,typename enable_if<!is_same<__decltype(T::pipelineStatisticsQuery),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pipelineStatisticsQuery: false_type { using type = void; }; template<class T> struct is_member_pipelineStatisticsQuery<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pipelineStatisticsQuery),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pipelineStatisticsQuery); }; } template<class T> struct has_member_pipelineStatisticsQuery { const static e_member_presence value = (e_member_presence)(impl::is_member_pipelineStatisticsQuery<T>::value + 2*impl::is_static_member_pipelineStatisticsQuery<T>::value + 4*is_const<typename impl::is_member_pipelineStatisticsQuery<T>::type>::value); }; template<class T, class F> struct has_member_pipelineStatisticsQuery_with_type : bool_constant<has_member_pipelineStatisticsQuery<T>::value && is_same<typename impl::is_member_pipelineStatisticsQuery<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderCullDistance: false_type { }; template<class T> struct is_static_member_shaderCullDistance<T,typename enable_if<!is_same<__decltype(T::shaderCullDistance),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderCullDistance: false_type { using type = void; }; template<class T> struct is_member_shaderCullDistance<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderCullDistance),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderCullDistance); }; } template<class T> struct has_member_shaderCullDistance { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderCullDistance<T>::value + 2*impl::is_static_member_shaderCullDistance<T>::value + 4*is_const<typename impl::is_member_shaderCullDistance<T>::type>::value); }; template<class T, class F> struct has_member_shaderCullDistance_with_type : bool_constant<has_member_shaderCullDistance<T>::value && is_same<typename impl::is_member_shaderCullDistance<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderResourceResidency: false_type { }; template<class T> struct is_static_member_shaderResourceResidency<T,typename enable_if<!is_same<__decltype(T::shaderResourceResidency),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderResourceResidency: false_type { using type = void; }; template<class T> struct is_member_shaderResourceResidency<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderResourceResidency),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderResourceResidency); }; } template<class T> struct has_member_shaderResourceResidency { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderResourceResidency<T>::value + 2*impl::is_static_member_shaderResourceResidency<T>::value + 4*is_const<typename impl::is_member_shaderResourceResidency<T>::type>::value); }; template<class T, class F> struct has_member_shaderResourceResidency_with_type : bool_constant<has_member_shaderResourceResidency<T>::value && is_same<typename impl::is_member_shaderResourceResidency<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderResourceMinLod: false_type { }; template<class T> struct is_static_member_shaderResourceMinLod<T,typename enable_if<!is_same<__decltype(T::shaderResourceMinLod),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderResourceMinLod: false_type { using type = void; }; template<class T> struct is_member_shaderResourceMinLod<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderResourceMinLod),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderResourceMinLod); }; } template<class T> struct has_member_shaderResourceMinLod { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderResourceMinLod<T>::value + 2*impl::is_static_member_shaderResourceMinLod<T>::value + 4*is_const<typename impl::is_member_shaderResourceMinLod<T>::type>::value); }; template<class T, class F> struct has_member_shaderResourceMinLod_with_type : bool_constant<has_member_shaderResourceMinLod<T>::value && is_same<typename impl::is_member_shaderResourceMinLod<T>::type, F>::value> {}; } };

// VK 1.1
// VK 1.2
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_bufferDeviceAddressMultiDevice: false_type { }; template<class T> struct is_static_member_bufferDeviceAddressMultiDevice<T,typename enable_if<!is_same<__decltype(T::bufferDeviceAddressMultiDevice),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_bufferDeviceAddressMultiDevice: false_type { using type = void; }; template<class T> struct is_member_bufferDeviceAddressMultiDevice<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().bufferDeviceAddressMultiDevice),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().bufferDeviceAddressMultiDevice); }; } template<class T> struct has_member_bufferDeviceAddressMultiDevice { const static e_member_presence value = (e_member_presence)(impl::is_member_bufferDeviceAddressMultiDevice<T>::value + 2*impl::is_static_member_bufferDeviceAddressMultiDevice<T>::value + 4*is_const<typename impl::is_member_bufferDeviceAddressMultiDevice<T>::type>::value); }; template<class T, class F> struct has_member_bufferDeviceAddressMultiDevice_with_type : bool_constant<has_member_bufferDeviceAddressMultiDevice<T>::value && is_same<typename impl::is_member_bufferDeviceAddressMultiDevice<T>::type, F>::value> {}; } };

// VK 1.3
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_robustImageAccess: false_type { }; template<class T> struct is_static_member_robustImageAccess<T,typename enable_if<!is_same<__decltype(T::robustImageAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_robustImageAccess: false_type { using type = void; }; template<class T> struct is_member_robustImageAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().robustImageAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().robustImageAccess); }; } template<class T> struct has_member_robustImageAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_robustImageAccess<T>::value + 2*impl::is_static_member_robustImageAccess<T>::value + 4*is_const<typename impl::is_member_robustImageAccess<T>::type>::value); }; template<class T, class F> struct has_member_robustImageAccess_with_type : bool_constant<has_member_robustImageAccess<T>::value && is_same<typename impl::is_member_robustImageAccess<T>::type, F>::value> {}; } };

// Nabla Core Extensions
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_robustBufferAccess2: false_type { }; template<class T> struct is_static_member_robustBufferAccess2<T,typename enable_if<!is_same<__decltype(T::robustBufferAccess2),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_robustBufferAccess2: false_type { using type = void; }; template<class T> struct is_member_robustBufferAccess2<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().robustBufferAccess2),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().robustBufferAccess2); }; } template<class T> struct has_member_robustBufferAccess2 { const static e_member_presence value = (e_member_presence)(impl::is_member_robustBufferAccess2<T>::value + 2*impl::is_static_member_robustBufferAccess2<T>::value + 4*is_const<typename impl::is_member_robustBufferAccess2<T>::type>::value); }; template<class T, class F> struct has_member_robustBufferAccess2_with_type : bool_constant<has_member_robustBufferAccess2<T>::value && is_same<typename impl::is_member_robustBufferAccess2<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_robustImageAccess2: false_type { }; template<class T> struct is_static_member_robustImageAccess2<T,typename enable_if<!is_same<__decltype(T::robustImageAccess2),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_robustImageAccess2: false_type { using type = void; }; template<class T> struct is_member_robustImageAccess2<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().robustImageAccess2),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().robustImageAccess2); }; } template<class T> struct has_member_robustImageAccess2 { const static e_member_presence value = (e_member_presence)(impl::is_member_robustImageAccess2<T>::value + 2*impl::is_static_member_robustImageAccess2<T>::value + 4*is_const<typename impl::is_member_robustImageAccess2<T>::type>::value); }; template<class T, class F> struct has_member_robustImageAccess2_with_type : bool_constant<has_member_robustImageAccess2<T>::value && is_same<typename impl::is_member_robustImageAccess2<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_nullDescriptor: false_type { }; template<class T> struct is_static_member_nullDescriptor<T,typename enable_if<!is_same<__decltype(T::nullDescriptor),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_nullDescriptor: false_type { using type = void; }; template<class T> struct is_member_nullDescriptor<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().nullDescriptor),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().nullDescriptor); }; } template<class T> struct has_member_nullDescriptor { const static e_member_presence value = (e_member_presence)(impl::is_member_nullDescriptor<T>::value + 2*impl::is_static_member_nullDescriptor<T>::value + 4*is_const<typename impl::is_member_nullDescriptor<T>::type>::value); }; template<class T, class F> struct has_member_nullDescriptor_with_type : bool_constant<has_member_nullDescriptor<T>::value && is_same<typename impl::is_member_nullDescriptor<T>::type, F>::value> {}; } };

// Extensions
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_swapchainModeBitPattern: false_type { }; template<class T> struct is_static_member_swapchainModeBitPattern<T,typename enable_if<!is_same<__decltype(T::swapchainModeBitPattern),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_swapchainModeBitPattern: false_type { using type = void; }; template<class T> struct is_member_swapchainModeBitPattern<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().swapchainModeBitPattern),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().swapchainModeBitPattern); }; } template<class T> struct has_member_swapchainModeBitPattern { const static e_member_presence value = (e_member_presence)(impl::is_member_swapchainModeBitPattern<T>::value + 2*impl::is_static_member_swapchainModeBitPattern<T>::value + 4*is_const<typename impl::is_member_swapchainModeBitPattern<T>::type>::value); }; template<class T, class F> struct has_member_swapchainModeBitPattern_with_type : bool_constant<has_member_swapchainModeBitPattern<T>::value && is_same<typename impl::is_member_swapchainModeBitPattern<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_shaderInfoAMD: false_type { }; template<class T> struct is_static_member_shaderInfoAMD<T,typename enable_if<!is_same<__decltype(T::shaderInfoAMD),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_shaderInfoAMD: false_type { using type = void; }; template<class T> struct is_member_shaderInfoAMD<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().shaderInfoAMD),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().shaderInfoAMD); }; } template<class T> struct has_member_shaderInfoAMD { const static e_member_presence value = (e_member_presence)(impl::is_member_shaderInfoAMD<T>::value + 2*impl::is_static_member_shaderInfoAMD<T>::value + 4*is_const<typename impl::is_member_shaderInfoAMD<T>::type>::value); }; template<class T, class F> struct has_member_shaderInfoAMD_with_type : bool_constant<has_member_shaderInfoAMD<T>::value && is_same<typename impl::is_member_shaderInfoAMD<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_conditionalRendering: false_type { }; template<class T> struct is_static_member_conditionalRendering<T,typename enable_if<!is_same<__decltype(T::conditionalRendering),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_conditionalRendering: false_type { using type = void; }; template<class T> struct is_member_conditionalRendering<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().conditionalRendering),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().conditionalRendering); }; } template<class T> struct has_member_conditionalRendering { const static e_member_presence value = (e_member_presence)(impl::is_member_conditionalRendering<T>::value + 2*impl::is_static_member_conditionalRendering<T>::value + 4*is_const<typename impl::is_member_conditionalRendering<T>::type>::value); }; template<class T, class F> struct has_member_conditionalRendering_with_type : bool_constant<has_member_conditionalRendering<T>::value && is_same<typename impl::is_member_conditionalRendering<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_inheritedConditionalRendering: false_type { }; template<class T> struct is_static_member_inheritedConditionalRendering<T,typename enable_if<!is_same<__decltype(T::inheritedConditionalRendering),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_inheritedConditionalRendering: false_type { using type = void; }; template<class T> struct is_member_inheritedConditionalRendering<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().inheritedConditionalRendering),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().inheritedConditionalRendering); }; } template<class T> struct has_member_inheritedConditionalRendering { const static e_member_presence value = (e_member_presence)(impl::is_member_inheritedConditionalRendering<T>::value + 2*impl::is_static_member_inheritedConditionalRendering<T>::value + 4*is_const<typename impl::is_member_inheritedConditionalRendering<T>::type>::value); }; template<class T, class F> struct has_member_inheritedConditionalRendering_with_type : bool_constant<has_member_inheritedConditionalRendering<T>::value && is_same<typename impl::is_member_inheritedConditionalRendering<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_geometryShaderPassthrough: false_type { }; template<class T> struct is_static_member_geometryShaderPassthrough<T,typename enable_if<!is_same<__decltype(T::geometryShaderPassthrough),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_geometryShaderPassthrough: false_type { using type = void; }; template<class T> struct is_member_geometryShaderPassthrough<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().geometryShaderPassthrough),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().geometryShaderPassthrough); }; } template<class T> struct has_member_geometryShaderPassthrough { const static e_member_presence value = (e_member_presence)(impl::is_member_geometryShaderPassthrough<T>::value + 2*impl::is_static_member_geometryShaderPassthrough<T>::value + 4*is_const<typename impl::is_member_geometryShaderPassthrough<T>::type>::value); }; template<class T, class F> struct has_member_geometryShaderPassthrough_with_type : bool_constant<has_member_geometryShaderPassthrough<T>::value && is_same<typename impl::is_member_geometryShaderPassthrough<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_hdrMetadata: false_type { }; template<class T> struct is_static_member_hdrMetadata<T,typename enable_if<!is_same<__decltype(T::hdrMetadata),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_hdrMetadata: false_type { using type = void; }; template<class T> struct is_member_hdrMetadata<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().hdrMetadata),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().hdrMetadata); }; } template<class T> struct has_member_hdrMetadata { const static e_member_presence value = (e_member_presence)(impl::is_member_hdrMetadata<T>::value + 2*impl::is_static_member_hdrMetadata<T>::value + 4*is_const<typename impl::is_member_hdrMetadata<T>::type>::value); }; template<class T, class F> struct has_member_hdrMetadata_with_type : bool_constant<has_member_hdrMetadata<T>::value && is_same<typename impl::is_member_hdrMetadata<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_performanceCounterQueryPools: false_type { }; template<class T> struct is_static_member_performanceCounterQueryPools<T,typename enable_if<!is_same<__decltype(T::performanceCounterQueryPools),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_performanceCounterQueryPools: false_type { using type = void; }; template<class T> struct is_member_performanceCounterQueryPools<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().performanceCounterQueryPools),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().performanceCounterQueryPools); }; } template<class T> struct has_member_performanceCounterQueryPools { const static e_member_presence value = (e_member_presence)(impl::is_member_performanceCounterQueryPools<T>::value + 2*impl::is_static_member_performanceCounterQueryPools<T>::value + 4*is_const<typename impl::is_member_performanceCounterQueryPools<T>::type>::value); }; template<class T, class F> struct has_member_performanceCounterQueryPools_with_type : bool_constant<has_member_performanceCounterQueryPools<T>::value && is_same<typename impl::is_member_performanceCounterQueryPools<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_performanceCounterMultipleQueryPools: false_type { }; template<class T> struct is_static_member_performanceCounterMultipleQueryPools<T,typename enable_if<!is_same<__decltype(T::performanceCounterMultipleQueryPools),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_performanceCounterMultipleQueryPools: false_type { using type = void; }; template<class T> struct is_member_performanceCounterMultipleQueryPools<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().performanceCounterMultipleQueryPools),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().performanceCounterMultipleQueryPools); }; } template<class T> struct has_member_performanceCounterMultipleQueryPools { const static e_member_presence value = (e_member_presence)(impl::is_member_performanceCounterMultipleQueryPools<T>::value + 2*impl::is_static_member_performanceCounterMultipleQueryPools<T>::value + 4*is_const<typename impl::is_member_performanceCounterMultipleQueryPools<T>::type>::value); }; template<class T, class F> struct has_member_performanceCounterMultipleQueryPools_with_type : bool_constant<has_member_performanceCounterMultipleQueryPools<T>::value && is_same<typename impl::is_member_performanceCounterMultipleQueryPools<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_mixedAttachmentSamples: false_type { }; template<class T> struct is_static_member_mixedAttachmentSamples<T,typename enable_if<!is_same<__decltype(T::mixedAttachmentSamples),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_mixedAttachmentSamples: false_type { using type = void; }; template<class T> struct is_member_mixedAttachmentSamples<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().mixedAttachmentSamples),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().mixedAttachmentSamples); }; } template<class T> struct has_member_mixedAttachmentSamples { const static e_member_presence value = (e_member_presence)(impl::is_member_mixedAttachmentSamples<T>::value + 2*impl::is_static_member_mixedAttachmentSamples<T>::value + 4*is_const<typename impl::is_member_mixedAttachmentSamples<T>::type>::value); }; template<class T, class F> struct has_member_mixedAttachmentSamples_with_type : bool_constant<has_member_mixedAttachmentSamples<T>::value && is_same<typename impl::is_member_mixedAttachmentSamples<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_accelerationStructure: false_type { }; template<class T> struct is_static_member_accelerationStructure<T,typename enable_if<!is_same<__decltype(T::accelerationStructure),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_accelerationStructure: false_type { using type = void; }; template<class T> struct is_member_accelerationStructure<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().accelerationStructure),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().accelerationStructure); }; } template<class T> struct has_member_accelerationStructure { const static e_member_presence value = (e_member_presence)(impl::is_member_accelerationStructure<T>::value + 2*impl::is_static_member_accelerationStructure<T>::value + 4*is_const<typename impl::is_member_accelerationStructure<T>::type>::value); }; template<class T, class F> struct has_member_accelerationStructure_with_type : bool_constant<has_member_accelerationStructure<T>::value && is_same<typename impl::is_member_accelerationStructure<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_accelerationStructureIndirectBuild: false_type { }; template<class T> struct is_static_member_accelerationStructureIndirectBuild<T,typename enable_if<!is_same<__decltype(T::accelerationStructureIndirectBuild),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_accelerationStructureIndirectBuild: false_type { using type = void; }; template<class T> struct is_member_accelerationStructureIndirectBuild<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().accelerationStructureIndirectBuild),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().accelerationStructureIndirectBuild); }; } template<class T> struct has_member_accelerationStructureIndirectBuild { const static e_member_presence value = (e_member_presence)(impl::is_member_accelerationStructureIndirectBuild<T>::value + 2*impl::is_static_member_accelerationStructureIndirectBuild<T>::value + 4*is_const<typename impl::is_member_accelerationStructureIndirectBuild<T>::type>::value); }; template<class T, class F> struct has_member_accelerationStructureIndirectBuild_with_type : bool_constant<has_member_accelerationStructureIndirectBuild<T>::value && is_same<typename impl::is_member_accelerationStructureIndirectBuild<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_accelerationStructureHostCommands: false_type { }; template<class T> struct is_static_member_accelerationStructureHostCommands<T,typename enable_if<!is_same<__decltype(T::accelerationStructureHostCommands),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_accelerationStructureHostCommands: false_type { using type = void; }; template<class T> struct is_member_accelerationStructureHostCommands<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().accelerationStructureHostCommands),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().accelerationStructureHostCommands); }; } template<class T> struct has_member_accelerationStructureHostCommands { const static e_member_presence value = (e_member_presence)(impl::is_member_accelerationStructureHostCommands<T>::value + 2*impl::is_static_member_accelerationStructureHostCommands<T>::value + 4*is_const<typename impl::is_member_accelerationStructureHostCommands<T>::type>::value); }; template<class T, class F> struct has_member_accelerationStructureHostCommands_with_type : bool_constant<has_member_accelerationStructureHostCommands<T>::value && is_same<typename impl::is_member_accelerationStructureHostCommands<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rayTracingPipeline: false_type { }; template<class T> struct is_static_member_rayTracingPipeline<T,typename enable_if<!is_same<__decltype(T::rayTracingPipeline),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rayTracingPipeline: false_type { using type = void; }; template<class T> struct is_member_rayTracingPipeline<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rayTracingPipeline),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rayTracingPipeline); }; } template<class T> struct has_member_rayTracingPipeline { const static e_member_presence value = (e_member_presence)(impl::is_member_rayTracingPipeline<T>::value + 2*impl::is_static_member_rayTracingPipeline<T>::value + 4*is_const<typename impl::is_member_rayTracingPipeline<T>::type>::value); }; template<class T, class F> struct has_member_rayTracingPipeline_with_type : bool_constant<has_member_rayTracingPipeline<T>::value && is_same<typename impl::is_member_rayTracingPipeline<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rayTraversalPrimitiveCulling: false_type { }; template<class T> struct is_static_member_rayTraversalPrimitiveCulling<T,typename enable_if<!is_same<__decltype(T::rayTraversalPrimitiveCulling),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rayTraversalPrimitiveCulling: false_type { using type = void; }; template<class T> struct is_member_rayTraversalPrimitiveCulling<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rayTraversalPrimitiveCulling),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rayTraversalPrimitiveCulling); }; } template<class T> struct has_member_rayTraversalPrimitiveCulling { const static e_member_presence value = (e_member_presence)(impl::is_member_rayTraversalPrimitiveCulling<T>::value + 2*impl::is_static_member_rayTraversalPrimitiveCulling<T>::value + 4*is_const<typename impl::is_member_rayTraversalPrimitiveCulling<T>::type>::value); }; template<class T, class F> struct has_member_rayTraversalPrimitiveCulling_with_type : bool_constant<has_member_rayTraversalPrimitiveCulling<T>::value && is_same<typename impl::is_member_rayTraversalPrimitiveCulling<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rayQuery: false_type { }; template<class T> struct is_static_member_rayQuery<T,typename enable_if<!is_same<__decltype(T::rayQuery),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rayQuery: false_type { using type = void; }; template<class T> struct is_member_rayQuery<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rayQuery),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rayQuery); }; } template<class T> struct has_member_rayQuery { const static e_member_presence value = (e_member_presence)(impl::is_member_rayQuery<T>::value + 2*impl::is_static_member_rayQuery<T>::value + 4*is_const<typename impl::is_member_rayQuery<T>::type>::value); }; template<class T, class F> struct has_member_rayQuery_with_type : bool_constant<has_member_rayQuery<T>::value && is_same<typename impl::is_member_rayQuery<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_representativeFragmentTest: false_type { }; template<class T> struct is_static_member_representativeFragmentTest<T,typename enable_if<!is_same<__decltype(T::representativeFragmentTest),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_representativeFragmentTest: false_type { using type = void; }; template<class T> struct is_member_representativeFragmentTest<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().representativeFragmentTest),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().representativeFragmentTest); }; } template<class T> struct has_member_representativeFragmentTest { const static e_member_presence value = (e_member_presence)(impl::is_member_representativeFragmentTest<T>::value + 2*impl::is_static_member_representativeFragmentTest<T>::value + 4*is_const<typename impl::is_member_representativeFragmentTest<T>::type>::value); }; template<class T, class F> struct has_member_representativeFragmentTest_with_type : bool_constant<has_member_representativeFragmentTest<T>::value && is_same<typename impl::is_member_representativeFragmentTest<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_bufferMarkerAMD: false_type { }; template<class T> struct is_static_member_bufferMarkerAMD<T,typename enable_if<!is_same<__decltype(T::bufferMarkerAMD),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_bufferMarkerAMD: false_type { using type = void; }; template<class T> struct is_member_bufferMarkerAMD<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().bufferMarkerAMD),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().bufferMarkerAMD); }; } template<class T> struct has_member_bufferMarkerAMD { const static e_member_presence value = (e_member_presence)(impl::is_member_bufferMarkerAMD<T>::value + 2*impl::is_static_member_bufferMarkerAMD<T>::value + 4*is_const<typename impl::is_member_bufferMarkerAMD<T>::type>::value); }; template<class T, class F> struct has_member_bufferMarkerAMD_with_type : bool_constant<has_member_bufferMarkerAMD<T>::value && is_same<typename impl::is_member_bufferMarkerAMD<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentDensityMap: false_type { }; template<class T> struct is_static_member_fragmentDensityMap<T,typename enable_if<!is_same<__decltype(T::fragmentDensityMap),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentDensityMap: false_type { using type = void; }; template<class T> struct is_member_fragmentDensityMap<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentDensityMap),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentDensityMap); }; } template<class T> struct has_member_fragmentDensityMap { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentDensityMap<T>::value + 2*impl::is_static_member_fragmentDensityMap<T>::value + 4*is_const<typename impl::is_member_fragmentDensityMap<T>::type>::value); }; template<class T, class F> struct has_member_fragmentDensityMap_with_type : bool_constant<has_member_fragmentDensityMap<T>::value && is_same<typename impl::is_member_fragmentDensityMap<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentDensityMapDynamic: false_type { }; template<class T> struct is_static_member_fragmentDensityMapDynamic<T,typename enable_if<!is_same<__decltype(T::fragmentDensityMapDynamic),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentDensityMapDynamic: false_type { using type = void; }; template<class T> struct is_member_fragmentDensityMapDynamic<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentDensityMapDynamic),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentDensityMapDynamic); }; } template<class T> struct has_member_fragmentDensityMapDynamic { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentDensityMapDynamic<T>::value + 2*impl::is_static_member_fragmentDensityMapDynamic<T>::value + 4*is_const<typename impl::is_member_fragmentDensityMapDynamic<T>::type>::value); }; template<class T, class F> struct has_member_fragmentDensityMapDynamic_with_type : bool_constant<has_member_fragmentDensityMapDynamic<T>::value && is_same<typename impl::is_member_fragmentDensityMapDynamic<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentDensityMapNonSubsampledImages: false_type { }; template<class T> struct is_static_member_fragmentDensityMapNonSubsampledImages<T,typename enable_if<!is_same<__decltype(T::fragmentDensityMapNonSubsampledImages),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentDensityMapNonSubsampledImages: false_type { using type = void; }; template<class T> struct is_member_fragmentDensityMapNonSubsampledImages<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentDensityMapNonSubsampledImages),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentDensityMapNonSubsampledImages); }; } template<class T> struct has_member_fragmentDensityMapNonSubsampledImages { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentDensityMapNonSubsampledImages<T>::value + 2*impl::is_static_member_fragmentDensityMapNonSubsampledImages<T>::value + 4*is_const<typename impl::is_member_fragmentDensityMapNonSubsampledImages<T>::type>::value); }; template<class T, class F> struct has_member_fragmentDensityMapNonSubsampledImages_with_type : bool_constant<has_member_fragmentDensityMapNonSubsampledImages<T>::value && is_same<typename impl::is_member_fragmentDensityMapNonSubsampledImages<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_deviceCoherentMemory: false_type { }; template<class T> struct is_static_member_deviceCoherentMemory<T,typename enable_if<!is_same<__decltype(T::deviceCoherentMemory),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_deviceCoherentMemory: false_type { using type = void; }; template<class T> struct is_member_deviceCoherentMemory<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().deviceCoherentMemory),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().deviceCoherentMemory); }; } template<class T> struct has_member_deviceCoherentMemory { const static e_member_presence value = (e_member_presence)(impl::is_member_deviceCoherentMemory<T>::value + 2*impl::is_static_member_deviceCoherentMemory<T>::value + 4*is_const<typename impl::is_member_deviceCoherentMemory<T>::type>::value); }; template<class T, class F> struct has_member_deviceCoherentMemory_with_type : bool_constant<has_member_deviceCoherentMemory<T>::value && is_same<typename impl::is_member_deviceCoherentMemory<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_memoryPriority: false_type { }; template<class T> struct is_static_member_memoryPriority<T,typename enable_if<!is_same<__decltype(T::memoryPriority),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_memoryPriority: false_type { using type = void; }; template<class T> struct is_member_memoryPriority<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().memoryPriority),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().memoryPriority); }; } template<class T> struct has_member_memoryPriority { const static e_member_presence value = (e_member_presence)(impl::is_member_memoryPriority<T>::value + 2*impl::is_static_member_memoryPriority<T>::value + 4*is_const<typename impl::is_member_memoryPriority<T>::type>::value); }; template<class T, class F> struct has_member_memoryPriority_with_type : bool_constant<has_member_memoryPriority<T>::value && is_same<typename impl::is_member_memoryPriority<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentShaderSampleInterlock: false_type { }; template<class T> struct is_static_member_fragmentShaderSampleInterlock<T,typename enable_if<!is_same<__decltype(T::fragmentShaderSampleInterlock),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentShaderSampleInterlock: false_type { using type = void; }; template<class T> struct is_member_fragmentShaderSampleInterlock<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentShaderSampleInterlock),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentShaderSampleInterlock); }; } template<class T> struct has_member_fragmentShaderSampleInterlock { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentShaderSampleInterlock<T>::value + 2*impl::is_static_member_fragmentShaderSampleInterlock<T>::value + 4*is_const<typename impl::is_member_fragmentShaderSampleInterlock<T>::type>::value); }; template<class T, class F> struct has_member_fragmentShaderSampleInterlock_with_type : bool_constant<has_member_fragmentShaderSampleInterlock<T>::value && is_same<typename impl::is_member_fragmentShaderSampleInterlock<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentShaderPixelInterlock: false_type { }; template<class T> struct is_static_member_fragmentShaderPixelInterlock<T,typename enable_if<!is_same<__decltype(T::fragmentShaderPixelInterlock),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentShaderPixelInterlock: false_type { using type = void; }; template<class T> struct is_member_fragmentShaderPixelInterlock<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentShaderPixelInterlock),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentShaderPixelInterlock); }; } template<class T> struct has_member_fragmentShaderPixelInterlock { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentShaderPixelInterlock<T>::value + 2*impl::is_static_member_fragmentShaderPixelInterlock<T>::value + 4*is_const<typename impl::is_member_fragmentShaderPixelInterlock<T>::type>::value); }; template<class T, class F> struct has_member_fragmentShaderPixelInterlock_with_type : bool_constant<has_member_fragmentShaderPixelInterlock<T>::value && is_same<typename impl::is_member_fragmentShaderPixelInterlock<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentShaderShadingRateInterlock: false_type { }; template<class T> struct is_static_member_fragmentShaderShadingRateInterlock<T,typename enable_if<!is_same<__decltype(T::fragmentShaderShadingRateInterlock),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentShaderShadingRateInterlock: false_type { using type = void; }; template<class T> struct is_member_fragmentShaderShadingRateInterlock<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentShaderShadingRateInterlock),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentShaderShadingRateInterlock); }; } template<class T> struct has_member_fragmentShaderShadingRateInterlock { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentShaderShadingRateInterlock<T>::value + 2*impl::is_static_member_fragmentShaderShadingRateInterlock<T>::value + 4*is_const<typename impl::is_member_fragmentShaderShadingRateInterlock<T>::type>::value); }; template<class T, class F> struct has_member_fragmentShaderShadingRateInterlock_with_type : bool_constant<has_member_fragmentShaderShadingRateInterlock<T>::value && is_same<typename impl::is_member_fragmentShaderShadingRateInterlock<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rectangularLines: false_type { }; template<class T> struct is_static_member_rectangularLines<T,typename enable_if<!is_same<__decltype(T::rectangularLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rectangularLines: false_type { using type = void; }; template<class T> struct is_member_rectangularLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rectangularLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rectangularLines); }; } template<class T> struct has_member_rectangularLines { const static e_member_presence value = (e_member_presence)(impl::is_member_rectangularLines<T>::value + 2*impl::is_static_member_rectangularLines<T>::value + 4*is_const<typename impl::is_member_rectangularLines<T>::type>::value); }; template<class T, class F> struct has_member_rectangularLines_with_type : bool_constant<has_member_rectangularLines<T>::value && is_same<typename impl::is_member_rectangularLines<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_bresenhamLines: false_type { }; template<class T> struct is_static_member_bresenhamLines<T,typename enable_if<!is_same<__decltype(T::bresenhamLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_bresenhamLines: false_type { using type = void; }; template<class T> struct is_member_bresenhamLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().bresenhamLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().bresenhamLines); }; } template<class T> struct has_member_bresenhamLines { const static e_member_presence value = (e_member_presence)(impl::is_member_bresenhamLines<T>::value + 2*impl::is_static_member_bresenhamLines<T>::value + 4*is_const<typename impl::is_member_bresenhamLines<T>::type>::value); }; template<class T, class F> struct has_member_bresenhamLines_with_type : bool_constant<has_member_bresenhamLines<T>::value && is_same<typename impl::is_member_bresenhamLines<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_smoothLines: false_type { }; template<class T> struct is_static_member_smoothLines<T,typename enable_if<!is_same<__decltype(T::smoothLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_smoothLines: false_type { using type = void; }; template<class T> struct is_member_smoothLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().smoothLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().smoothLines); }; } template<class T> struct has_member_smoothLines { const static e_member_presence value = (e_member_presence)(impl::is_member_smoothLines<T>::value + 2*impl::is_static_member_smoothLines<T>::value + 4*is_const<typename impl::is_member_smoothLines<T>::type>::value); }; template<class T, class F> struct has_member_smoothLines_with_type : bool_constant<has_member_smoothLines<T>::value && is_same<typename impl::is_member_smoothLines<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_stippledRectangularLines: false_type { }; template<class T> struct is_static_member_stippledRectangularLines<T,typename enable_if<!is_same<__decltype(T::stippledRectangularLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_stippledRectangularLines: false_type { using type = void; }; template<class T> struct is_member_stippledRectangularLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().stippledRectangularLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().stippledRectangularLines); }; } template<class T> struct has_member_stippledRectangularLines { const static e_member_presence value = (e_member_presence)(impl::is_member_stippledRectangularLines<T>::value + 2*impl::is_static_member_stippledRectangularLines<T>::value + 4*is_const<typename impl::is_member_stippledRectangularLines<T>::type>::value); }; template<class T, class F> struct has_member_stippledRectangularLines_with_type : bool_constant<has_member_stippledRectangularLines<T>::value && is_same<typename impl::is_member_stippledRectangularLines<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_stippledBresenhamLines: false_type { }; template<class T> struct is_static_member_stippledBresenhamLines<T,typename enable_if<!is_same<__decltype(T::stippledBresenhamLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_stippledBresenhamLines: false_type { using type = void; }; template<class T> struct is_member_stippledBresenhamLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().stippledBresenhamLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().stippledBresenhamLines); }; } template<class T> struct has_member_stippledBresenhamLines { const static e_member_presence value = (e_member_presence)(impl::is_member_stippledBresenhamLines<T>::value + 2*impl::is_static_member_stippledBresenhamLines<T>::value + 4*is_const<typename impl::is_member_stippledBresenhamLines<T>::type>::value); }; template<class T, class F> struct has_member_stippledBresenhamLines_with_type : bool_constant<has_member_stippledBresenhamLines<T>::value && is_same<typename impl::is_member_stippledBresenhamLines<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_stippledSmoothLines: false_type { }; template<class T> struct is_static_member_stippledSmoothLines<T,typename enable_if<!is_same<__decltype(T::stippledSmoothLines),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_stippledSmoothLines: false_type { using type = void; }; template<class T> struct is_member_stippledSmoothLines<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().stippledSmoothLines),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().stippledSmoothLines); }; } template<class T> struct has_member_stippledSmoothLines { const static e_member_presence value = (e_member_presence)(impl::is_member_stippledSmoothLines<T>::value + 2*impl::is_static_member_stippledSmoothLines<T>::value + 4*is_const<typename impl::is_member_stippledSmoothLines<T>::type>::value); }; template<class T, class F> struct has_member_stippledSmoothLines_with_type : bool_constant<has_member_stippledSmoothLines<T>::value && is_same<typename impl::is_member_stippledSmoothLines<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_indexTypeUint8: false_type { }; template<class T> struct is_static_member_indexTypeUint8<T,typename enable_if<!is_same<__decltype(T::indexTypeUint8),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_indexTypeUint8: false_type { using type = void; }; template<class T> struct is_member_indexTypeUint8<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().indexTypeUint8),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().indexTypeUint8); }; } template<class T> struct has_member_indexTypeUint8 { const static e_member_presence value = (e_member_presence)(impl::is_member_indexTypeUint8<T>::value + 2*impl::is_static_member_indexTypeUint8<T>::value + 4*is_const<typename impl::is_member_indexTypeUint8<T>::type>::value); }; template<class T, class F> struct has_member_indexTypeUint8_with_type : bool_constant<has_member_indexTypeUint8<T>::value && is_same<typename impl::is_member_indexTypeUint8<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_deferredHostOperations: false_type { }; template<class T> struct is_static_member_deferredHostOperations<T,typename enable_if<!is_same<__decltype(T::deferredHostOperations),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_deferredHostOperations: false_type { using type = void; }; template<class T> struct is_member_deferredHostOperations<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().deferredHostOperations),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().deferredHostOperations); }; } template<class T> struct has_member_deferredHostOperations { const static e_member_presence value = (e_member_presence)(impl::is_member_deferredHostOperations<T>::value + 2*impl::is_static_member_deferredHostOperations<T>::value + 4*is_const<typename impl::is_member_deferredHostOperations<T>::type>::value); }; template<class T, class F> struct has_member_deferredHostOperations_with_type : bool_constant<has_member_deferredHostOperations<T>::value && is_same<typename impl::is_member_deferredHostOperations<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_pipelineExecutableInfo: false_type { }; template<class T> struct is_static_member_pipelineExecutableInfo<T,typename enable_if<!is_same<__decltype(T::pipelineExecutableInfo),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_pipelineExecutableInfo: false_type { using type = void; }; template<class T> struct is_member_pipelineExecutableInfo<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().pipelineExecutableInfo),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().pipelineExecutableInfo); }; } template<class T> struct has_member_pipelineExecutableInfo { const static e_member_presence value = (e_member_presence)(impl::is_member_pipelineExecutableInfo<T>::value + 2*impl::is_static_member_pipelineExecutableInfo<T>::value + 4*is_const<typename impl::is_member_pipelineExecutableInfo<T>::type>::value); }; template<class T, class F> struct has_member_pipelineExecutableInfo_with_type : bool_constant<has_member_pipelineExecutableInfo<T>::value && is_same<typename impl::is_member_pipelineExecutableInfo<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_deviceGeneratedCommands: false_type { }; template<class T> struct is_static_member_deviceGeneratedCommands<T,typename enable_if<!is_same<__decltype(T::deviceGeneratedCommands),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_deviceGeneratedCommands: false_type { using type = void; }; template<class T> struct is_member_deviceGeneratedCommands<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().deviceGeneratedCommands),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().deviceGeneratedCommands); }; } template<class T> struct has_member_deviceGeneratedCommands { const static e_member_presence value = (e_member_presence)(impl::is_member_deviceGeneratedCommands<T>::value + 2*impl::is_static_member_deviceGeneratedCommands<T>::value + 4*is_const<typename impl::is_member_deviceGeneratedCommands<T>::type>::value); }; template<class T, class F> struct has_member_deviceGeneratedCommands_with_type : bool_constant<has_member_deviceGeneratedCommands<T>::value && is_same<typename impl::is_member_deviceGeneratedCommands<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rayTracingMotionBlur: false_type { }; template<class T> struct is_static_member_rayTracingMotionBlur<T,typename enable_if<!is_same<__decltype(T::rayTracingMotionBlur),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rayTracingMotionBlur: false_type { using type = void; }; template<class T> struct is_member_rayTracingMotionBlur<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rayTracingMotionBlur),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rayTracingMotionBlur); }; } template<class T> struct has_member_rayTracingMotionBlur { const static e_member_presence value = (e_member_presence)(impl::is_member_rayTracingMotionBlur<T>::value + 2*impl::is_static_member_rayTracingMotionBlur<T>::value + 4*is_const<typename impl::is_member_rayTracingMotionBlur<T>::type>::value); }; template<class T, class F> struct has_member_rayTracingMotionBlur_with_type : bool_constant<has_member_rayTracingMotionBlur<T>::value && is_same<typename impl::is_member_rayTracingMotionBlur<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rayTracingMotionBlurPipelineTraceRaysIndirect: false_type { }; template<class T> struct is_static_member_rayTracingMotionBlurPipelineTraceRaysIndirect<T,typename enable_if<!is_same<__decltype(T::rayTracingMotionBlurPipelineTraceRaysIndirect),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rayTracingMotionBlurPipelineTraceRaysIndirect: false_type { using type = void; }; template<class T> struct is_member_rayTracingMotionBlurPipelineTraceRaysIndirect<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rayTracingMotionBlurPipelineTraceRaysIndirect),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rayTracingMotionBlurPipelineTraceRaysIndirect); }; } template<class T> struct has_member_rayTracingMotionBlurPipelineTraceRaysIndirect { const static e_member_presence value = (e_member_presence)(impl::is_member_rayTracingMotionBlurPipelineTraceRaysIndirect<T>::value + 2*impl::is_static_member_rayTracingMotionBlurPipelineTraceRaysIndirect<T>::value + 4*is_const<typename impl::is_member_rayTracingMotionBlurPipelineTraceRaysIndirect<T>::type>::value); }; template<class T, class F> struct has_member_rayTracingMotionBlurPipelineTraceRaysIndirect_with_type : bool_constant<has_member_rayTracingMotionBlurPipelineTraceRaysIndirect<T>::value && is_same<typename impl::is_member_rayTracingMotionBlurPipelineTraceRaysIndirect<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_fragmentDensityMapDeferred: false_type { }; template<class T> struct is_static_member_fragmentDensityMapDeferred<T,typename enable_if<!is_same<__decltype(T::fragmentDensityMapDeferred),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_fragmentDensityMapDeferred: false_type { using type = void; }; template<class T> struct is_member_fragmentDensityMapDeferred<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().fragmentDensityMapDeferred),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().fragmentDensityMapDeferred); }; } template<class T> struct has_member_fragmentDensityMapDeferred { const static e_member_presence value = (e_member_presence)(impl::is_member_fragmentDensityMapDeferred<T>::value + 2*impl::is_static_member_fragmentDensityMapDeferred<T>::value + 4*is_const<typename impl::is_member_fragmentDensityMapDeferred<T>::type>::value); }; template<class T, class F> struct has_member_fragmentDensityMapDeferred_with_type : bool_constant<has_member_fragmentDensityMapDeferred<T>::value && is_same<typename impl::is_member_fragmentDensityMapDeferred<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rasterizationOrderColorAttachmentAccess: false_type { }; template<class T> struct is_static_member_rasterizationOrderColorAttachmentAccess<T,typename enable_if<!is_same<__decltype(T::rasterizationOrderColorAttachmentAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rasterizationOrderColorAttachmentAccess: false_type { using type = void; }; template<class T> struct is_member_rasterizationOrderColorAttachmentAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rasterizationOrderColorAttachmentAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rasterizationOrderColorAttachmentAccess); }; } template<class T> struct has_member_rasterizationOrderColorAttachmentAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_rasterizationOrderColorAttachmentAccess<T>::value + 2*impl::is_static_member_rasterizationOrderColorAttachmentAccess<T>::value + 4*is_const<typename impl::is_member_rasterizationOrderColorAttachmentAccess<T>::type>::value); }; template<class T, class F> struct has_member_rasterizationOrderColorAttachmentAccess_with_type : bool_constant<has_member_rasterizationOrderColorAttachmentAccess<T>::value && is_same<typename impl::is_member_rasterizationOrderColorAttachmentAccess<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rasterizationOrderDepthAttachmentAccess: false_type { }; template<class T> struct is_static_member_rasterizationOrderDepthAttachmentAccess<T,typename enable_if<!is_same<__decltype(T::rasterizationOrderDepthAttachmentAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rasterizationOrderDepthAttachmentAccess: false_type { using type = void; }; template<class T> struct is_member_rasterizationOrderDepthAttachmentAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rasterizationOrderDepthAttachmentAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rasterizationOrderDepthAttachmentAccess); }; } template<class T> struct has_member_rasterizationOrderDepthAttachmentAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_rasterizationOrderDepthAttachmentAccess<T>::value + 2*impl::is_static_member_rasterizationOrderDepthAttachmentAccess<T>::value + 4*is_const<typename impl::is_member_rasterizationOrderDepthAttachmentAccess<T>::type>::value); }; template<class T, class F> struct has_member_rasterizationOrderDepthAttachmentAccess_with_type : bool_constant<has_member_rasterizationOrderDepthAttachmentAccess<T>::value && is_same<typename impl::is_member_rasterizationOrderDepthAttachmentAccess<T>::type, F>::value> {}; } };
namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_rasterizationOrderStencilAttachmentAccess: false_type { }; template<class T> struct is_static_member_rasterizationOrderStencilAttachmentAccess<T,typename enable_if<!is_same<__decltype(T::rasterizationOrderStencilAttachmentAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_rasterizationOrderStencilAttachmentAccess: false_type { using type = void; }; template<class T> struct is_member_rasterizationOrderStencilAttachmentAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().rasterizationOrderStencilAttachmentAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().rasterizationOrderStencilAttachmentAccess); }; } template<class T> struct has_member_rasterizationOrderStencilAttachmentAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_rasterizationOrderStencilAttachmentAccess<T>::value + 2*impl::is_static_member_rasterizationOrderStencilAttachmentAccess<T>::value + 4*is_const<typename impl::is_member_rasterizationOrderStencilAttachmentAccess<T>::type>::value); }; template<class T, class F> struct has_member_rasterizationOrderStencilAttachmentAccess_with_type : bool_constant<has_member_rasterizationOrderStencilAttachmentAccess<T>::value && is_same<typename impl::is_member_rasterizationOrderStencilAttachmentAccess<T>::type, F>::value> {}; } };

namespace nbl { namespace hlsl { namespace impl { template<class T, class=void> struct is_static_member_cooperativeMatrixRobustBufferAccess: false_type { }; template<class T> struct is_static_member_cooperativeMatrixRobustBufferAccess<T,typename enable_if<!is_same<__decltype(T::cooperativeMatrixRobustBufferAccess),void>::value,void>::type> : true_type { }; template<class T, class=void> struct is_member_cooperativeMatrixRobustBufferAccess: false_type { using type = void; }; template<class T> struct is_member_cooperativeMatrixRobustBufferAccess<T,typename enable_if<!is_same<__decltype(experimental::declval<T>().cooperativeMatrixRobustBufferAccess),void>::value,void>::type> : true_type { using type = __decltype(experimental::declval<T>().cooperativeMatrixRobustBufferAccess); }; } template<class T> struct has_member_cooperativeMatrixRobustBufferAccess { const static e_member_presence value = (e_member_presence)(impl::is_member_cooperativeMatrixRobustBufferAccess<T>::value + 2*impl::is_static_member_cooperativeMatrixRobustBufferAccess<T>::value + 4*is_const<typename impl::is_member_cooperativeMatrixRobustBufferAccess<T>::type>::value); }; template<class T, class F> struct has_member_cooperativeMatrixRobustBufferAccess_with_type : bool_constant<has_member_cooperativeMatrixRobustBufferAccess<T>::value && is_same<typename impl::is_member_cooperativeMatrixRobustBufferAccess<T>::type, F>::value> {}; } };

// Nabla

#line 15 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/device_capabilities_traits.hlsl"
// TODO: has_member_ has to be improved. It should be detecting present, static and constant

#line 20 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/device_capabilities_traits.hlsl"
namespace nbl
{
namespace hlsl
{

namespace impl
{
#line 1 "C:/Users/fjlet/Desktop/Nabla/build/src/nbl/device/include/nbl/video/device_capabilities_traits_defaults.hlsl"
// constexprs
const static uint32_t MinMaxImageDimension2D = 1 << 14;
const static uint32_t MinMaxSSBOSize = (0x1u << 30u) - 4;
const static uint16_t MaxMaxPushConstantsSize = 256;
const static uint32_t MinMaxWorkgroupCount = 1 << 12;
const static uint32_t MinMaxWorkgroupInvocations = 256;
const static int32_t MinSubPixelInterpolationOffsetBits = 4;
const static uint16_t MinMaxColorAttachments = 8;

// Limits Defaults
// VK 1.0
template<typename S, bool = has_member_maxImageDimension1D<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxImageDimension1D : integral_constant< uint32_t,S::maxImageDimension1D> {}; template<typename S> struct get_or_default_maxImageDimension1D<S,false> : integral_constant< uint32_t, MinMaxImageDimension2D> {};;
template<typename S, bool = has_member_maxImageDimension2D<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxImageDimension2D : integral_constant< uint32_t,S::maxImageDimension2D> {}; template<typename S> struct get_or_default_maxImageDimension2D<S,false> : integral_constant< uint32_t, MinMaxImageDimension2D> {};;
template<typename S, bool = has_member_maxImageDimension3D<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxImageDimension3D : integral_constant< uint32_t,S::maxImageDimension3D> {}; template<typename S> struct get_or_default_maxImageDimension3D<S,false> : integral_constant< uint32_t, 1 << 11> {};;
template<typename S, bool = has_member_maxImageDimensionCube<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxImageDimensionCube : integral_constant< uint32_t,S::maxImageDimensionCube> {}; template<typename S> struct get_or_default_maxImageDimensionCube<S,false> : integral_constant< uint32_t, MinMaxImageDimension2D> {};;
template<typename S, bool = has_member_maxImageArrayLayers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxImageArrayLayers : integral_constant< uint32_t,S::maxImageArrayLayers> {}; template<typename S> struct get_or_default_maxImageArrayLayers<S,false> : integral_constant< uint32_t, 1 << 11> {};;
template<typename S, bool = has_member_maxBufferViewTexels<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxBufferViewTexels : integral_constant< uint32_t,S::maxBufferViewTexels> {}; template<typename S> struct get_or_default_maxBufferViewTexels<S,false> : integral_constant< uint32_t, 1u << 25> {};;
template<typename S, bool = has_member_maxUBOSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxUBOSize : integral_constant< uint32_t,S::maxUBOSize> {}; template<typename S> struct get_or_default_maxUBOSize<S,false> : integral_constant< uint32_t, 1u << 16> {};;
template<typename S, bool = has_member_maxSSBOSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSSBOSize : integral_constant< uint32_t,S::maxSSBOSize> {}; template<typename S> struct get_or_default_maxSSBOSize<S,false> : integral_constant< uint32_t, MinMaxSSBOSize> {};;
template<typename S, bool = has_member_maxPushConstantsSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPushConstantsSize : integral_constant< uint16_t,S::maxPushConstantsSize> {}; template<typename S> struct get_or_default_maxPushConstantsSize<S,false> : integral_constant< uint16_t, 128> {};;
template<typename S, bool = has_member_maxMemoryAllocationCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxMemoryAllocationCount : integral_constant< uint32_t,S::maxMemoryAllocationCount> {}; template<typename S> struct get_or_default_maxMemoryAllocationCount<S,false> : integral_constant< uint32_t, 1 << 12> {};;
template<typename S, bool = has_member_maxSamplerAllocationCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSamplerAllocationCount : integral_constant< uint32_t,S::maxSamplerAllocationCount> {}; template<typename S> struct get_or_default_maxSamplerAllocationCount<S,false> : integral_constant< uint32_t, (1u << 10u)> {};;
template<typename S, bool = has_member_bufferImageGranularity<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_bufferImageGranularity : integral_constant< uint32_t,S::bufferImageGranularity> {}; template<typename S> struct get_or_default_bufferImageGranularity<S,false> : integral_constant< uint32_t, 1u << 16> {};;

template<typename S, bool = has_member_maxPerStageDescriptorSamplers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorSamplers : integral_constant< uint32_t,S::maxPerStageDescriptorSamplers> {}; template<typename S> struct get_or_default_maxPerStageDescriptorSamplers<S,false> : integral_constant< uint32_t, 16> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUBOs : integral_constant< uint32_t,S::maxPerStageDescriptorUBOs> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUBOs<S,false> : integral_constant< uint32_t, 15> {};;
template<typename S, bool = has_member_maxPerStageDescriptorSSBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorSSBOs : integral_constant< uint32_t,S::maxPerStageDescriptorSSBOs> {}; template<typename S> struct get_or_default_maxPerStageDescriptorSSBOs<S,false> : integral_constant< uint32_t, 31> {};;
template<typename S, bool = has_member_maxPerStageDescriptorImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorImages : integral_constant< uint32_t,S::maxPerStageDescriptorImages> {}; template<typename S> struct get_or_default_maxPerStageDescriptorImages<S,false> : integral_constant< uint32_t, 96> {};;
template<typename S, bool = has_member_maxPerStageDescriptorStorageImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorStorageImages : integral_constant< uint32_t,S::maxPerStageDescriptorStorageImages> {}; template<typename S> struct get_or_default_maxPerStageDescriptorStorageImages<S,false> : integral_constant< uint32_t, 8> {};;
template<typename S, bool = has_member_maxPerStageDescriptorInputAttachments<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorInputAttachments : integral_constant< uint32_t,S::maxPerStageDescriptorInputAttachments> {}; template<typename S> struct get_or_default_maxPerStageDescriptorInputAttachments<S,false> : integral_constant< uint32_t, 7> {};;
template<typename S, bool = has_member_maxPerStageResources<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageResources : integral_constant< uint32_t,S::maxPerStageResources> {}; template<typename S> struct get_or_default_maxPerStageResources<S,false> : integral_constant< uint32_t, 127> {};;

template<typename S, bool = has_member_maxDescriptorSetSamplers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetSamplers : integral_constant< uint32_t,S::maxDescriptorSetSamplers> {}; template<typename S> struct get_or_default_maxDescriptorSetSamplers<S,false> : integral_constant< uint32_t, 80> {};;
template<typename S, bool = has_member_maxDescriptorSetUBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUBOs : integral_constant< uint32_t,S::maxDescriptorSetUBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetUBOs<S,false> : integral_constant< uint32_t, 155> {};;
template<typename S, bool = has_member_maxDescriptorSetDynamicOffsetUBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetDynamicOffsetUBOs : integral_constant< uint32_t,S::maxDescriptorSetDynamicOffsetUBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetDynamicOffsetUBOs<S,false> : integral_constant< uint32_t, 8> {};;
template<typename S, bool = has_member_maxDescriptorSetSSBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetSSBOs : integral_constant< uint32_t,S::maxDescriptorSetSSBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetSSBOs<S,false> : integral_constant< uint32_t, 155> {};;
template<typename S, bool = has_member_maxDescriptorSetDynamicOffsetSSBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetDynamicOffsetSSBOs : integral_constant< uint32_t,S::maxDescriptorSetDynamicOffsetSSBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetDynamicOffsetSSBOs<S,false> : integral_constant< uint32_t, 8> {};;
template<typename S, bool = has_member_maxDescriptorSetImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetImages : integral_constant< uint32_t,S::maxDescriptorSetImages> {}; template<typename S> struct get_or_default_maxDescriptorSetImages<S,false> : integral_constant< uint32_t, 480> {};;
template<typename S, bool = has_member_maxDescriptorSetStorageImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetStorageImages : integral_constant< uint32_t,S::maxDescriptorSetStorageImages> {}; template<typename S> struct get_or_default_maxDescriptorSetStorageImages<S,false> : integral_constant< uint32_t, 40> {};;
template<typename S, bool = has_member_maxDescriptorSetInputAttachments<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetInputAttachments : integral_constant< uint32_t,S::maxDescriptorSetInputAttachments> {}; template<typename S> struct get_or_default_maxDescriptorSetInputAttachments<S,false> : integral_constant< uint32_t, 7> {};;

template<typename S, bool = has_member_maxVertexOutputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxVertexOutputComponents : integral_constant< uint16_t,S::maxVertexOutputComponents> {}; template<typename S> struct get_or_default_maxVertexOutputComponents<S,false> : integral_constant< uint16_t, 124> {};;

template<typename S, bool = has_member_maxTessellationGenerationLevel<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationGenerationLevel : integral_constant< uint16_t,S::maxTessellationGenerationLevel> {}; template<typename S> struct get_or_default_maxTessellationGenerationLevel<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxTessellationPatchSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationPatchSize : integral_constant< uint16_t,S::maxTessellationPatchSize> {}; template<typename S> struct get_or_default_maxTessellationPatchSize<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxTessellationControlPerVertexInputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationControlPerVertexInputComponents : integral_constant< uint16_t,S::maxTessellationControlPerVertexInputComponents> {}; template<typename S> struct get_or_default_maxTessellationControlPerVertexInputComponents<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxTessellationControlPerVertexOutputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationControlPerVertexOutputComponents : integral_constant< uint16_t,S::maxTessellationControlPerVertexOutputComponents> {}; template<typename S> struct get_or_default_maxTessellationControlPerVertexOutputComponents<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxTessellationControlPerPatchOutputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationControlPerPatchOutputComponents : integral_constant< uint16_t,S::maxTessellationControlPerPatchOutputComponents> {}; template<typename S> struct get_or_default_maxTessellationControlPerPatchOutputComponents<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxTessellationControlTotalOutputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationControlTotalOutputComponents : integral_constant< uint16_t,S::maxTessellationControlTotalOutputComponents> {}; template<typename S> struct get_or_default_maxTessellationControlTotalOutputComponents<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxTessellationEvaluationInputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationEvaluationInputComponents : integral_constant< uint16_t,S::maxTessellationEvaluationInputComponents> {}; template<typename S> struct get_or_default_maxTessellationEvaluationInputComponents<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxTessellationEvaluationOutputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTessellationEvaluationOutputComponents : integral_constant< uint16_t,S::maxTessellationEvaluationOutputComponents> {}; template<typename S> struct get_or_default_maxTessellationEvaluationOutputComponents<S,false> : integral_constant< uint16_t, 0> {};;

template<typename S, bool = has_member_maxGeometryShaderInvocations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxGeometryShaderInvocations : integral_constant< uint16_t,S::maxGeometryShaderInvocations> {}; template<typename S> struct get_or_default_maxGeometryShaderInvocations<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxGeometryInputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxGeometryInputComponents : integral_constant< uint16_t,S::maxGeometryInputComponents> {}; template<typename S> struct get_or_default_maxGeometryInputComponents<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxGeometryOutputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxGeometryOutputComponents : integral_constant< uint16_t,S::maxGeometryOutputComponents> {}; template<typename S> struct get_or_default_maxGeometryOutputComponents<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxGeometryOutputVertices<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxGeometryOutputVertices : integral_constant< uint16_t,S::maxGeometryOutputVertices> {}; template<typename S> struct get_or_default_maxGeometryOutputVertices<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxGeometryTotalOutputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxGeometryTotalOutputComponents : integral_constant< uint16_t,S::maxGeometryTotalOutputComponents> {}; template<typename S> struct get_or_default_maxGeometryTotalOutputComponents<S,false> : integral_constant< uint16_t, 0> {};;

template<typename S, bool = has_member_maxFragmentInputComponents<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFragmentInputComponents : integral_constant< uint32_t,S::maxFragmentInputComponents> {}; template<typename S> struct get_or_default_maxFragmentInputComponents<S,false> : integral_constant< uint32_t, 116> {};;
template<typename S, bool = has_member_maxFragmentOutputAttachments<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFragmentOutputAttachments : integral_constant< uint32_t,S::maxFragmentOutputAttachments> {}; template<typename S> struct get_or_default_maxFragmentOutputAttachments<S,false> : integral_constant< uint32_t, 8> {};;
template<typename S, bool = has_member_maxFragmentDualSrcAttachments<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFragmentDualSrcAttachments : integral_constant< uint32_t,S::maxFragmentDualSrcAttachments> {}; template<typename S> struct get_or_default_maxFragmentDualSrcAttachments<S,false> : integral_constant< uint32_t, 1> {};;
template<typename S, bool = has_member_maxFragmentCombinedOutputResources<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFragmentCombinedOutputResources : integral_constant< uint32_t,S::maxFragmentCombinedOutputResources> {}; template<typename S> struct get_or_default_maxFragmentCombinedOutputResources<S,false> : integral_constant< uint32_t, 127> {};;

template<typename S, bool = has_member_maxComputeSharedMemorySize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxComputeSharedMemorySize : integral_constant< uint32_t,S::maxComputeSharedMemorySize> {}; template<typename S> struct get_or_default_maxComputeSharedMemorySize<S,false> : integral_constant< uint32_t, 1 << 15> {};;
template<typename S, bool = has_member_maxComputeWorkGroupCountX<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxComputeWorkGroupCountX : integral_constant< uint32_t,S::maxComputeWorkGroupCountX> {}; template<typename S> struct get_or_default_maxComputeWorkGroupCountX<S,false> : integral_constant< uint32_t, MinMaxWorkgroupCount> {};;
template<typename S, bool = has_member_maxComputeWorkGroupCountY<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxComputeWorkGroupCountY : integral_constant< uint32_t,S::maxComputeWorkGroupCountY> {}; template<typename S> struct get_or_default_maxComputeWorkGroupCountY<S,false> : integral_constant< uint32_t, MinMaxWorkgroupCount> {};;
template<typename S, bool = has_member_maxComputeWorkGroupCountZ<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxComputeWorkGroupCountZ : integral_constant< uint32_t,S::maxComputeWorkGroupCountZ> {}; template<typename S> struct get_or_default_maxComputeWorkGroupCountZ<S,false> : integral_constant< uint32_t, MinMaxWorkgroupCount> {};;
template<typename S, bool = has_member_maxComputeWorkGroupInvocations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxComputeWorkGroupInvocations : integral_constant< uint16_t,S::maxComputeWorkGroupInvocations> {}; template<typename S> struct get_or_default_maxComputeWorkGroupInvocations<S,false> : integral_constant< uint16_t, MinMaxWorkgroupInvocations> {};;
template<typename S, bool = has_member_maxWorkgroupSizeX<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxWorkgroupSizeX : integral_constant< uint16_t,S::maxWorkgroupSizeX> {}; template<typename S> struct get_or_default_maxWorkgroupSizeX<S,false> : integral_constant< uint16_t, MinMaxWorkgroupInvocations> {};;
template<typename S, bool = has_member_maxWorkgroupSizeY<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxWorkgroupSizeY : integral_constant< uint16_t,S::maxWorkgroupSizeY> {}; template<typename S> struct get_or_default_maxWorkgroupSizeY<S,false> : integral_constant< uint16_t, MinMaxWorkgroupInvocations> {};;
template<typename S, bool = has_member_maxWorkgroupSizeZ<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxWorkgroupSizeZ : integral_constant< uint16_t,S::maxWorkgroupSizeZ> {}; template<typename S> struct get_or_default_maxWorkgroupSizeZ<S,false> : integral_constant< uint16_t, 64u> {};;

template<typename S, bool = has_member_subPixelPrecisionBits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_subPixelPrecisionBits : integral_constant< uint16_t,S::subPixelPrecisionBits> {}; template<typename S> struct get_or_default_subPixelPrecisionBits<S,false> : integral_constant< uint16_t, 4> {};;
template<typename S, bool = has_member_subTexelPrecisionBits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_subTexelPrecisionBits : integral_constant< uint16_t,S::subTexelPrecisionBits> {}; template<typename S> struct get_or_default_subTexelPrecisionBits<S,false> : integral_constant< uint16_t, 4> {};;
template<typename S, bool = has_member_mipmapPrecisionBits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_mipmapPrecisionBits : integral_constant< uint16_t,S::mipmapPrecisionBits> {}; template<typename S> struct get_or_default_mipmapPrecisionBits<S,false> : integral_constant< uint16_t, 4> {};;

template<typename S, bool = has_member_maxDrawIndirectCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDrawIndirectCount : integral_constant< uint32_t,S::maxDrawIndirectCount> {}; template<typename S> struct get_or_default_maxDrawIndirectCount<S,false> : integral_constant< uint32_t, 0x1u << 30> {};;

template<typename S, bool = has_member_maxSamplerLodBiasBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSamplerLodBiasBitPattern : integral_constant< uint32_t,S::maxSamplerLodBiasBitPattern> {}; template<typename S> struct get_or_default_maxSamplerLodBiasBitPattern<S,false> : integral_constant< uint32_t, asuint(4.f)> {};;
template<typename S, bool = has_member_maxSamplerAnisotropyLog2<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSamplerAnisotropyLog2 : integral_constant< uint16_t,S::maxSamplerAnisotropyLog2> {}; template<typename S> struct get_or_default_maxSamplerAnisotropyLog2<S,false> : integral_constant< uint16_t, 4> {};;

template<typename S, bool = has_member_maxViewports<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxViewports : integral_constant< uint16_t,S::maxViewports> {}; template<typename S> struct get_or_default_maxViewports<S,false> : integral_constant< uint16_t, 16> {};;
template<typename S, bool = has_member_maxViewportDimsX<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxViewportDimsX : integral_constant< uint16_t,S::maxViewportDimsX> {}; template<typename S> struct get_or_default_maxViewportDimsX<S,false> : integral_constant< uint16_t, MinMaxImageDimension2D> {};;
template<typename S, bool = has_member_maxViewportDimsY<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxViewportDimsY : integral_constant< uint16_t,S::maxViewportDimsY> {}; template<typename S> struct get_or_default_maxViewportDimsY<S,false> : integral_constant< uint16_t, MinMaxImageDimension2D> {};;
template<typename S, bool = has_member_viewportBoundsRangeBitPatternMin<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_viewportBoundsRangeBitPatternMin : integral_constant< uint32_t,S::viewportBoundsRangeBitPatternMin> {}; template<typename S> struct get_or_default_viewportBoundsRangeBitPatternMin<S,false> : integral_constant< uint32_t, asuint(-MinMaxImageDimension2D*2u)> {};;
template<typename S, bool = has_member_viewportBoundsRangeBitPatternMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_viewportBoundsRangeBitPatternMax : integral_constant< uint32_t,S::viewportBoundsRangeBitPatternMax> {}; template<typename S> struct get_or_default_viewportBoundsRangeBitPatternMax<S,false> : integral_constant< uint32_t, asuint(MinMaxImageDimension2D*2u-1)> {};;
template<typename S, bool = has_member_viewportSubPixelBits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_viewportSubPixelBits : integral_constant< uint32_t,S::viewportSubPixelBits> {}; template<typename S> struct get_or_default_viewportSubPixelBits<S,false> : integral_constant< uint32_t, 0> {};;

template<typename S, bool = has_member_minMemoryMapAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minMemoryMapAlignment : integral_constant< uint16_t,S::minMemoryMapAlignment> {}; template<typename S> struct get_or_default_minMemoryMapAlignment<S,false> : integral_constant< uint16_t, 64> {};;
template<typename S, bool = has_member_bufferViewAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_bufferViewAlignment : integral_constant< uint16_t,S::bufferViewAlignment> {}; template<typename S> struct get_or_default_bufferViewAlignment<S,false> : integral_constant< uint16_t, 64> {};;
template<typename S, bool = has_member_minUBOAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minUBOAlignment : integral_constant< uint16_t,S::minUBOAlignment> {}; template<typename S> struct get_or_default_minUBOAlignment<S,false> : integral_constant< uint16_t, 256> {};;
template<typename S, bool = has_member_minSSBOAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minSSBOAlignment : integral_constant< uint16_t,S::minSSBOAlignment> {}; template<typename S> struct get_or_default_minSSBOAlignment<S,false> : integral_constant< uint16_t, 64> {};;

template<typename S, bool = has_member_minTexelOffset<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minTexelOffset : integral_constant< int16_t,S::minTexelOffset> {}; template<typename S> struct get_or_default_minTexelOffset<S,false> : integral_constant< int16_t, -8> {};;
template<typename S, bool = has_member_maxTexelOffset<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTexelOffset : integral_constant< uint16_t,S::maxTexelOffset> {}; template<typename S> struct get_or_default_maxTexelOffset<S,false> : integral_constant< uint16_t, 7> {};;
template<typename S, bool = has_member_minTexelGatherOffset<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minTexelGatherOffset : integral_constant< int16_t,S::minTexelGatherOffset> {}; template<typename S> struct get_or_default_minTexelGatherOffset<S,false> : integral_constant< int16_t, -8> {};;
template<typename S, bool = has_member_maxTexelGatherOffset<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxTexelGatherOffset : integral_constant< uint16_t,S::maxTexelGatherOffset> {}; template<typename S> struct get_or_default_maxTexelGatherOffset<S,false> : integral_constant< uint16_t, 7> {};;

template<typename S, bool = has_member_minInterpolationOffsetBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minInterpolationOffsetBitPattern : integral_constant< uint32_t,S::minInterpolationOffsetBitPattern> {}; template<typename S> struct get_or_default_minInterpolationOffsetBitPattern<S,false> : integral_constant< uint32_t, asuint(-0.5f)> {};;
template<typename S, bool = has_member_maxInterpolationOffsetBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxInterpolationOffsetBitPattern : integral_constant< uint32_t,S::maxInterpolationOffsetBitPattern> {}; template<typename S> struct get_or_default_maxInterpolationOffsetBitPattern<S,false> : integral_constant< uint32_t, asuint(0.4375)> {};;
template<typename S, bool = has_member_subPixelInterpolationOffsetBits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_subPixelInterpolationOffsetBits : integral_constant< uint16_t,S::subPixelInterpolationOffsetBits> {}; template<typename S> struct get_or_default_subPixelInterpolationOffsetBits<S,false> : integral_constant< uint16_t, MinSubPixelInterpolationOffsetBits> {};;

template<typename S, bool = has_member_maxFramebufferWidth<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFramebufferWidth : integral_constant< uint32_t,S::maxFramebufferWidth> {}; template<typename S> struct get_or_default_maxFramebufferWidth<S,false> : integral_constant< uint32_t, MinMaxImageDimension2D> {};;
template<typename S, bool = has_member_maxFramebufferHeight<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFramebufferHeight : integral_constant< uint32_t,S::maxFramebufferHeight> {}; template<typename S> struct get_or_default_maxFramebufferHeight<S,false> : integral_constant< uint32_t, MinMaxImageDimension2D> {};;
template<typename S, bool = has_member_maxFramebufferLayers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFramebufferLayers : integral_constant< uint32_t,S::maxFramebufferLayers> {}; template<typename S> struct get_or_default_maxFramebufferLayers<S,false> : integral_constant< uint32_t, 1 << 10> {};;

template<typename S, bool = has_member_maxColorAttachments<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxColorAttachments : integral_constant< uint16_t,S::maxColorAttachments> {}; template<typename S> struct get_or_default_maxColorAttachments<S,false> : integral_constant< uint16_t, MinMaxColorAttachments> {};;

template<typename S, bool = has_member_maxSampleMaskWords<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSampleMaskWords : integral_constant< uint16_t,S::maxSampleMaskWords> {}; template<typename S> struct get_or_default_maxSampleMaskWords<S,false> : integral_constant< uint16_t, 1> {};;

template<typename S, bool = has_member_timestampPeriodInNanoSecondsBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_timestampPeriodInNanoSecondsBitPattern : integral_constant< uint32_t,S::timestampPeriodInNanoSecondsBitPattern> {}; template<typename S> struct get_or_default_timestampPeriodInNanoSecondsBitPattern<S,false> : integral_constant< uint32_t, asuint(83.334f)> {};;

template<typename S, bool = has_member_maxClipDistances<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxClipDistances : integral_constant< uint16_t,S::maxClipDistances> {}; template<typename S> struct get_or_default_maxClipDistances<S,false> : integral_constant< uint16_t, 8> {};;
template<typename S, bool = has_member_maxCullDistances<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxCullDistances : integral_constant< uint16_t,S::maxCullDistances> {}; template<typename S> struct get_or_default_maxCullDistances<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_maxCombinedClipAndCullDistances<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxCombinedClipAndCullDistances : integral_constant< uint16_t,S::maxCombinedClipAndCullDistances> {}; template<typename S> struct get_or_default_maxCombinedClipAndCullDistances<S,false> : integral_constant< uint16_t, 8> {};;

template<typename S, bool = has_member_discreteQueuePriorities<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_discreteQueuePriorities : integral_constant< uint32_t,S::discreteQueuePriorities> {}; template<typename S> struct get_or_default_discreteQueuePriorities<S,false> : integral_constant< uint32_t, 2> {};;

template<typename S, bool = has_member_pointSizeRangeBitPatternMin<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pointSizeRangeBitPatternMin : integral_constant< uint32_t,S::pointSizeRangeBitPatternMin> {}; template<typename S> struct get_or_default_pointSizeRangeBitPatternMin<S,false> : integral_constant< uint32_t, asuint(1.f)> {};;
template<typename S, bool = has_member_pointSizeRangeBitPatternMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pointSizeRangeBitPatternMax : integral_constant< uint32_t,S::pointSizeRangeBitPatternMax> {}; template<typename S> struct get_or_default_pointSizeRangeBitPatternMax<S,false> : integral_constant< uint32_t, asuint(255.875f)> {};;
template<typename S, bool = has_member_lineWidthRangeBitPatternMin<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_lineWidthRangeBitPatternMin : integral_constant< uint32_t,S::lineWidthRangeBitPatternMin> {}; template<typename S> struct get_or_default_lineWidthRangeBitPatternMin<S,false> : integral_constant< uint32_t, asuint(1.f)> {};;
template<typename S, bool = has_member_lineWidthRangeBitPatternMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_lineWidthRangeBitPatternMax : integral_constant< uint32_t,S::lineWidthRangeBitPatternMax> {}; template<typename S> struct get_or_default_lineWidthRangeBitPatternMax<S,false> : integral_constant< uint32_t, asuint(1.f)> {};;
template<typename S, bool = has_member_pointSizeGranularityBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pointSizeGranularityBitPattern : integral_constant< uint32_t,S::pointSizeGranularityBitPattern> {}; template<typename S> struct get_or_default_pointSizeGranularityBitPattern<S,false> : integral_constant< uint32_t, asuint(1.f)> {};;
template<typename S, bool = has_member_lineWidthGranularityBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_lineWidthGranularityBitPattern : integral_constant< uint32_t,S::lineWidthGranularityBitPattern> {}; template<typename S> struct get_or_default_lineWidthGranularityBitPattern<S,false> : integral_constant< uint32_t, asuint(0.125f)> {};;

template<typename S, bool = has_member_strictLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_strictLines : integral_constant< bool,S::strictLines> {}; template<typename S> struct get_or_default_strictLines<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_standardSampleLocations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_standardSampleLocations : integral_constant< bool,S::standardSampleLocations> {}; template<typename S> struct get_or_default_standardSampleLocations<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_optimalBufferCopyOffsetAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_optimalBufferCopyOffsetAlignment : integral_constant< uint16_t,S::optimalBufferCopyOffsetAlignment> {}; template<typename S> struct get_or_default_optimalBufferCopyOffsetAlignment<S,false> : integral_constant< uint16_t, 128> {};;
template<typename S, bool = has_member_optimalBufferCopyRowPitchAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_optimalBufferCopyRowPitchAlignment : integral_constant< uint16_t,S::optimalBufferCopyRowPitchAlignment> {}; template<typename S> struct get_or_default_optimalBufferCopyRowPitchAlignment<S,false> : integral_constant< uint16_t, 128> {};;
template<typename S, bool = has_member_nonCoherentAtomSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_nonCoherentAtomSize : integral_constant< uint16_t,S::nonCoherentAtomSize> {}; template<typename S> struct get_or_default_nonCoherentAtomSize<S,false> : integral_constant< uint16_t, 128> {};;

// VK 1.1
template<typename S, bool = has_member_subgroupSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_subgroupSize : integral_constant< uint16_t,S::subgroupSize> {}; template<typename S> struct get_or_default_subgroupSize<S,false> : integral_constant< uint16_t, 4> {};;
template<typename S, bool = has_member_subgroupOpsShaderStagesBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_subgroupOpsShaderStagesBitPattern : integral_constant< uint64_t,S::subgroupOpsShaderStagesBitPattern> {}; template<typename S> struct get_or_default_subgroupOpsShaderStagesBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::ShaderStage::ESS_COMPUTE | nbl::hlsl::ShaderStage::ESS_ALL_GRAPHICS> {};;
template<typename S, bool = has_member_shaderSubgroupClustered<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSubgroupClustered : integral_constant< bool,S::shaderSubgroupClustered> {}; template<typename S> struct get_or_default_shaderSubgroupClustered<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSubgroupArithmetic<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSubgroupArithmetic : integral_constant< bool,S::shaderSubgroupArithmetic> {}; template<typename S> struct get_or_default_shaderSubgroupArithmetic<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSubgroupQuad<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSubgroupQuad : integral_constant< bool,S::shaderSubgroupQuad> {}; template<typename S> struct get_or_default_shaderSubgroupQuad<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSubgroupQuadAllStages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSubgroupQuadAllStages : integral_constant< bool,S::shaderSubgroupQuadAllStages> {}; template<typename S> struct get_or_default_shaderSubgroupQuadAllStages<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_pointClippingBehaviorBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pointClippingBehaviorBitPattern : integral_constant< uint64_t,S::pointClippingBehaviorBitPattern> {}; template<typename S> struct get_or_default_pointClippingBehaviorBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::PointClippingBehavior::EPCB_USER_CLIP_PLANES_ONLY> {};;

template<typename S, bool = has_member_maxMultiviewViewCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxMultiviewViewCount : integral_constant< uint16_t,S::maxMultiviewViewCount> {}; template<typename S> struct get_or_default_maxMultiviewViewCount<S,false> : integral_constant< uint16_t, 6> {};;
template<typename S, bool = has_member_maxMultiviewInstanceIndex<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxMultiviewInstanceIndex : integral_constant< uint32_t,S::maxMultiviewInstanceIndex> {}; template<typename S> struct get_or_default_maxMultiviewInstanceIndex<S,false> : integral_constant< uint32_t, (1u << 27) - 1> {};;

template<typename S, bool = has_member_maxPerSetDescriptors<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerSetDescriptors : integral_constant< uint32_t,S::maxPerSetDescriptors> {}; template<typename S> struct get_or_default_maxPerSetDescriptors<S,false> : integral_constant< uint32_t, 1024> {};;
template<typename S, bool = has_member_maxMemoryAllocationSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxMemoryAllocationSize : integral_constant< uint64_t,S::maxMemoryAllocationSize> {}; template<typename S> struct get_or_default_maxMemoryAllocationSize<S,false> : integral_constant< uint64_t, MinMaxSSBOSize*2> {};;

// VK 1.2
template<typename S, bool = has_member_shaderSignedZeroInfNanPreserveFloat64<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSignedZeroInfNanPreserveFloat64 : integral_constant< bool,S::shaderSignedZeroInfNanPreserveFloat64> {}; template<typename S> struct get_or_default_shaderSignedZeroInfNanPreserveFloat64<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDenormPreserveFloat16<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDenormPreserveFloat16 : integral_constant< bool,S::shaderDenormPreserveFloat16> {}; template<typename S> struct get_or_default_shaderDenormPreserveFloat16<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDenormPreserveFloat32<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDenormPreserveFloat32 : integral_constant< bool,S::shaderDenormPreserveFloat32> {}; template<typename S> struct get_or_default_shaderDenormPreserveFloat32<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDenormPreserveFloat64<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDenormPreserveFloat64 : integral_constant< bool,S::shaderDenormPreserveFloat64> {}; template<typename S> struct get_or_default_shaderDenormPreserveFloat64<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDenormFlushToZeroFloat16<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDenormFlushToZeroFloat16 : integral_constant< bool,S::shaderDenormFlushToZeroFloat16> {}; template<typename S> struct get_or_default_shaderDenormFlushToZeroFloat16<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDenormFlushToZeroFloat32<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDenormFlushToZeroFloat32 : integral_constant< bool,S::shaderDenormFlushToZeroFloat32> {}; template<typename S> struct get_or_default_shaderDenormFlushToZeroFloat32<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDenormFlushToZeroFloat64<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDenormFlushToZeroFloat64 : integral_constant< bool,S::shaderDenormFlushToZeroFloat64> {}; template<typename S> struct get_or_default_shaderDenormFlushToZeroFloat64<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderRoundingModeRTEFloat16<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderRoundingModeRTEFloat16 : integral_constant< bool,S::shaderRoundingModeRTEFloat16> {}; template<typename S> struct get_or_default_shaderRoundingModeRTEFloat16<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderRoundingModeRTEFloat32<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderRoundingModeRTEFloat32 : integral_constant< bool,S::shaderRoundingModeRTEFloat32> {}; template<typename S> struct get_or_default_shaderRoundingModeRTEFloat32<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderRoundingModeRTEFloat64<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderRoundingModeRTEFloat64 : integral_constant< bool,S::shaderRoundingModeRTEFloat64> {}; template<typename S> struct get_or_default_shaderRoundingModeRTEFloat64<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderRoundingModeRTZFloat16<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderRoundingModeRTZFloat16 : integral_constant< bool,S::shaderRoundingModeRTZFloat16> {}; template<typename S> struct get_or_default_shaderRoundingModeRTZFloat16<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderRoundingModeRTZFloat32<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderRoundingModeRTZFloat32 : integral_constant< bool,S::shaderRoundingModeRTZFloat32> {}; template<typename S> struct get_or_default_shaderRoundingModeRTZFloat32<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderRoundingModeRTZFloat64<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderRoundingModeRTZFloat64 : integral_constant< bool,S::shaderRoundingModeRTZFloat64> {}; template<typename S> struct get_or_default_shaderRoundingModeRTZFloat64<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_maxUpdateAfterBindDescriptorsInAllPools<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxUpdateAfterBindDescriptorsInAllPools : integral_constant< uint32_t,S::maxUpdateAfterBindDescriptorsInAllPools> {}; template<typename S> struct get_or_default_maxUpdateAfterBindDescriptorsInAllPools<S,false> : integral_constant< uint32_t, 0x1u << 20> {};;
template<typename S, bool = has_member_shaderUniformBufferArrayNonUniformIndexingNative<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderUniformBufferArrayNonUniformIndexingNative : integral_constant< bool,S::shaderUniformBufferArrayNonUniformIndexingNative> {}; template<typename S> struct get_or_default_shaderUniformBufferArrayNonUniformIndexingNative<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSampledImageArrayNonUniformIndexingNative<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSampledImageArrayNonUniformIndexingNative : integral_constant< bool,S::shaderSampledImageArrayNonUniformIndexingNative> {}; template<typename S> struct get_or_default_shaderSampledImageArrayNonUniformIndexingNative<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderStorageBufferArrayNonUniformIndexingNative<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderStorageBufferArrayNonUniformIndexingNative : integral_constant< bool,S::shaderStorageBufferArrayNonUniformIndexingNative> {}; template<typename S> struct get_or_default_shaderStorageBufferArrayNonUniformIndexingNative<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderStorageImageArrayNonUniformIndexingNative<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderStorageImageArrayNonUniformIndexingNative : integral_constant< bool,S::shaderStorageImageArrayNonUniformIndexingNative> {}; template<typename S> struct get_or_default_shaderStorageImageArrayNonUniformIndexingNative<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderInputAttachmentArrayNonUniformIndexingNative<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderInputAttachmentArrayNonUniformIndexingNative : integral_constant< bool,S::shaderInputAttachmentArrayNonUniformIndexingNative> {}; template<typename S> struct get_or_default_shaderInputAttachmentArrayNonUniformIndexingNative<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_robustBufferAccessUpdateAfterBind<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_robustBufferAccessUpdateAfterBind : integral_constant< bool,S::robustBufferAccessUpdateAfterBind> {}; template<typename S> struct get_or_default_robustBufferAccessUpdateAfterBind<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_quadDivergentImplicitLod<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_quadDivergentImplicitLod : integral_constant< bool,S::quadDivergentImplicitLod> {}; template<typename S> struct get_or_default_quadDivergentImplicitLod<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUpdateAfterBindSamplers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUpdateAfterBindSamplers : integral_constant< uint32_t,S::maxPerStageDescriptorUpdateAfterBindSamplers> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUpdateAfterBindSamplers<S,false> : integral_constant< uint32_t, 1 << 10> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUpdateAfterBindUBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUpdateAfterBindUBOs : integral_constant< uint32_t,S::maxPerStageDescriptorUpdateAfterBindUBOs> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUpdateAfterBindUBOs<S,false> : integral_constant< uint32_t, 15> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUpdateAfterBindSSBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUpdateAfterBindSSBOs : integral_constant< uint32_t,S::maxPerStageDescriptorUpdateAfterBindSSBOs> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUpdateAfterBindSSBOs<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUpdateAfterBindImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUpdateAfterBindImages : integral_constant< uint32_t,S::maxPerStageDescriptorUpdateAfterBindImages> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUpdateAfterBindImages<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUpdateAfterBindStorageImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUpdateAfterBindStorageImages : integral_constant< uint32_t,S::maxPerStageDescriptorUpdateAfterBindStorageImages> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUpdateAfterBindStorageImages<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUpdateAfterBindInputAttachments<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUpdateAfterBindInputAttachments : integral_constant< uint32_t,S::maxPerStageDescriptorUpdateAfterBindInputAttachments> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUpdateAfterBindInputAttachments<S,false> : integral_constant< uint32_t, MinMaxColorAttachments> {};;
template<typename S, bool = has_member_maxPerStageUpdateAfterBindResources<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageUpdateAfterBindResources : integral_constant< uint32_t,S::maxPerStageUpdateAfterBindResources> {}; template<typename S> struct get_or_default_maxPerStageUpdateAfterBindResources<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindSamplers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindSamplers : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindSamplers> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindSamplers<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindUBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindUBOs : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindUBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindUBOs<S,false> : integral_constant< uint32_t, 180> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<S,false> : integral_constant< uint32_t, 8> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindSSBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindSSBOs : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindSSBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindSSBOs<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<S,false> : integral_constant< uint32_t, 8> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindImages : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindImages> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindImages<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindStorageImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindStorageImages : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindStorageImages> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindStorageImages<S,false> : integral_constant< uint32_t, 1000000> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindInputAttachments<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindInputAttachments : integral_constant< uint32_t,S::maxDescriptorSetUpdateAfterBindInputAttachments> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindInputAttachments<S,false> : integral_constant< uint32_t, MinMaxColorAttachments> {};;

template<typename S, bool = has_member_supportedDepthResolveModesBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_supportedDepthResolveModesBitPattern : integral_constant< uint64_t,S::supportedDepthResolveModesBitPattern> {}; template<typename S> struct get_or_default_supportedDepthResolveModesBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::ResolveModeFlags::SAMPLE_ZERO_BIT | nbl::hlsl::ResolveModeFlags::MIN_BIT | nbl::hlsl::ResolveModeFlags::MAX_BIT> {};;
template<typename S, bool = has_member_supportedStencilResolveModesBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_supportedStencilResolveModesBitPattern : integral_constant< uint64_t,S::supportedStencilResolveModesBitPattern> {}; template<typename S> struct get_or_default_supportedStencilResolveModesBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::ResolveModeFlags::SAMPLE_ZERO_BIT> {};;

template<typename S, bool = has_member_filterMinmaxImageComponentMapping<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_filterMinmaxImageComponentMapping : integral_constant< bool,S::filterMinmaxImageComponentMapping> {}; template<typename S> struct get_or_default_filterMinmaxImageComponentMapping<S,false> : integral_constant< bool, false> {};;

// VK 1.3
template<typename S, bool = has_member_minSubgroupSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minSubgroupSize : integral_constant< uint16_t,S::minSubgroupSize> {}; template<typename S> struct get_or_default_minSubgroupSize<S,false> : integral_constant< uint16_t, 128> {};;
template<typename S, bool = has_member_maxSubgroupSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSubgroupSize : integral_constant< uint16_t,S::maxSubgroupSize> {}; template<typename S> struct get_or_default_maxSubgroupSize<S,false> : integral_constant< uint16_t, 4> {};;
template<typename S, bool = has_member_maxComputeWorkgroupSubgroups<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxComputeWorkgroupSubgroups : integral_constant< uint32_t,S::maxComputeWorkgroupSubgroups> {}; template<typename S> struct get_or_default_maxComputeWorkgroupSubgroups<S,false> : integral_constant< uint32_t, 16> {};;
template<typename S, bool = has_member_requiredSubgroupSizeStagesBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_requiredSubgroupSizeStagesBitPattern : integral_constant< uint64_t,S::requiredSubgroupSizeStagesBitPattern> {}; template<typename S> struct get_or_default_requiredSubgroupSizeStagesBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::ShaderStage::ESS_UNKNOWN> {};;

template<typename S, bool = has_member_integerDotProduct8BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct8BitUnsignedAccelerated : integral_constant< bool,S::integerDotProduct8BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct8BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct8BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct8BitSignedAccelerated : integral_constant< bool,S::integerDotProduct8BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct8BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct8BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct8BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProduct8BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct8BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct4x8BitPackedUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct4x8BitPackedUnsignedAccelerated : integral_constant< bool,S::integerDotProduct4x8BitPackedUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct4x8BitPackedUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct4x8BitPackedSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct4x8BitPackedSignedAccelerated : integral_constant< bool,S::integerDotProduct4x8BitPackedSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct4x8BitPackedSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct4x8BitPackedMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct4x8BitPackedMixedSignednessAccelerated : integral_constant< bool,S::integerDotProduct4x8BitPackedMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct4x8BitPackedMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct16BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct16BitUnsignedAccelerated : integral_constant< bool,S::integerDotProduct16BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct16BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct16BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct16BitSignedAccelerated : integral_constant< bool,S::integerDotProduct16BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct16BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct16BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct16BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProduct16BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct16BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct32BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct32BitUnsignedAccelerated : integral_constant< bool,S::integerDotProduct32BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct32BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct32BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct32BitSignedAccelerated : integral_constant< bool,S::integerDotProduct32BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct32BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct32BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct32BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProduct32BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct32BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct64BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct64BitUnsignedAccelerated : integral_constant< bool,S::integerDotProduct64BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct64BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct64BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct64BitSignedAccelerated : integral_constant< bool,S::integerDotProduct64BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct64BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProduct64BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProduct64BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProduct64BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProduct64BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating8BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating8BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating8BitSignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating8BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating8BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating16BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating16BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating16BitSignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating16BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating16BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating32BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating32BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating32BitSignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating32BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating32BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating64BitUnsignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating64BitSignedAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating64BitSignedAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating64BitSignedAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating64BitSignedAccelerated<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated : integral_constant< bool,S::integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated> {}; template<typename S> struct get_or_default_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_storageTexelBufferOffsetAlignmentBytes<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_storageTexelBufferOffsetAlignmentBytes : integral_constant< uint64_t,S::storageTexelBufferOffsetAlignmentBytes> {}; template<typename S> struct get_or_default_storageTexelBufferOffsetAlignmentBytes<S,false> : integral_constant< uint64_t, nbl::hlsl::numeric_limits<uint64_t>::max> {};;
template<typename S, bool = has_member_uniformTexelBufferOffsetAlignmentBytes<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_uniformTexelBufferOffsetAlignmentBytes : integral_constant< uint64_t,S::uniformTexelBufferOffsetAlignmentBytes> {}; template<typename S> struct get_or_default_uniformTexelBufferOffsetAlignmentBytes<S,false> : integral_constant< uint64_t, nbl::hlsl::numeric_limits<uint64_t>::max> {};;

template<typename S, bool = has_member_maxBufferSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxBufferSize : integral_constant< uint64_t,S::maxBufferSize> {}; template<typename S> struct get_or_default_maxBufferSize<S,false> : integral_constant< uint64_t, MinMaxSSBOSize> {};;

// Nabla Core Extensions
template<typename S, bool = has_member_minImportedHostPointerAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minImportedHostPointerAlignment : integral_constant< uint32_t,S::minImportedHostPointerAlignment> {}; template<typename S> struct get_or_default_minImportedHostPointerAlignment<S,false> : integral_constant< uint32_t, 0x1u << 31> {};;

template<typename S, bool = has_member_shaderBufferFloat32AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat32AtomicAdd : integral_constant< bool,S::shaderBufferFloat32AtomicAdd> {}; template<typename S> struct get_or_default_shaderBufferFloat32AtomicAdd<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderBufferFloat64Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat64Atomics : integral_constant< bool,S::shaderBufferFloat64Atomics> {}; template<typename S> struct get_or_default_shaderBufferFloat64Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderBufferFloat64AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat64AtomicAdd : integral_constant< bool,S::shaderBufferFloat64AtomicAdd> {}; template<typename S> struct get_or_default_shaderBufferFloat64AtomicAdd<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat32AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat32AtomicAdd : integral_constant< bool,S::shaderSharedFloat32AtomicAdd> {}; template<typename S> struct get_or_default_shaderSharedFloat32AtomicAdd<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat64Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat64Atomics : integral_constant< bool,S::shaderSharedFloat64Atomics> {}; template<typename S> struct get_or_default_shaderSharedFloat64Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat64AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat64AtomicAdd : integral_constant< bool,S::shaderSharedFloat64AtomicAdd> {}; template<typename S> struct get_or_default_shaderSharedFloat64AtomicAdd<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderImageFloat32AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderImageFloat32AtomicAdd : integral_constant< bool,S::shaderImageFloat32AtomicAdd> {}; template<typename S> struct get_or_default_shaderImageFloat32AtomicAdd<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_sparseImageFloat32Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sparseImageFloat32Atomics : integral_constant< bool,S::sparseImageFloat32Atomics> {}; template<typename S> struct get_or_default_sparseImageFloat32Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_sparseImageFloat32AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sparseImageFloat32AtomicAdd : integral_constant< bool,S::sparseImageFloat32AtomicAdd> {}; template<typename S> struct get_or_default_sparseImageFloat32AtomicAdd<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_robustStorageBufferAccessSizeAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_robustStorageBufferAccessSizeAlignment : integral_constant< uint64_t,S::robustStorageBufferAccessSizeAlignment> {}; template<typename S> struct get_or_default_robustStorageBufferAccessSizeAlignment<S,false> : integral_constant< uint64_t, 0x1ull << 63> {};;
template<typename S, bool = has_member_robustUniformBufferAccessSizeAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_robustUniformBufferAccessSizeAlignment : integral_constant< uint64_t,S::robustUniformBufferAccessSizeAlignment> {}; template<typename S> struct get_or_default_robustUniformBufferAccessSizeAlignment<S,false> : integral_constant< uint64_t, 0x1ull << 63> {};;

// Extensions
template<typename S, bool = has_member_shaderTrinaryMinmax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderTrinaryMinmax : integral_constant< bool,S::shaderTrinaryMinmax> {}; template<typename S> struct get_or_default_shaderTrinaryMinmax<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderExplicitVertexParameter<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderExplicitVertexParameter : integral_constant< bool,S::shaderExplicitVertexParameter> {}; template<typename S> struct get_or_default_shaderExplicitVertexParameter<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_gpuShaderHalfFloatAMD<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_gpuShaderHalfFloatAMD : integral_constant< bool,S::gpuShaderHalfFloatAMD> {}; template<typename S> struct get_or_default_gpuShaderHalfFloatAMD<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderImageLoadStoreLod<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderImageLoadStoreLod : integral_constant< bool,S::shaderImageLoadStoreLod> {}; template<typename S> struct get_or_default_shaderImageLoadStoreLod<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_displayTiming<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_displayTiming : integral_constant< bool,S::displayTiming> {}; template<typename S> struct get_or_default_displayTiming<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_maxDiscardRectangles<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDiscardRectangles : integral_constant< uint32_t,S::maxDiscardRectangles> {}; template<typename S> struct get_or_default_maxDiscardRectangles<S,false> : integral_constant< uint32_t, 0> {};;

template<typename S, bool = has_member_primitiveOverestimationSizeBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_primitiveOverestimationSizeBitPattern : integral_constant< uint32_t,S::primitiveOverestimationSizeBitPattern> {}; template<typename S> struct get_or_default_primitiveOverestimationSizeBitPattern<S,false> : integral_constant< uint32_t, asuint(0.f)> {};;
template<typename S, bool = has_member_maxExtraPrimitiveOverestimationSizeBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxExtraPrimitiveOverestimationSizeBitPattern : integral_constant< uint32_t,S::maxExtraPrimitiveOverestimationSizeBitPattern> {}; template<typename S> struct get_or_default_maxExtraPrimitiveOverestimationSizeBitPattern<S,false> : integral_constant< uint32_t, asuint(0.f)> {};;
template<typename S, bool = has_member_extraPrimitiveOverestimationSizeGranularityBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_extraPrimitiveOverestimationSizeGranularityBitPattern : integral_constant< uint32_t,S::extraPrimitiveOverestimationSizeGranularityBitPattern> {}; template<typename S> struct get_or_default_extraPrimitiveOverestimationSizeGranularityBitPattern<S,false> : integral_constant< uint32_t, 0x7F800000> {};;
template<typename S, bool = has_member_primitiveUnderestimation<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_primitiveUnderestimation : integral_constant< bool,S::primitiveUnderestimation> {}; template<typename S> struct get_or_default_primitiveUnderestimation<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_conservativePointAndLineRasterization<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_conservativePointAndLineRasterization : integral_constant< bool,S::conservativePointAndLineRasterization> {}; template<typename S> struct get_or_default_conservativePointAndLineRasterization<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_degenerateTrianglesRasterized<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_degenerateTrianglesRasterized : integral_constant< bool,S::degenerateTrianglesRasterized> {}; template<typename S> struct get_or_default_degenerateTrianglesRasterized<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_degenerateLinesRasterized<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_degenerateLinesRasterized : integral_constant< bool,S::degenerateLinesRasterized> {}; template<typename S> struct get_or_default_degenerateLinesRasterized<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_fullyCoveredFragmentShaderInputVariable<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fullyCoveredFragmentShaderInputVariable : integral_constant< bool,S::fullyCoveredFragmentShaderInputVariable> {}; template<typename S> struct get_or_default_fullyCoveredFragmentShaderInputVariable<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_conservativeRasterizationPostDepthCoverage<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_conservativeRasterizationPostDepthCoverage : integral_constant< bool,S::conservativeRasterizationPostDepthCoverage> {}; template<typename S> struct get_or_default_conservativeRasterizationPostDepthCoverage<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_queueFamilyForeign<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_queueFamilyForeign : integral_constant< bool,S::queueFamilyForeign> {}; template<typename S> struct get_or_default_queueFamilyForeign<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderStencilExport<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderStencilExport : integral_constant< bool,S::shaderStencilExport> {}; template<typename S> struct get_or_default_shaderStencilExport<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_variableSampleLocations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_variableSampleLocations : integral_constant< bool,S::variableSampleLocations> {}; template<typename S> struct get_or_default_variableSampleLocations<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_sampleLocationSubPixelBits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sampleLocationSubPixelBits : integral_constant< uint16_t,S::sampleLocationSubPixelBits> {}; template<typename S> struct get_or_default_sampleLocationSubPixelBits<S,false> : integral_constant< uint16_t, 0> {};;
template<typename S, bool = has_member_sampleLocationSampleCountsBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sampleLocationSampleCountsBitPattern : integral_constant< uint64_t,S::sampleLocationSampleCountsBitPattern> {}; template<typename S> struct get_or_default_sampleLocationSampleCountsBitPattern<S,false> : integral_constant< uint64_t, (nbl::hlsl::SampleCountFlags)(0u)> {};;
template<typename S, bool = has_member_maxSampleLocationGridSizeX<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSampleLocationGridSizeX : integral_constant< uint32_t,S::maxSampleLocationGridSizeX> {}; template<typename S> struct get_or_default_maxSampleLocationGridSizeX<S,false> : integral_constant< uint32_t, 0u> {};;
template<typename S, bool = has_member_maxSampleLocationGridSizeY<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSampleLocationGridSizeY : integral_constant< uint32_t,S::maxSampleLocationGridSizeY> {}; template<typename S> struct get_or_default_maxSampleLocationGridSizeY<S,false> : integral_constant< uint32_t, 0u> {};;
template<typename S, bool = has_member_sampleLocationCoordinateRangeBitPatternMin<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sampleLocationCoordinateRangeBitPatternMin : integral_constant< uint32_t,S::sampleLocationCoordinateRangeBitPatternMin> {}; template<typename S> struct get_or_default_sampleLocationCoordinateRangeBitPatternMin<S,false> : integral_constant< uint32_t, asuint(1.f)> {};;
template<typename S, bool = has_member_sampleLocationCoordinateRangeBitPatternMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sampleLocationCoordinateRangeBitPatternMax : integral_constant< uint32_t,S::sampleLocationCoordinateRangeBitPatternMax> {}; template<typename S> struct get_or_default_sampleLocationCoordinateRangeBitPatternMax<S,false> : integral_constant< uint32_t, asuint(0.f)> {};;

template<typename S, bool = has_member_maxAccelerationStructureGeometryCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxAccelerationStructureGeometryCount : integral_constant< uint64_t,S::maxAccelerationStructureGeometryCount> {}; template<typename S> struct get_or_default_maxAccelerationStructureGeometryCount<S,false> : integral_constant< uint64_t, 0> {};;
template<typename S, bool = has_member_maxAccelerationStructureInstanceCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxAccelerationStructureInstanceCount : integral_constant< uint64_t,S::maxAccelerationStructureInstanceCount> {}; template<typename S> struct get_or_default_maxAccelerationStructureInstanceCount<S,false> : integral_constant< uint64_t, 0> {};;
template<typename S, bool = has_member_maxAccelerationStructurePrimitiveCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxAccelerationStructurePrimitiveCount : integral_constant< uint64_t,S::maxAccelerationStructurePrimitiveCount> {}; template<typename S> struct get_or_default_maxAccelerationStructurePrimitiveCount<S,false> : integral_constant< uint64_t, 0> {};;
template<typename S, bool = has_member_maxPerStageDescriptorAccelerationStructures<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorAccelerationStructures : integral_constant< uint64_t,S::maxPerStageDescriptorAccelerationStructures> {}; template<typename S> struct get_or_default_maxPerStageDescriptorAccelerationStructures<S,false> : integral_constant< uint64_t, 0> {};;
template<typename S, bool = has_member_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxPerStageDescriptorUpdateAfterBindAccelerationStructures : integral_constant< uint64_t,S::maxPerStageDescriptorUpdateAfterBindAccelerationStructures> {}; template<typename S> struct get_or_default_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<S,false> : integral_constant< uint64_t, 0> {};;
template<typename S, bool = has_member_maxDescriptorSetAccelerationStructures<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetAccelerationStructures : integral_constant< uint64_t,S::maxDescriptorSetAccelerationStructures> {}; template<typename S> struct get_or_default_maxDescriptorSetAccelerationStructures<S,false> : integral_constant< uint64_t, 0> {};;
template<typename S, bool = has_member_maxDescriptorSetUpdateAfterBindAccelerationStructures<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetUpdateAfterBindAccelerationStructures : integral_constant< uint64_t,S::maxDescriptorSetUpdateAfterBindAccelerationStructures> {}; template<typename S> struct get_or_default_maxDescriptorSetUpdateAfterBindAccelerationStructures<S,false> : integral_constant< uint64_t, 0> {};;
template<typename S, bool = has_member_minAccelerationStructureScratchOffsetAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minAccelerationStructureScratchOffsetAlignment : integral_constant< uint64_t,S::minAccelerationStructureScratchOffsetAlignment> {}; template<typename S> struct get_or_default_minAccelerationStructureScratchOffsetAlignment<S,false> : integral_constant< uint64_t, 0x1u << 31u> {};;

template<typename S, bool = has_member_maxRayRecursionDepth<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxRayRecursionDepth : integral_constant< uint32_t,S::maxRayRecursionDepth> {}; template<typename S> struct get_or_default_maxRayRecursionDepth<S,false> : integral_constant< uint32_t, 0> {};;
template<typename S, bool = has_member_maxShaderGroupStride<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxShaderGroupStride : integral_constant< uint32_t,S::maxShaderGroupStride> {}; template<typename S> struct get_or_default_maxShaderGroupStride<S,false> : integral_constant< uint32_t, 0> {};;
template<typename S, bool = has_member_shaderGroupBaseAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderGroupBaseAlignment : integral_constant< uint32_t,S::shaderGroupBaseAlignment> {}; template<typename S> struct get_or_default_shaderGroupBaseAlignment<S,false> : integral_constant< uint32_t, 0x1u << 31u> {};;
template<typename S, bool = has_member_maxRayDispatchInvocationCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxRayDispatchInvocationCount : integral_constant< uint32_t,S::maxRayDispatchInvocationCount> {}; template<typename S> struct get_or_default_maxRayDispatchInvocationCount<S,false> : integral_constant< uint32_t, 0> {};;
template<typename S, bool = has_member_shaderGroupHandleAlignment<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderGroupHandleAlignment : integral_constant< uint32_t,S::shaderGroupHandleAlignment> {}; template<typename S> struct get_or_default_shaderGroupHandleAlignment<S,false> : integral_constant< uint32_t, 0x1u << 31u> {};;
template<typename S, bool = has_member_maxRayHitAttributeSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxRayHitAttributeSize : integral_constant< uint32_t,S::maxRayHitAttributeSize> {}; template<typename S> struct get_or_default_maxRayHitAttributeSize<S,false> : integral_constant< uint32_t, 0> {};;

template<typename S, bool = has_member_shaderSMBuiltins<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSMBuiltins : integral_constant< bool,S::shaderSMBuiltins> {}; template<typename S> struct get_or_default_shaderSMBuiltins<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_postDepthCoverage<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_postDepthCoverage : integral_constant< bool,S::postDepthCoverage> {}; template<typename S> struct get_or_default_postDepthCoverage<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_computeDerivativeGroupQuads<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_computeDerivativeGroupQuads : integral_constant< bool,S::computeDerivativeGroupQuads> {}; template<typename S> struct get_or_default_computeDerivativeGroupQuads<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_computeDerivativeGroupLinear<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_computeDerivativeGroupLinear : integral_constant< bool,S::computeDerivativeGroupLinear> {}; template<typename S> struct get_or_default_computeDerivativeGroupLinear<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_pciDomain<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pciDomain : integral_constant< uint32_t,S::pciDomain> {}; template<typename S> struct get_or_default_pciDomain<S,false> : integral_constant< uint32_t, ~0u> {};;
template<typename S, bool = has_member_pciBus<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pciBus : integral_constant< uint32_t,S::pciBus> {}; template<typename S> struct get_or_default_pciBus<S,false> : integral_constant< uint32_t, ~0u> {};;
template<typename S, bool = has_member_pciDevice<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pciDevice : integral_constant< uint32_t,S::pciDevice> {}; template<typename S> struct get_or_default_pciDevice<S,false> : integral_constant< uint32_t, ~0u> {};;
template<typename S, bool = has_member_pciFunction<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pciFunction : integral_constant< uint32_t,S::pciFunction> {}; template<typename S> struct get_or_default_pciFunction<S,false> : integral_constant< uint32_t, ~0u> {};;

template<typename S, bool = has_member_minFragmentDensityTexelSizeX<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minFragmentDensityTexelSizeX : integral_constant< uint32_t,S::minFragmentDensityTexelSizeX> {}; template<typename S> struct get_or_default_minFragmentDensityTexelSizeX<S,false> : integral_constant< uint32_t, ~0u> {};;
template<typename S, bool = has_member_minFragmentDensityTexelSizeY<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_minFragmentDensityTexelSizeY : integral_constant< uint32_t,S::minFragmentDensityTexelSizeY> {}; template<typename S> struct get_or_default_minFragmentDensityTexelSizeY<S,false> : integral_constant< uint32_t, ~0u> {};;
template<typename S, bool = has_member_maxFragmentDensityTexelSizeX<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFragmentDensityTexelSizeX : integral_constant< uint32_t,S::maxFragmentDensityTexelSizeX> {}; template<typename S> struct get_or_default_maxFragmentDensityTexelSizeX<S,false> : integral_constant< uint32_t, 0u> {};;
template<typename S, bool = has_member_maxFragmentDensityTexelSizeY<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxFragmentDensityTexelSizeY : integral_constant< uint32_t,S::maxFragmentDensityTexelSizeY> {}; template<typename S> struct get_or_default_maxFragmentDensityTexelSizeY<S,false> : integral_constant< uint32_t, 0u> {};;
template<typename S, bool = has_member_fragmentDensityInvocations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentDensityInvocations : integral_constant< bool,S::fragmentDensityInvocations> {}; template<typename S> struct get_or_default_fragmentDensityInvocations<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_decorateString<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_decorateString : integral_constant< bool,S::decorateString> {}; template<typename S> struct get_or_default_decorateString<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderImageInt64Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderImageInt64Atomics : integral_constant< bool,S::shaderImageInt64Atomics> {}; template<typename S> struct get_or_default_shaderImageInt64Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_sparseImageInt64Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sparseImageInt64Atomics : integral_constant< bool,S::sparseImageInt64Atomics> {}; template<typename S> struct get_or_default_sparseImageInt64Atomics<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_lineSubPixelPrecisionBits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_lineSubPixelPrecisionBits : integral_constant< uint32_t,S::lineSubPixelPrecisionBits> {}; template<typename S> struct get_or_default_lineSubPixelPrecisionBits<S,false> : integral_constant< uint32_t, 0> {};;

template<typename S, bool = has_member_shaderBufferFloat16Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat16Atomics : integral_constant< bool,S::shaderBufferFloat16Atomics> {}; template<typename S> struct get_or_default_shaderBufferFloat16Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderBufferFloat16AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat16AtomicAdd : integral_constant< bool,S::shaderBufferFloat16AtomicAdd> {}; template<typename S> struct get_or_default_shaderBufferFloat16AtomicAdd<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderBufferFloat16AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat16AtomicMinMax : integral_constant< bool,S::shaderBufferFloat16AtomicMinMax> {}; template<typename S> struct get_or_default_shaderBufferFloat16AtomicMinMax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderBufferFloat32AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat32AtomicMinMax : integral_constant< bool,S::shaderBufferFloat32AtomicMinMax> {}; template<typename S> struct get_or_default_shaderBufferFloat32AtomicMinMax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderBufferFloat64AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferFloat64AtomicMinMax : integral_constant< bool,S::shaderBufferFloat64AtomicMinMax> {}; template<typename S> struct get_or_default_shaderBufferFloat64AtomicMinMax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat16Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat16Atomics : integral_constant< bool,S::shaderSharedFloat16Atomics> {}; template<typename S> struct get_or_default_shaderSharedFloat16Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat16AtomicAdd<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat16AtomicAdd : integral_constant< bool,S::shaderSharedFloat16AtomicAdd> {}; template<typename S> struct get_or_default_shaderSharedFloat16AtomicAdd<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat16AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat16AtomicMinMax : integral_constant< bool,S::shaderSharedFloat16AtomicMinMax> {}; template<typename S> struct get_or_default_shaderSharedFloat16AtomicMinMax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat32AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat32AtomicMinMax : integral_constant< bool,S::shaderSharedFloat32AtomicMinMax> {}; template<typename S> struct get_or_default_shaderSharedFloat32AtomicMinMax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedFloat64AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedFloat64AtomicMinMax : integral_constant< bool,S::shaderSharedFloat64AtomicMinMax> {}; template<typename S> struct get_or_default_shaderSharedFloat64AtomicMinMax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderImageFloat32AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderImageFloat32AtomicMinMax : integral_constant< bool,S::shaderImageFloat32AtomicMinMax> {}; template<typename S> struct get_or_default_shaderImageFloat32AtomicMinMax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_sparseImageFloat32AtomicMinMax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_sparseImageFloat32AtomicMinMax : integral_constant< bool,S::sparseImageFloat32AtomicMinMax> {}; template<typename S> struct get_or_default_sparseImageFloat32AtomicMinMax<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_deviceMemoryReport<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_deviceMemoryReport : integral_constant< bool,S::deviceMemoryReport> {}; template<typename S> struct get_or_default_deviceMemoryReport<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderNonSemanticInfo<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderNonSemanticInfo : integral_constant< bool,S::shaderNonSemanticInfo> {}; template<typename S> struct get_or_default_shaderNonSemanticInfo<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_fragmentShaderBarycentric<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentShaderBarycentric : integral_constant< bool,S::fragmentShaderBarycentric> {}; template<typename S> struct get_or_default_fragmentShaderBarycentric<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderSubgroupUniformControlFlow<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSubgroupUniformControlFlow : integral_constant< bool,S::shaderSubgroupUniformControlFlow> {}; template<typename S> struct get_or_default_shaderSubgroupUniformControlFlow<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_subsampledLoads<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_subsampledLoads : integral_constant< bool,S::subsampledLoads> {}; template<typename S> struct get_or_default_subsampledLoads<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_subsampledCoarseReconstructionEarlyAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_subsampledCoarseReconstructionEarlyAccess : integral_constant< bool,S::subsampledCoarseReconstructionEarlyAccess> {}; template<typename S> struct get_or_default_subsampledCoarseReconstructionEarlyAccess<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_maxSubsampledArrayLayers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxSubsampledArrayLayers : integral_constant< uint32_t,S::maxSubsampledArrayLayers> {}; template<typename S> struct get_or_default_maxSubsampledArrayLayers<S,false> : integral_constant< uint32_t, 0> {};;
template<typename S, bool = has_member_maxDescriptorSetSubsampledSamplers<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxDescriptorSetSubsampledSamplers : integral_constant< uint32_t,S::maxDescriptorSetSubsampledSamplers> {}; template<typename S> struct get_or_default_maxDescriptorSetSubsampledSamplers<S,false> : integral_constant< uint32_t, 0> {};;

template<typename S, bool = has_member_workgroupMemoryExplicitLayout<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_workgroupMemoryExplicitLayout : integral_constant< bool,S::workgroupMemoryExplicitLayout> {}; template<typename S> struct get_or_default_workgroupMemoryExplicitLayout<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_workgroupMemoryExplicitLayoutScalarBlockLayout<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_workgroupMemoryExplicitLayoutScalarBlockLayout : integral_constant< bool,S::workgroupMemoryExplicitLayoutScalarBlockLayout> {}; template<typename S> struct get_or_default_workgroupMemoryExplicitLayoutScalarBlockLayout<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_workgroupMemoryExplicitLayout8BitAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_workgroupMemoryExplicitLayout8BitAccess : integral_constant< bool,S::workgroupMemoryExplicitLayout8BitAccess> {}; template<typename S> struct get_or_default_workgroupMemoryExplicitLayout8BitAccess<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_workgroupMemoryExplicitLayout16BitAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_workgroupMemoryExplicitLayout16BitAccess : integral_constant< bool,S::workgroupMemoryExplicitLayout16BitAccess> {}; template<typename S> struct get_or_default_workgroupMemoryExplicitLayout16BitAccess<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_colorWriteEnable<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_colorWriteEnable : integral_constant< bool,S::colorWriteEnable> {}; template<typename S> struct get_or_default_colorWriteEnable<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_cooperativeMatrixSupportedStagesBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_cooperativeMatrixSupportedStagesBitPattern : integral_constant< uint64_t,S::cooperativeMatrixSupportedStagesBitPattern> {}; template<typename S> struct get_or_default_cooperativeMatrixSupportedStagesBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::ShaderStage::ESS_UNKNOWN> {};;

// Nabla
template<typename S, bool = has_member_computeUnits<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_computeUnits : integral_constant< uint32_t,S::computeUnits> {}; template<typename S> struct get_or_default_computeUnits<S,false> : integral_constant< uint32_t, 0> {};;
template<typename S, bool = has_member_dispatchBase<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_dispatchBase : integral_constant< bool,S::dispatchBase> {}; template<typename S> struct get_or_default_dispatchBase<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_allowCommandBufferQueryCopies<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_allowCommandBufferQueryCopies : integral_constant< bool,S::allowCommandBufferQueryCopies> {}; template<typename S> struct get_or_default_allowCommandBufferQueryCopies<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_maxOptimallyResidentWorkgroupInvocations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxOptimallyResidentWorkgroupInvocations : integral_constant< uint32_t,S::maxOptimallyResidentWorkgroupInvocations> {}; template<typename S> struct get_or_default_maxOptimallyResidentWorkgroupInvocations<S,false> : integral_constant< uint32_t, 0> {};;
template<typename S, bool = has_member_maxResidentInvocations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_maxResidentInvocations : integral_constant< uint32_t,S::maxResidentInvocations> {}; template<typename S> struct get_or_default_maxResidentInvocations<S,false> : integral_constant< uint32_t, 0> {};;
template<typename S, bool = has_member_spirvVersionBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_spirvVersionBitPattern : integral_constant< uint64_t,S::spirvVersionBitPattern> {}; template<typename S> struct get_or_default_spirvVersionBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::SpirvVersion::ESV_1_6> {};;

template<typename S, bool = has_member_logicOp<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_logicOp : integral_constant< bool,S::logicOp> {}; template<typename S> struct get_or_default_logicOp<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_vertexPipelineStoresAndAtomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_vertexPipelineStoresAndAtomics : integral_constant< bool,S::vertexPipelineStoresAndAtomics> {}; template<typename S> struct get_or_default_vertexPipelineStoresAndAtomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_fragmentStoresAndAtomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentStoresAndAtomics : integral_constant< bool,S::fragmentStoresAndAtomics> {}; template<typename S> struct get_or_default_fragmentStoresAndAtomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderTessellationAndGeometryPointSize<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderTessellationAndGeometryPointSize : integral_constant< bool,S::shaderTessellationAndGeometryPointSize> {}; template<typename S> struct get_or_default_shaderTessellationAndGeometryPointSize<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderStorageImageMultisample<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderStorageImageMultisample : integral_constant< bool,S::shaderStorageImageMultisample> {}; template<typename S> struct get_or_default_shaderStorageImageMultisample<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderStorageImageReadWithoutFormat<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderStorageImageReadWithoutFormat : integral_constant< bool,S::shaderStorageImageReadWithoutFormat> {}; template<typename S> struct get_or_default_shaderStorageImageReadWithoutFormat<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderStorageImageArrayDynamicIndexing<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderStorageImageArrayDynamicIndexing : integral_constant< bool,S::shaderStorageImageArrayDynamicIndexing> {}; template<typename S> struct get_or_default_shaderStorageImageArrayDynamicIndexing<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderFloat64<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderFloat64 : integral_constant< bool,S::shaderFloat64> {}; template<typename S> struct get_or_default_shaderFloat64<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_variableMultisampleRate<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_variableMultisampleRate : integral_constant< bool,S::variableMultisampleRate> {}; template<typename S> struct get_or_default_variableMultisampleRate<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_storagePushConstant16<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_storagePushConstant16 : integral_constant< bool,S::storagePushConstant16> {}; template<typename S> struct get_or_default_storagePushConstant16<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_storageInputOutput16<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_storageInputOutput16 : integral_constant< bool,S::storageInputOutput16> {}; template<typename S> struct get_or_default_storageInputOutput16<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_multiviewGeometryShader<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_multiviewGeometryShader : integral_constant< bool,S::multiviewGeometryShader> {}; template<typename S> struct get_or_default_multiviewGeometryShader<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_multiviewTessellationShader<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_multiviewTessellationShader : integral_constant< bool,S::multiviewTessellationShader> {}; template<typename S> struct get_or_default_multiviewTessellationShader<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_drawIndirectCount<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_drawIndirectCount : integral_constant< bool,S::drawIndirectCount> {}; template<typename S> struct get_or_default_drawIndirectCount<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_storagePushConstant8<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_storagePushConstant8 : integral_constant< bool,S::storagePushConstant8> {}; template<typename S> struct get_or_default_storagePushConstant8<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderBufferInt64Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderBufferInt64Atomics : integral_constant< bool,S::shaderBufferInt64Atomics> {}; template<typename S> struct get_or_default_shaderBufferInt64Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSharedInt64Atomics<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSharedInt64Atomics : integral_constant< bool,S::shaderSharedInt64Atomics> {}; template<typename S> struct get_or_default_shaderSharedInt64Atomics<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderFloat16<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderFloat16 : integral_constant< bool,S::shaderFloat16> {}; template<typename S> struct get_or_default_shaderFloat16<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderInputAttachmentArrayDynamicIndexing<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderInputAttachmentArrayDynamicIndexing : integral_constant< bool,S::shaderInputAttachmentArrayDynamicIndexing> {}; template<typename S> struct get_or_default_shaderInputAttachmentArrayDynamicIndexing<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderUniformBufferArrayNonUniformIndexing<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderUniformBufferArrayNonUniformIndexing : integral_constant< bool,S::shaderUniformBufferArrayNonUniformIndexing> {}; template<typename S> struct get_or_default_shaderUniformBufferArrayNonUniformIndexing<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderInputAttachmentArrayNonUniformIndexing<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderInputAttachmentArrayNonUniformIndexing : integral_constant< bool,S::shaderInputAttachmentArrayNonUniformIndexing> {}; template<typename S> struct get_or_default_shaderInputAttachmentArrayNonUniformIndexing<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_descriptorBindingUniformBufferUpdateAfterBind<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_descriptorBindingUniformBufferUpdateAfterBind : integral_constant< bool,S::descriptorBindingUniformBufferUpdateAfterBind> {}; template<typename S> struct get_or_default_descriptorBindingUniformBufferUpdateAfterBind<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_samplerFilterMinmax<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_samplerFilterMinmax : integral_constant< bool,S::samplerFilterMinmax> {}; template<typename S> struct get_or_default_samplerFilterMinmax<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_vulkanMemoryModelAvailabilityVisibilityChains<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_vulkanMemoryModelAvailabilityVisibilityChains : integral_constant< bool,S::vulkanMemoryModelAvailabilityVisibilityChains> {}; template<typename S> struct get_or_default_vulkanMemoryModelAvailabilityVisibilityChains<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderOutputViewportIndex<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderOutputViewportIndex : integral_constant< bool,S::shaderOutputViewportIndex> {}; template<typename S> struct get_or_default_shaderOutputViewportIndex<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderOutputLayer<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderOutputLayer : integral_constant< bool,S::shaderOutputLayer> {}; template<typename S> struct get_or_default_shaderOutputLayer<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDemoteToHelperInvocation<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDemoteToHelperInvocation : integral_constant< bool,S::shaderDemoteToHelperInvocation> {}; template<typename S> struct get_or_default_shaderDemoteToHelperInvocation<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderTerminateInvocation<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderTerminateInvocation : integral_constant< bool,S::shaderTerminateInvocation> {}; template<typename S> struct get_or_default_shaderTerminateInvocation<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderZeroInitializeWorkgroupMemory<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderZeroInitializeWorkgroupMemory : integral_constant< bool,S::shaderZeroInitializeWorkgroupMemory> {}; template<typename S> struct get_or_default_shaderZeroInitializeWorkgroupMemory<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderDeviceClock<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderDeviceClock : integral_constant< bool,S::shaderDeviceClock> {}; template<typename S> struct get_or_default_shaderDeviceClock<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderSubgroupClock<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderSubgroupClock : integral_constant< bool,S::shaderSubgroupClock> {}; template<typename S> struct get_or_default_shaderSubgroupClock<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_imageFootprint<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_imageFootprint : integral_constant< bool,S::imageFootprint> {}; template<typename S> struct get_or_default_imageFootprint<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderIntegerFunctions2<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderIntegerFunctions2 : integral_constant< bool,S::shaderIntegerFunctions2> {}; template<typename S> struct get_or_default_shaderIntegerFunctions2<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderEarlyAndLateFragmentTests<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderEarlyAndLateFragmentTests : integral_constant< bool,S::shaderEarlyAndLateFragmentTests> {}; template<typename S> struct get_or_default_shaderEarlyAndLateFragmentTests<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_rayTracingPositionFetch<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rayTracingPositionFetch : integral_constant< bool,S::rayTracingPositionFetch> {}; template<typename S> struct get_or_default_rayTracingPositionFetch<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_cooperativeMatrix<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_cooperativeMatrix : integral_constant< bool,S::cooperativeMatrix> {}; template<typename S> struct get_or_default_cooperativeMatrix<S,false> : integral_constant< bool, false> {};;

// Features Defaults
// VK 1.0
template<typename S, bool = has_member_robustBufferAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_robustBufferAccess : integral_constant< bool,S::robustBufferAccess> {}; template<typename S> struct get_or_default_robustBufferAccess<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_geometryShader<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_geometryShader : integral_constant< bool,S::geometryShader> {}; template<typename S> struct get_or_default_geometryShader<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_tessellationShader<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_tessellationShader : integral_constant< bool,S::tessellationShader> {}; template<typename S> struct get_or_default_tessellationShader<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_depthBounds<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_depthBounds : integral_constant< bool,S::depthBounds> {}; template<typename S> struct get_or_default_depthBounds<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_wideLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_wideLines : integral_constant< bool,S::wideLines> {}; template<typename S> struct get_or_default_wideLines<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_largePoints<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_largePoints : integral_constant< bool,S::largePoints> {}; template<typename S> struct get_or_default_largePoints<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_alphaToOne<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_alphaToOne : integral_constant< bool,S::alphaToOne> {}; template<typename S> struct get_or_default_alphaToOne<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_pipelineStatisticsQuery<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pipelineStatisticsQuery : integral_constant< bool,S::pipelineStatisticsQuery> {}; template<typename S> struct get_or_default_pipelineStatisticsQuery<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderCullDistance<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderCullDistance : integral_constant< bool,S::shaderCullDistance> {}; template<typename S> struct get_or_default_shaderCullDistance<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_shaderResourceResidency<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderResourceResidency : integral_constant< bool,S::shaderResourceResidency> {}; template<typename S> struct get_or_default_shaderResourceResidency<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_shaderResourceMinLod<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderResourceMinLod : integral_constant< bool,S::shaderResourceMinLod> {}; template<typename S> struct get_or_default_shaderResourceMinLod<S,false> : integral_constant< bool, false> {};;

// VK 1.1
// VK 1.2
template<typename S, bool = has_member_bufferDeviceAddressMultiDevice<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_bufferDeviceAddressMultiDevice : integral_constant< bool,S::bufferDeviceAddressMultiDevice> {}; template<typename S> struct get_or_default_bufferDeviceAddressMultiDevice<S,false> : integral_constant< bool, false> {};;

// VK 1.3
template<typename S, bool = has_member_robustImageAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_robustImageAccess : integral_constant< bool,S::robustImageAccess> {}; template<typename S> struct get_or_default_robustImageAccess<S,false> : integral_constant< bool, false> {};;

// Nabla Core Extensions
template<typename S, bool = has_member_robustBufferAccess2<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_robustBufferAccess2 : integral_constant< bool,S::robustBufferAccess2> {}; template<typename S> struct get_or_default_robustBufferAccess2<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_robustImageAccess2<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_robustImageAccess2 : integral_constant< bool,S::robustImageAccess2> {}; template<typename S> struct get_or_default_robustImageAccess2<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_nullDescriptor<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_nullDescriptor : integral_constant< bool,S::nullDescriptor> {}; template<typename S> struct get_or_default_nullDescriptor<S,false> : integral_constant< bool, false> {};;

// Extensions
template<typename S, bool = has_member_swapchainModeBitPattern<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_swapchainModeBitPattern : integral_constant< uint64_t,S::swapchainModeBitPattern> {}; template<typename S> struct get_or_default_swapchainModeBitPattern<S,false> : integral_constant< uint64_t, nbl::hlsl::SwapchainMode::ESM_NONE> {};;

template<typename S, bool = has_member_shaderInfoAMD<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_shaderInfoAMD : integral_constant< bool,S::shaderInfoAMD> {}; template<typename S> struct get_or_default_shaderInfoAMD<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_conditionalRendering<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_conditionalRendering : integral_constant< bool,S::conditionalRendering> {}; template<typename S> struct get_or_default_conditionalRendering<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_inheritedConditionalRendering<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_inheritedConditionalRendering : integral_constant< bool,S::inheritedConditionalRendering> {}; template<typename S> struct get_or_default_inheritedConditionalRendering<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_geometryShaderPassthrough<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_geometryShaderPassthrough : integral_constant< bool,S::geometryShaderPassthrough> {}; template<typename S> struct get_or_default_geometryShaderPassthrough<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_hdrMetadata<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_hdrMetadata : integral_constant< bool,S::hdrMetadata> {}; template<typename S> struct get_or_default_hdrMetadata<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_performanceCounterQueryPools<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_performanceCounterQueryPools : integral_constant< bool,S::performanceCounterQueryPools> {}; template<typename S> struct get_or_default_performanceCounterQueryPools<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_performanceCounterMultipleQueryPools<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_performanceCounterMultipleQueryPools : integral_constant< bool,S::performanceCounterMultipleQueryPools> {}; template<typename S> struct get_or_default_performanceCounterMultipleQueryPools<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_mixedAttachmentSamples<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_mixedAttachmentSamples : integral_constant< bool,S::mixedAttachmentSamples> {}; template<typename S> struct get_or_default_mixedAttachmentSamples<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_accelerationStructure<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_accelerationStructure : integral_constant< bool,S::accelerationStructure> {}; template<typename S> struct get_or_default_accelerationStructure<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_accelerationStructureIndirectBuild<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_accelerationStructureIndirectBuild : integral_constant< bool,S::accelerationStructureIndirectBuild> {}; template<typename S> struct get_or_default_accelerationStructureIndirectBuild<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_accelerationStructureHostCommands<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_accelerationStructureHostCommands : integral_constant< bool,S::accelerationStructureHostCommands> {}; template<typename S> struct get_or_default_accelerationStructureHostCommands<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_rayTracingPipeline<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rayTracingPipeline : integral_constant< bool,S::rayTracingPipeline> {}; template<typename S> struct get_or_default_rayTracingPipeline<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_rayTraversalPrimitiveCulling<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rayTraversalPrimitiveCulling : integral_constant< bool,S::rayTraversalPrimitiveCulling> {}; template<typename S> struct get_or_default_rayTraversalPrimitiveCulling<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_rayQuery<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rayQuery : integral_constant< bool,S::rayQuery> {}; template<typename S> struct get_or_default_rayQuery<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_representativeFragmentTest<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_representativeFragmentTest : integral_constant< bool,S::representativeFragmentTest> {}; template<typename S> struct get_or_default_representativeFragmentTest<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_bufferMarkerAMD<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_bufferMarkerAMD : integral_constant< bool,S::bufferMarkerAMD> {}; template<typename S> struct get_or_default_bufferMarkerAMD<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_fragmentDensityMap<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentDensityMap : integral_constant< bool,S::fragmentDensityMap> {}; template<typename S> struct get_or_default_fragmentDensityMap<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_fragmentDensityMapDynamic<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentDensityMapDynamic : integral_constant< bool,S::fragmentDensityMapDynamic> {}; template<typename S> struct get_or_default_fragmentDensityMapDynamic<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_fragmentDensityMapNonSubsampledImages<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentDensityMapNonSubsampledImages : integral_constant< bool,S::fragmentDensityMapNonSubsampledImages> {}; template<typename S> struct get_or_default_fragmentDensityMapNonSubsampledImages<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_deviceCoherentMemory<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_deviceCoherentMemory : integral_constant< bool,S::deviceCoherentMemory> {}; template<typename S> struct get_or_default_deviceCoherentMemory<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_memoryPriority<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_memoryPriority : integral_constant< bool,S::memoryPriority> {}; template<typename S> struct get_or_default_memoryPriority<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_fragmentShaderSampleInterlock<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentShaderSampleInterlock : integral_constant< bool,S::fragmentShaderSampleInterlock> {}; template<typename S> struct get_or_default_fragmentShaderSampleInterlock<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_fragmentShaderPixelInterlock<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentShaderPixelInterlock : integral_constant< bool,S::fragmentShaderPixelInterlock> {}; template<typename S> struct get_or_default_fragmentShaderPixelInterlock<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_fragmentShaderShadingRateInterlock<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentShaderShadingRateInterlock : integral_constant< bool,S::fragmentShaderShadingRateInterlock> {}; template<typename S> struct get_or_default_fragmentShaderShadingRateInterlock<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_rectangularLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rectangularLines : integral_constant< bool,S::rectangularLines> {}; template<typename S> struct get_or_default_rectangularLines<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_bresenhamLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_bresenhamLines : integral_constant< bool,S::bresenhamLines> {}; template<typename S> struct get_or_default_bresenhamLines<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_smoothLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_smoothLines : integral_constant< bool,S::smoothLines> {}; template<typename S> struct get_or_default_smoothLines<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_stippledRectangularLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_stippledRectangularLines : integral_constant< bool,S::stippledRectangularLines> {}; template<typename S> struct get_or_default_stippledRectangularLines<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_stippledBresenhamLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_stippledBresenhamLines : integral_constant< bool,S::stippledBresenhamLines> {}; template<typename S> struct get_or_default_stippledBresenhamLines<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_stippledSmoothLines<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_stippledSmoothLines : integral_constant< bool,S::stippledSmoothLines> {}; template<typename S> struct get_or_default_stippledSmoothLines<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_indexTypeUint8<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_indexTypeUint8 : integral_constant< bool,S::indexTypeUint8> {}; template<typename S> struct get_or_default_indexTypeUint8<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_deferredHostOperations<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_deferredHostOperations : integral_constant< bool,S::deferredHostOperations> {}; template<typename S> struct get_or_default_deferredHostOperations<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_pipelineExecutableInfo<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_pipelineExecutableInfo : integral_constant< bool,S::pipelineExecutableInfo> {}; template<typename S> struct get_or_default_pipelineExecutableInfo<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_deviceGeneratedCommands<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_deviceGeneratedCommands : integral_constant< bool,S::deviceGeneratedCommands> {}; template<typename S> struct get_or_default_deviceGeneratedCommands<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_rayTracingMotionBlur<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rayTracingMotionBlur : integral_constant< bool,S::rayTracingMotionBlur> {}; template<typename S> struct get_or_default_rayTracingMotionBlur<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_rayTracingMotionBlurPipelineTraceRaysIndirect<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rayTracingMotionBlurPipelineTraceRaysIndirect : integral_constant< bool,S::rayTracingMotionBlurPipelineTraceRaysIndirect> {}; template<typename S> struct get_or_default_rayTracingMotionBlurPipelineTraceRaysIndirect<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_fragmentDensityMapDeferred<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_fragmentDensityMapDeferred : integral_constant< bool,S::fragmentDensityMapDeferred> {}; template<typename S> struct get_or_default_fragmentDensityMapDeferred<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_rasterizationOrderColorAttachmentAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rasterizationOrderColorAttachmentAccess : integral_constant< bool,S::rasterizationOrderColorAttachmentAccess> {}; template<typename S> struct get_or_default_rasterizationOrderColorAttachmentAccess<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_rasterizationOrderDepthAttachmentAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rasterizationOrderDepthAttachmentAccess : integral_constant< bool,S::rasterizationOrderDepthAttachmentAccess> {}; template<typename S> struct get_or_default_rasterizationOrderDepthAttachmentAccess<S,false> : integral_constant< bool, false> {};;
template<typename S, bool = has_member_rasterizationOrderStencilAttachmentAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_rasterizationOrderStencilAttachmentAccess : integral_constant< bool,S::rasterizationOrderStencilAttachmentAccess> {}; template<typename S> struct get_or_default_rasterizationOrderStencilAttachmentAccess<S,false> : integral_constant< bool, false> {};;

template<typename S, bool = has_member_cooperativeMatrixRobustBufferAccess<S>::value == (e_member_presence::is_present | e_member_presence::is_static)> struct get_or_default_cooperativeMatrixRobustBufferAccess : integral_constant< bool,S::cooperativeMatrixRobustBufferAccess> {}; template<typename S> struct get_or_default_cooperativeMatrixRobustBufferAccess<S,false> : integral_constant< bool, false> {};;

// Nabla
#line 28 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/device_capabilities_traits.hlsl"
}

template<typename device_capabilities>
struct device_capabilities_traits
{
 uint32_t computeOptimalPersistentWorkgroupDispatchSize(const uint32_t elementCount, const uint32_t workgroupSize, const uint32_t workgroupSpinningProtection)
 {
	 const uint32_t infinitelyWideDeviceWGCount = (elementCount - 1u) / (workgroupSize * workgroupSpinningProtection) + 1u; // need thtat divAndRoundUp
	 return min(infinitelyWideDeviceWGCount,maxResidentInvocations/maxOptimallyResidentWorkgroupInvocations);
 }

uint32_t computeOptimalPersistentWorkgroupDispatchSize(const uint32_t elementCount, const uint32_t workgroupSize)
    {
	    return computeOptimalPersistentWorkgroupDispatchSize(elementCount,workgroupSize,1u);
    }

#line 1 "C:/Users/fjlet/Desktop/Nabla/build/src/nbl/device/include/nbl/video/device_capabilities_traits_members.hlsl"
// Limits Members
// VK 1.0
const static uint32_t maxImageDimension1D = impl::get_or_default_maxImageDimension1D<device_capabilities>::value;
const static uint32_t maxImageDimension2D = impl::get_or_default_maxImageDimension2D<device_capabilities>::value;
const static uint32_t maxImageDimension3D = impl::get_or_default_maxImageDimension3D<device_capabilities>::value;
const static uint32_t maxImageDimensionCube = impl::get_or_default_maxImageDimensionCube<device_capabilities>::value;
const static uint32_t maxImageArrayLayers = impl::get_or_default_maxImageArrayLayers<device_capabilities>::value;
const static uint32_t maxBufferViewTexels = impl::get_or_default_maxBufferViewTexels<device_capabilities>::value;
const static uint32_t maxUBOSize = impl::get_or_default_maxUBOSize<device_capabilities>::value;
const static uint32_t maxSSBOSize = impl::get_or_default_maxSSBOSize<device_capabilities>::value;
const static uint16_t maxPushConstantsSize = impl::get_or_default_maxPushConstantsSize<device_capabilities>::value;
const static uint32_t maxMemoryAllocationCount = impl::get_or_default_maxMemoryAllocationCount<device_capabilities>::value;
const static uint32_t maxSamplerAllocationCount = impl::get_or_default_maxSamplerAllocationCount<device_capabilities>::value;
const static uint32_t bufferImageGranularity = impl::get_or_default_bufferImageGranularity<device_capabilities>::value;

const static uint32_t maxPerStageDescriptorSamplers = impl::get_or_default_maxPerStageDescriptorSamplers<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorUBOs = impl::get_or_default_maxPerStageDescriptorUBOs<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorSSBOs = impl::get_or_default_maxPerStageDescriptorSSBOs<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorImages = impl::get_or_default_maxPerStageDescriptorImages<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorStorageImages = impl::get_or_default_maxPerStageDescriptorStorageImages<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorInputAttachments = impl::get_or_default_maxPerStageDescriptorInputAttachments<device_capabilities>::value;
const static uint32_t maxPerStageResources = impl::get_or_default_maxPerStageResources<device_capabilities>::value;

const static uint32_t maxDescriptorSetSamplers = impl::get_or_default_maxDescriptorSetSamplers<device_capabilities>::value;
const static uint32_t maxDescriptorSetUBOs = impl::get_or_default_maxDescriptorSetUBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetDynamicOffsetUBOs = impl::get_or_default_maxDescriptorSetDynamicOffsetUBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetSSBOs = impl::get_or_default_maxDescriptorSetSSBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetDynamicOffsetSSBOs = impl::get_or_default_maxDescriptorSetDynamicOffsetSSBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetImages = impl::get_or_default_maxDescriptorSetImages<device_capabilities>::value;
const static uint32_t maxDescriptorSetStorageImages = impl::get_or_default_maxDescriptorSetStorageImages<device_capabilities>::value;
const static uint32_t maxDescriptorSetInputAttachments = impl::get_or_default_maxDescriptorSetInputAttachments<device_capabilities>::value;

const static uint16_t maxVertexOutputComponents = impl::get_or_default_maxVertexOutputComponents<device_capabilities>::value;

const static uint16_t maxTessellationGenerationLevel = impl::get_or_default_maxTessellationGenerationLevel<device_capabilities>::value;
const static uint16_t maxTessellationPatchSize = impl::get_or_default_maxTessellationPatchSize<device_capabilities>::value;
const static uint16_t maxTessellationControlPerVertexInputComponents = impl::get_or_default_maxTessellationControlPerVertexInputComponents<device_capabilities>::value;
const static uint16_t maxTessellationControlPerVertexOutputComponents = impl::get_or_default_maxTessellationControlPerVertexOutputComponents<device_capabilities>::value;
const static uint16_t maxTessellationControlPerPatchOutputComponents = impl::get_or_default_maxTessellationControlPerPatchOutputComponents<device_capabilities>::value;
const static uint16_t maxTessellationControlTotalOutputComponents = impl::get_or_default_maxTessellationControlTotalOutputComponents<device_capabilities>::value;
const static uint16_t maxTessellationEvaluationInputComponents = impl::get_or_default_maxTessellationEvaluationInputComponents<device_capabilities>::value;
const static uint16_t maxTessellationEvaluationOutputComponents = impl::get_or_default_maxTessellationEvaluationOutputComponents<device_capabilities>::value;

const static uint16_t maxGeometryShaderInvocations = impl::get_or_default_maxGeometryShaderInvocations<device_capabilities>::value;
const static uint16_t maxGeometryInputComponents = impl::get_or_default_maxGeometryInputComponents<device_capabilities>::value;
const static uint16_t maxGeometryOutputComponents = impl::get_or_default_maxGeometryOutputComponents<device_capabilities>::value;
const static uint16_t maxGeometryOutputVertices = impl::get_or_default_maxGeometryOutputVertices<device_capabilities>::value;
const static uint16_t maxGeometryTotalOutputComponents = impl::get_or_default_maxGeometryTotalOutputComponents<device_capabilities>::value;

const static uint32_t maxFragmentInputComponents = impl::get_or_default_maxFragmentInputComponents<device_capabilities>::value;
const static uint32_t maxFragmentOutputAttachments = impl::get_or_default_maxFragmentOutputAttachments<device_capabilities>::value;
const static uint32_t maxFragmentDualSrcAttachments = impl::get_or_default_maxFragmentDualSrcAttachments<device_capabilities>::value;
const static uint32_t maxFragmentCombinedOutputResources = impl::get_or_default_maxFragmentCombinedOutputResources<device_capabilities>::value;

const static uint32_t maxComputeSharedMemorySize = impl::get_or_default_maxComputeSharedMemorySize<device_capabilities>::value;
const static uint32_t maxComputeWorkGroupCountX = impl::get_or_default_maxComputeWorkGroupCountX<device_capabilities>::value;
const static uint32_t maxComputeWorkGroupCountY = impl::get_or_default_maxComputeWorkGroupCountY<device_capabilities>::value;
const static uint32_t maxComputeWorkGroupCountZ = impl::get_or_default_maxComputeWorkGroupCountZ<device_capabilities>::value;
const static uint16_t maxComputeWorkGroupInvocations = impl::get_or_default_maxComputeWorkGroupInvocations<device_capabilities>::value;
const static uint16_t maxWorkgroupSizeX = impl::get_or_default_maxWorkgroupSizeX<device_capabilities>::value;
const static uint16_t maxWorkgroupSizeY = impl::get_or_default_maxWorkgroupSizeY<device_capabilities>::value;
const static uint16_t maxWorkgroupSizeZ = impl::get_or_default_maxWorkgroupSizeZ<device_capabilities>::value;

const static uint16_t subPixelPrecisionBits = impl::get_or_default_subPixelPrecisionBits<device_capabilities>::value;
const static uint16_t subTexelPrecisionBits = impl::get_or_default_subTexelPrecisionBits<device_capabilities>::value;
const static uint16_t mipmapPrecisionBits = impl::get_or_default_mipmapPrecisionBits<device_capabilities>::value;

const static uint32_t maxDrawIndirectCount = impl::get_or_default_maxDrawIndirectCount<device_capabilities>::value;

const static uint32_t maxSamplerLodBiasBitPattern = impl::get_or_default_maxSamplerLodBiasBitPattern<device_capabilities>::value;
const static uint16_t maxSamplerAnisotropyLog2 = impl::get_or_default_maxSamplerAnisotropyLog2<device_capabilities>::value;

const static uint16_t maxViewports = impl::get_or_default_maxViewports<device_capabilities>::value;
const static uint16_t maxViewportDimsX = impl::get_or_default_maxViewportDimsX<device_capabilities>::value;
const static uint16_t maxViewportDimsY = impl::get_or_default_maxViewportDimsY<device_capabilities>::value;
const static uint32_t viewportBoundsRangeBitPatternMin = impl::get_or_default_viewportBoundsRangeBitPatternMin<device_capabilities>::value;
const static uint32_t viewportBoundsRangeBitPatternMax = impl::get_or_default_viewportBoundsRangeBitPatternMax<device_capabilities>::value;
const static uint32_t viewportSubPixelBits = impl::get_or_default_viewportSubPixelBits<device_capabilities>::value;

const static uint16_t minMemoryMapAlignment = impl::get_or_default_minMemoryMapAlignment<device_capabilities>::value;
const static uint16_t bufferViewAlignment = impl::get_or_default_bufferViewAlignment<device_capabilities>::value;
const static uint16_t minUBOAlignment = impl::get_or_default_minUBOAlignment<device_capabilities>::value;
const static uint16_t minSSBOAlignment = impl::get_or_default_minSSBOAlignment<device_capabilities>::value;

const static int16_t minTexelOffset = impl::get_or_default_minTexelOffset<device_capabilities>::value;
const static uint16_t maxTexelOffset = impl::get_or_default_maxTexelOffset<device_capabilities>::value;
const static int16_t minTexelGatherOffset = impl::get_or_default_minTexelGatherOffset<device_capabilities>::value;
const static uint16_t maxTexelGatherOffset = impl::get_or_default_maxTexelGatherOffset<device_capabilities>::value;

const static uint32_t minInterpolationOffsetBitPattern = impl::get_or_default_minInterpolationOffsetBitPattern<device_capabilities>::value;
const static uint32_t maxInterpolationOffsetBitPattern = impl::get_or_default_maxInterpolationOffsetBitPattern<device_capabilities>::value;
const static uint16_t subPixelInterpolationOffsetBits = impl::get_or_default_subPixelInterpolationOffsetBits<device_capabilities>::value;

const static uint32_t maxFramebufferWidth = impl::get_or_default_maxFramebufferWidth<device_capabilities>::value;
const static uint32_t maxFramebufferHeight = impl::get_or_default_maxFramebufferHeight<device_capabilities>::value;
const static uint32_t maxFramebufferLayers = impl::get_or_default_maxFramebufferLayers<device_capabilities>::value;

const static uint16_t maxColorAttachments = impl::get_or_default_maxColorAttachments<device_capabilities>::value;

const static uint16_t maxSampleMaskWords = impl::get_or_default_maxSampleMaskWords<device_capabilities>::value;

const static uint32_t timestampPeriodInNanoSecondsBitPattern = impl::get_or_default_timestampPeriodInNanoSecondsBitPattern<device_capabilities>::value;

const static uint16_t maxClipDistances = impl::get_or_default_maxClipDistances<device_capabilities>::value;
const static uint16_t maxCullDistances = impl::get_or_default_maxCullDistances<device_capabilities>::value;
const static uint16_t maxCombinedClipAndCullDistances = impl::get_or_default_maxCombinedClipAndCullDistances<device_capabilities>::value;

const static uint32_t discreteQueuePriorities = impl::get_or_default_discreteQueuePriorities<device_capabilities>::value;

const static uint32_t pointSizeRangeBitPatternMin = impl::get_or_default_pointSizeRangeBitPatternMin<device_capabilities>::value;
const static uint32_t pointSizeRangeBitPatternMax = impl::get_or_default_pointSizeRangeBitPatternMax<device_capabilities>::value;
const static uint32_t lineWidthRangeBitPatternMin = impl::get_or_default_lineWidthRangeBitPatternMin<device_capabilities>::value;
const static uint32_t lineWidthRangeBitPatternMax = impl::get_or_default_lineWidthRangeBitPatternMax<device_capabilities>::value;
const static uint32_t pointSizeGranularityBitPattern = impl::get_or_default_pointSizeGranularityBitPattern<device_capabilities>::value;
const static uint32_t lineWidthGranularityBitPattern = impl::get_or_default_lineWidthGranularityBitPattern<device_capabilities>::value;

const static bool strictLines = impl::get_or_default_strictLines<device_capabilities>::value;

const static bool standardSampleLocations = impl::get_or_default_standardSampleLocations<device_capabilities>::value;

const static uint16_t optimalBufferCopyOffsetAlignment = impl::get_or_default_optimalBufferCopyOffsetAlignment<device_capabilities>::value;
const static uint16_t optimalBufferCopyRowPitchAlignment = impl::get_or_default_optimalBufferCopyRowPitchAlignment<device_capabilities>::value;
const static uint16_t nonCoherentAtomSize = impl::get_or_default_nonCoherentAtomSize<device_capabilities>::value;

// VK 1.1
const static uint16_t subgroupSize = impl::get_or_default_subgroupSize<device_capabilities>::value;
const static uint64_t subgroupOpsShaderStagesBitPattern = impl::get_or_default_subgroupOpsShaderStagesBitPattern<device_capabilities>::value;
const static bool shaderSubgroupClustered = impl::get_or_default_shaderSubgroupClustered<device_capabilities>::value;
const static bool shaderSubgroupArithmetic = impl::get_or_default_shaderSubgroupArithmetic<device_capabilities>::value;
const static bool shaderSubgroupQuad = impl::get_or_default_shaderSubgroupQuad<device_capabilities>::value;
const static bool shaderSubgroupQuadAllStages = impl::get_or_default_shaderSubgroupQuadAllStages<device_capabilities>::value;

const static uint64_t pointClippingBehaviorBitPattern = impl::get_or_default_pointClippingBehaviorBitPattern<device_capabilities>::value;

const static uint16_t maxMultiviewViewCount = impl::get_or_default_maxMultiviewViewCount<device_capabilities>::value;
const static uint32_t maxMultiviewInstanceIndex = impl::get_or_default_maxMultiviewInstanceIndex<device_capabilities>::value;

const static uint32_t maxPerSetDescriptors = impl::get_or_default_maxPerSetDescriptors<device_capabilities>::value;
const static uint64_t maxMemoryAllocationSize = impl::get_or_default_maxMemoryAllocationSize<device_capabilities>::value;

// VK 1.2
const static bool shaderSignedZeroInfNanPreserveFloat64 = impl::get_or_default_shaderSignedZeroInfNanPreserveFloat64<device_capabilities>::value;
const static bool shaderDenormPreserveFloat16 = impl::get_or_default_shaderDenormPreserveFloat16<device_capabilities>::value;
const static bool shaderDenormPreserveFloat32 = impl::get_or_default_shaderDenormPreserveFloat32<device_capabilities>::value;
const static bool shaderDenormPreserveFloat64 = impl::get_or_default_shaderDenormPreserveFloat64<device_capabilities>::value;
const static bool shaderDenormFlushToZeroFloat16 = impl::get_or_default_shaderDenormFlushToZeroFloat16<device_capabilities>::value;
const static bool shaderDenormFlushToZeroFloat32 = impl::get_or_default_shaderDenormFlushToZeroFloat32<device_capabilities>::value;
const static bool shaderDenormFlushToZeroFloat64 = impl::get_or_default_shaderDenormFlushToZeroFloat64<device_capabilities>::value;
const static bool shaderRoundingModeRTEFloat16 = impl::get_or_default_shaderRoundingModeRTEFloat16<device_capabilities>::value;
const static bool shaderRoundingModeRTEFloat32 = impl::get_or_default_shaderRoundingModeRTEFloat32<device_capabilities>::value;
const static bool shaderRoundingModeRTEFloat64 = impl::get_or_default_shaderRoundingModeRTEFloat64<device_capabilities>::value;
const static bool shaderRoundingModeRTZFloat16 = impl::get_or_default_shaderRoundingModeRTZFloat16<device_capabilities>::value;
const static bool shaderRoundingModeRTZFloat32 = impl::get_or_default_shaderRoundingModeRTZFloat32<device_capabilities>::value;
const static bool shaderRoundingModeRTZFloat64 = impl::get_or_default_shaderRoundingModeRTZFloat64<device_capabilities>::value;

const static uint32_t maxUpdateAfterBindDescriptorsInAllPools = impl::get_or_default_maxUpdateAfterBindDescriptorsInAllPools<device_capabilities>::value;
const static bool shaderUniformBufferArrayNonUniformIndexingNative = impl::get_or_default_shaderUniformBufferArrayNonUniformIndexingNative<device_capabilities>::value;
const static bool shaderSampledImageArrayNonUniformIndexingNative = impl::get_or_default_shaderSampledImageArrayNonUniformIndexingNative<device_capabilities>::value;
const static bool shaderStorageBufferArrayNonUniformIndexingNative = impl::get_or_default_shaderStorageBufferArrayNonUniformIndexingNative<device_capabilities>::value;
const static bool shaderStorageImageArrayNonUniformIndexingNative = impl::get_or_default_shaderStorageImageArrayNonUniformIndexingNative<device_capabilities>::value;
const static bool shaderInputAttachmentArrayNonUniformIndexingNative = impl::get_or_default_shaderInputAttachmentArrayNonUniformIndexingNative<device_capabilities>::value;
const static bool robustBufferAccessUpdateAfterBind = impl::get_or_default_robustBufferAccessUpdateAfterBind<device_capabilities>::value;
const static bool quadDivergentImplicitLod = impl::get_or_default_quadDivergentImplicitLod<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorUpdateAfterBindSamplers = impl::get_or_default_maxPerStageDescriptorUpdateAfterBindSamplers<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorUpdateAfterBindUBOs = impl::get_or_default_maxPerStageDescriptorUpdateAfterBindUBOs<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorUpdateAfterBindSSBOs = impl::get_or_default_maxPerStageDescriptorUpdateAfterBindSSBOs<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorUpdateAfterBindImages = impl::get_or_default_maxPerStageDescriptorUpdateAfterBindImages<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages = impl::get_or_default_maxPerStageDescriptorUpdateAfterBindStorageImages<device_capabilities>::value;
const static uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments = impl::get_or_default_maxPerStageDescriptorUpdateAfterBindInputAttachments<device_capabilities>::value;
const static uint32_t maxPerStageUpdateAfterBindResources = impl::get_or_default_maxPerStageUpdateAfterBindResources<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindSamplers = impl::get_or_default_maxDescriptorSetUpdateAfterBindSamplers<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindUBOs = impl::get_or_default_maxDescriptorSetUpdateAfterBindUBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs = impl::get_or_default_maxDescriptorSetUpdateAfterBindDynamicOffsetUBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindSSBOs = impl::get_or_default_maxDescriptorSetUpdateAfterBindSSBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs = impl::get_or_default_maxDescriptorSetUpdateAfterBindDynamicOffsetSSBOs<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindImages = impl::get_or_default_maxDescriptorSetUpdateAfterBindImages<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindStorageImages = impl::get_or_default_maxDescriptorSetUpdateAfterBindStorageImages<device_capabilities>::value;
const static uint32_t maxDescriptorSetUpdateAfterBindInputAttachments = impl::get_or_default_maxDescriptorSetUpdateAfterBindInputAttachments<device_capabilities>::value;

const static uint64_t supportedDepthResolveModesBitPattern = impl::get_or_default_supportedDepthResolveModesBitPattern<device_capabilities>::value;
const static uint64_t supportedStencilResolveModesBitPattern = impl::get_or_default_supportedStencilResolveModesBitPattern<device_capabilities>::value;

const static bool filterMinmaxImageComponentMapping = impl::get_or_default_filterMinmaxImageComponentMapping<device_capabilities>::value;

// VK 1.3
const static uint16_t minSubgroupSize = impl::get_or_default_minSubgroupSize<device_capabilities>::value;
const static uint16_t maxSubgroupSize = impl::get_or_default_maxSubgroupSize<device_capabilities>::value;
const static uint32_t maxComputeWorkgroupSubgroups = impl::get_or_default_maxComputeWorkgroupSubgroups<device_capabilities>::value;
const static uint64_t requiredSubgroupSizeStagesBitPattern = impl::get_or_default_requiredSubgroupSizeStagesBitPattern<device_capabilities>::value;

const static bool integerDotProduct8BitUnsignedAccelerated = impl::get_or_default_integerDotProduct8BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct8BitSignedAccelerated = impl::get_or_default_integerDotProduct8BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct8BitMixedSignednessAccelerated = impl::get_or_default_integerDotProduct8BitMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProduct4x8BitPackedUnsignedAccelerated = impl::get_or_default_integerDotProduct4x8BitPackedUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct4x8BitPackedSignedAccelerated = impl::get_or_default_integerDotProduct4x8BitPackedSignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct4x8BitPackedMixedSignednessAccelerated = impl::get_or_default_integerDotProduct4x8BitPackedMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProduct16BitUnsignedAccelerated = impl::get_or_default_integerDotProduct16BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct16BitSignedAccelerated = impl::get_or_default_integerDotProduct16BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct16BitMixedSignednessAccelerated = impl::get_or_default_integerDotProduct16BitMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProduct32BitUnsignedAccelerated = impl::get_or_default_integerDotProduct32BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct32BitSignedAccelerated = impl::get_or_default_integerDotProduct32BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct32BitMixedSignednessAccelerated = impl::get_or_default_integerDotProduct32BitMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProduct64BitUnsignedAccelerated = impl::get_or_default_integerDotProduct64BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct64BitSignedAccelerated = impl::get_or_default_integerDotProduct64BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProduct64BitMixedSignednessAccelerated = impl::get_or_default_integerDotProduct64BitMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating8BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating8BitSignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating8BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating16BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating16BitSignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating16BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating32BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating32BitSignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating32BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating64BitUnsignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating64BitSignedAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating64BitSignedAccelerated<device_capabilities>::value;
const static bool integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = impl::get_or_default_integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated<device_capabilities>::value;

const static uint64_t storageTexelBufferOffsetAlignmentBytes = impl::get_or_default_storageTexelBufferOffsetAlignmentBytes<device_capabilities>::value;
const static uint64_t uniformTexelBufferOffsetAlignmentBytes = impl::get_or_default_uniformTexelBufferOffsetAlignmentBytes<device_capabilities>::value;

const static uint64_t maxBufferSize = impl::get_or_default_maxBufferSize<device_capabilities>::value;

// Nabla Core Extensions
const static uint32_t minImportedHostPointerAlignment = impl::get_or_default_minImportedHostPointerAlignment<device_capabilities>::value;

const static bool shaderBufferFloat32AtomicAdd = impl::get_or_default_shaderBufferFloat32AtomicAdd<device_capabilities>::value;
const static bool shaderBufferFloat64Atomics = impl::get_or_default_shaderBufferFloat64Atomics<device_capabilities>::value;
const static bool shaderBufferFloat64AtomicAdd = impl::get_or_default_shaderBufferFloat64AtomicAdd<device_capabilities>::value;
const static bool shaderSharedFloat32AtomicAdd = impl::get_or_default_shaderSharedFloat32AtomicAdd<device_capabilities>::value;
const static bool shaderSharedFloat64Atomics = impl::get_or_default_shaderSharedFloat64Atomics<device_capabilities>::value;
const static bool shaderSharedFloat64AtomicAdd = impl::get_or_default_shaderSharedFloat64AtomicAdd<device_capabilities>::value;
const static bool shaderImageFloat32AtomicAdd = impl::get_or_default_shaderImageFloat32AtomicAdd<device_capabilities>::value;
const static bool sparseImageFloat32Atomics = impl::get_or_default_sparseImageFloat32Atomics<device_capabilities>::value;
const static bool sparseImageFloat32AtomicAdd = impl::get_or_default_sparseImageFloat32AtomicAdd<device_capabilities>::value;

const static uint64_t robustStorageBufferAccessSizeAlignment = impl::get_or_default_robustStorageBufferAccessSizeAlignment<device_capabilities>::value;
const static uint64_t robustUniformBufferAccessSizeAlignment = impl::get_or_default_robustUniformBufferAccessSizeAlignment<device_capabilities>::value;

// Extensions
const static bool shaderTrinaryMinmax = impl::get_or_default_shaderTrinaryMinmax<device_capabilities>::value;

const static bool shaderExplicitVertexParameter = impl::get_or_default_shaderExplicitVertexParameter<device_capabilities>::value;

const static bool gpuShaderHalfFloatAMD = impl::get_or_default_gpuShaderHalfFloatAMD<device_capabilities>::value;

const static bool shaderImageLoadStoreLod = impl::get_or_default_shaderImageLoadStoreLod<device_capabilities>::value;

const static bool displayTiming = impl::get_or_default_displayTiming<device_capabilities>::value;

const static uint32_t maxDiscardRectangles = impl::get_or_default_maxDiscardRectangles<device_capabilities>::value;

const static uint32_t primitiveOverestimationSizeBitPattern = impl::get_or_default_primitiveOverestimationSizeBitPattern<device_capabilities>::value;
const static uint32_t maxExtraPrimitiveOverestimationSizeBitPattern = impl::get_or_default_maxExtraPrimitiveOverestimationSizeBitPattern<device_capabilities>::value;
const static uint32_t extraPrimitiveOverestimationSizeGranularityBitPattern = impl::get_or_default_extraPrimitiveOverestimationSizeGranularityBitPattern<device_capabilities>::value;
const static bool primitiveUnderestimation = impl::get_or_default_primitiveUnderestimation<device_capabilities>::value;
const static bool conservativePointAndLineRasterization = impl::get_or_default_conservativePointAndLineRasterization<device_capabilities>::value;
const static bool degenerateTrianglesRasterized = impl::get_or_default_degenerateTrianglesRasterized<device_capabilities>::value;
const static bool degenerateLinesRasterized = impl::get_or_default_degenerateLinesRasterized<device_capabilities>::value;
const static bool fullyCoveredFragmentShaderInputVariable = impl::get_or_default_fullyCoveredFragmentShaderInputVariable<device_capabilities>::value;
const static bool conservativeRasterizationPostDepthCoverage = impl::get_or_default_conservativeRasterizationPostDepthCoverage<device_capabilities>::value;

const static bool queueFamilyForeign = impl::get_or_default_queueFamilyForeign<device_capabilities>::value;

const static bool shaderStencilExport = impl::get_or_default_shaderStencilExport<device_capabilities>::value;

const static bool variableSampleLocations = impl::get_or_default_variableSampleLocations<device_capabilities>::value;
const static uint16_t sampleLocationSubPixelBits = impl::get_or_default_sampleLocationSubPixelBits<device_capabilities>::value;
const static uint64_t sampleLocationSampleCountsBitPattern = impl::get_or_default_sampleLocationSampleCountsBitPattern<device_capabilities>::value;
const static uint32_t maxSampleLocationGridSizeX = impl::get_or_default_maxSampleLocationGridSizeX<device_capabilities>::value;
const static uint32_t maxSampleLocationGridSizeY = impl::get_or_default_maxSampleLocationGridSizeY<device_capabilities>::value;
const static uint32_t sampleLocationCoordinateRangeBitPatternMin = impl::get_or_default_sampleLocationCoordinateRangeBitPatternMin<device_capabilities>::value;
const static uint32_t sampleLocationCoordinateRangeBitPatternMax = impl::get_or_default_sampleLocationCoordinateRangeBitPatternMax<device_capabilities>::value;

const static uint64_t maxAccelerationStructureGeometryCount = impl::get_or_default_maxAccelerationStructureGeometryCount<device_capabilities>::value;
const static uint64_t maxAccelerationStructureInstanceCount = impl::get_or_default_maxAccelerationStructureInstanceCount<device_capabilities>::value;
const static uint64_t maxAccelerationStructurePrimitiveCount = impl::get_or_default_maxAccelerationStructurePrimitiveCount<device_capabilities>::value;
const static uint64_t maxPerStageDescriptorAccelerationStructures = impl::get_or_default_maxPerStageDescriptorAccelerationStructures<device_capabilities>::value;
const static uint64_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures = impl::get_or_default_maxPerStageDescriptorUpdateAfterBindAccelerationStructures<device_capabilities>::value;
const static uint64_t maxDescriptorSetAccelerationStructures = impl::get_or_default_maxDescriptorSetAccelerationStructures<device_capabilities>::value;
const static uint64_t maxDescriptorSetUpdateAfterBindAccelerationStructures = impl::get_or_default_maxDescriptorSetUpdateAfterBindAccelerationStructures<device_capabilities>::value;
const static uint64_t minAccelerationStructureScratchOffsetAlignment = impl::get_or_default_minAccelerationStructureScratchOffsetAlignment<device_capabilities>::value;

const static uint32_t maxRayRecursionDepth = impl::get_or_default_maxRayRecursionDepth<device_capabilities>::value;
const static uint32_t maxShaderGroupStride = impl::get_or_default_maxShaderGroupStride<device_capabilities>::value;
const static uint32_t shaderGroupBaseAlignment = impl::get_or_default_shaderGroupBaseAlignment<device_capabilities>::value;
const static uint32_t maxRayDispatchInvocationCount = impl::get_or_default_maxRayDispatchInvocationCount<device_capabilities>::value;
const static uint32_t shaderGroupHandleAlignment = impl::get_or_default_shaderGroupHandleAlignment<device_capabilities>::value;
const static uint32_t maxRayHitAttributeSize = impl::get_or_default_maxRayHitAttributeSize<device_capabilities>::value;

const static bool shaderSMBuiltins = impl::get_or_default_shaderSMBuiltins<device_capabilities>::value;

const static bool postDepthCoverage = impl::get_or_default_postDepthCoverage<device_capabilities>::value;

const static bool computeDerivativeGroupQuads = impl::get_or_default_computeDerivativeGroupQuads<device_capabilities>::value;
const static bool computeDerivativeGroupLinear = impl::get_or_default_computeDerivativeGroupLinear<device_capabilities>::value;

const static uint32_t pciDomain = impl::get_or_default_pciDomain<device_capabilities>::value;
const static uint32_t pciBus = impl::get_or_default_pciBus<device_capabilities>::value;
const static uint32_t pciDevice = impl::get_or_default_pciDevice<device_capabilities>::value;
const static uint32_t pciFunction = impl::get_or_default_pciFunction<device_capabilities>::value;

const static uint32_t minFragmentDensityTexelSizeX = impl::get_or_default_minFragmentDensityTexelSizeX<device_capabilities>::value;
const static uint32_t minFragmentDensityTexelSizeY = impl::get_or_default_minFragmentDensityTexelSizeY<device_capabilities>::value;
const static uint32_t maxFragmentDensityTexelSizeX = impl::get_or_default_maxFragmentDensityTexelSizeX<device_capabilities>::value;
const static uint32_t maxFragmentDensityTexelSizeY = impl::get_or_default_maxFragmentDensityTexelSizeY<device_capabilities>::value;
const static bool fragmentDensityInvocations = impl::get_or_default_fragmentDensityInvocations<device_capabilities>::value;

const static bool decorateString = impl::get_or_default_decorateString<device_capabilities>::value;

const static bool shaderImageInt64Atomics = impl::get_or_default_shaderImageInt64Atomics<device_capabilities>::value;
const static bool sparseImageInt64Atomics = impl::get_or_default_sparseImageInt64Atomics<device_capabilities>::value;

const static uint32_t lineSubPixelPrecisionBits = impl::get_or_default_lineSubPixelPrecisionBits<device_capabilities>::value;

const static bool shaderBufferFloat16Atomics = impl::get_or_default_shaderBufferFloat16Atomics<device_capabilities>::value;
const static bool shaderBufferFloat16AtomicAdd = impl::get_or_default_shaderBufferFloat16AtomicAdd<device_capabilities>::value;
const static bool shaderBufferFloat16AtomicMinMax = impl::get_or_default_shaderBufferFloat16AtomicMinMax<device_capabilities>::value;
const static bool shaderBufferFloat32AtomicMinMax = impl::get_or_default_shaderBufferFloat32AtomicMinMax<device_capabilities>::value;
const static bool shaderBufferFloat64AtomicMinMax = impl::get_or_default_shaderBufferFloat64AtomicMinMax<device_capabilities>::value;
const static bool shaderSharedFloat16Atomics = impl::get_or_default_shaderSharedFloat16Atomics<device_capabilities>::value;
const static bool shaderSharedFloat16AtomicAdd = impl::get_or_default_shaderSharedFloat16AtomicAdd<device_capabilities>::value;
const static bool shaderSharedFloat16AtomicMinMax = impl::get_or_default_shaderSharedFloat16AtomicMinMax<device_capabilities>::value;
const static bool shaderSharedFloat32AtomicMinMax = impl::get_or_default_shaderSharedFloat32AtomicMinMax<device_capabilities>::value;
const static bool shaderSharedFloat64AtomicMinMax = impl::get_or_default_shaderSharedFloat64AtomicMinMax<device_capabilities>::value;
const static bool shaderImageFloat32AtomicMinMax = impl::get_or_default_shaderImageFloat32AtomicMinMax<device_capabilities>::value;
const static bool sparseImageFloat32AtomicMinMax = impl::get_or_default_sparseImageFloat32AtomicMinMax<device_capabilities>::value;

const static bool deviceMemoryReport = impl::get_or_default_deviceMemoryReport<device_capabilities>::value;

const static bool shaderNonSemanticInfo = impl::get_or_default_shaderNonSemanticInfo<device_capabilities>::value;

const static bool fragmentShaderBarycentric = impl::get_or_default_fragmentShaderBarycentric<device_capabilities>::value;

const static bool shaderSubgroupUniformControlFlow = impl::get_or_default_shaderSubgroupUniformControlFlow<device_capabilities>::value;

const static bool subsampledLoads = impl::get_or_default_subsampledLoads<device_capabilities>::value;
const static bool subsampledCoarseReconstructionEarlyAccess = impl::get_or_default_subsampledCoarseReconstructionEarlyAccess<device_capabilities>::value;
const static uint32_t maxSubsampledArrayLayers = impl::get_or_default_maxSubsampledArrayLayers<device_capabilities>::value;
const static uint32_t maxDescriptorSetSubsampledSamplers = impl::get_or_default_maxDescriptorSetSubsampledSamplers<device_capabilities>::value;

const static bool workgroupMemoryExplicitLayout = impl::get_or_default_workgroupMemoryExplicitLayout<device_capabilities>::value;
const static bool workgroupMemoryExplicitLayoutScalarBlockLayout = impl::get_or_default_workgroupMemoryExplicitLayoutScalarBlockLayout<device_capabilities>::value;
const static bool workgroupMemoryExplicitLayout8BitAccess = impl::get_or_default_workgroupMemoryExplicitLayout8BitAccess<device_capabilities>::value;
const static bool workgroupMemoryExplicitLayout16BitAccess = impl::get_or_default_workgroupMemoryExplicitLayout16BitAccess<device_capabilities>::value;

const static bool colorWriteEnable = impl::get_or_default_colorWriteEnable<device_capabilities>::value;

const static uint64_t cooperativeMatrixSupportedStagesBitPattern = impl::get_or_default_cooperativeMatrixSupportedStagesBitPattern<device_capabilities>::value;

// Nabla
const static uint32_t computeUnits = impl::get_or_default_computeUnits<device_capabilities>::value;
const static bool dispatchBase = impl::get_or_default_dispatchBase<device_capabilities>::value;
const static bool allowCommandBufferQueryCopies = impl::get_or_default_allowCommandBufferQueryCopies<device_capabilities>::value;
const static uint32_t maxOptimallyResidentWorkgroupInvocations = impl::get_or_default_maxOptimallyResidentWorkgroupInvocations<device_capabilities>::value;
const static uint32_t maxResidentInvocations = impl::get_or_default_maxResidentInvocations<device_capabilities>::value;
const static uint64_t spirvVersionBitPattern = impl::get_or_default_spirvVersionBitPattern<device_capabilities>::value;

const static bool logicOp = impl::get_or_default_logicOp<device_capabilities>::value;
const static bool vertexPipelineStoresAndAtomics = impl::get_or_default_vertexPipelineStoresAndAtomics<device_capabilities>::value;
const static bool fragmentStoresAndAtomics = impl::get_or_default_fragmentStoresAndAtomics<device_capabilities>::value;
const static bool shaderTessellationAndGeometryPointSize = impl::get_or_default_shaderTessellationAndGeometryPointSize<device_capabilities>::value;
const static bool shaderStorageImageMultisample = impl::get_or_default_shaderStorageImageMultisample<device_capabilities>::value;
const static bool shaderStorageImageReadWithoutFormat = impl::get_or_default_shaderStorageImageReadWithoutFormat<device_capabilities>::value;
const static bool shaderStorageImageArrayDynamicIndexing = impl::get_or_default_shaderStorageImageArrayDynamicIndexing<device_capabilities>::value;
const static bool shaderFloat64 = impl::get_or_default_shaderFloat64<device_capabilities>::value;
const static bool variableMultisampleRate = impl::get_or_default_variableMultisampleRate<device_capabilities>::value;
const static bool storagePushConstant16 = impl::get_or_default_storagePushConstant16<device_capabilities>::value;
const static bool storageInputOutput16 = impl::get_or_default_storageInputOutput16<device_capabilities>::value;
const static bool multiviewGeometryShader = impl::get_or_default_multiviewGeometryShader<device_capabilities>::value;
const static bool multiviewTessellationShader = impl::get_or_default_multiviewTessellationShader<device_capabilities>::value;
const static bool drawIndirectCount = impl::get_or_default_drawIndirectCount<device_capabilities>::value;
const static bool storagePushConstant8 = impl::get_or_default_storagePushConstant8<device_capabilities>::value;
const static bool shaderBufferInt64Atomics = impl::get_or_default_shaderBufferInt64Atomics<device_capabilities>::value;
const static bool shaderSharedInt64Atomics = impl::get_or_default_shaderSharedInt64Atomics<device_capabilities>::value;
const static bool shaderFloat16 = impl::get_or_default_shaderFloat16<device_capabilities>::value;
const static bool shaderInputAttachmentArrayDynamicIndexing = impl::get_or_default_shaderInputAttachmentArrayDynamicIndexing<device_capabilities>::value;
const static bool shaderUniformBufferArrayNonUniformIndexing = impl::get_or_default_shaderUniformBufferArrayNonUniformIndexing<device_capabilities>::value;
const static bool shaderInputAttachmentArrayNonUniformIndexing = impl::get_or_default_shaderInputAttachmentArrayNonUniformIndexing<device_capabilities>::value;
const static bool descriptorBindingUniformBufferUpdateAfterBind = impl::get_or_default_descriptorBindingUniformBufferUpdateAfterBind<device_capabilities>::value;
const static bool samplerFilterMinmax = impl::get_or_default_samplerFilterMinmax<device_capabilities>::value;
const static bool vulkanMemoryModelAvailabilityVisibilityChains = impl::get_or_default_vulkanMemoryModelAvailabilityVisibilityChains<device_capabilities>::value;
const static bool shaderOutputViewportIndex = impl::get_or_default_shaderOutputViewportIndex<device_capabilities>::value;
const static bool shaderOutputLayer = impl::get_or_default_shaderOutputLayer<device_capabilities>::value;
const static bool shaderDemoteToHelperInvocation = impl::get_or_default_shaderDemoteToHelperInvocation<device_capabilities>::value;
const static bool shaderTerminateInvocation = impl::get_or_default_shaderTerminateInvocation<device_capabilities>::value;
const static bool shaderZeroInitializeWorkgroupMemory = impl::get_or_default_shaderZeroInitializeWorkgroupMemory<device_capabilities>::value;
const static bool shaderDeviceClock = impl::get_or_default_shaderDeviceClock<device_capabilities>::value;
const static bool shaderSubgroupClock = impl::get_or_default_shaderSubgroupClock<device_capabilities>::value;
const static bool imageFootprint = impl::get_or_default_imageFootprint<device_capabilities>::value;
const static bool shaderIntegerFunctions2 = impl::get_or_default_shaderIntegerFunctions2<device_capabilities>::value;
const static bool shaderEarlyAndLateFragmentTests = impl::get_or_default_shaderEarlyAndLateFragmentTests<device_capabilities>::value;
const static bool rayTracingPositionFetch = impl::get_or_default_rayTracingPositionFetch<device_capabilities>::value;
const static bool cooperativeMatrix = impl::get_or_default_cooperativeMatrix<device_capabilities>::value;

// Features Members
// VK 1.0
const static bool robustBufferAccess = impl::get_or_default_robustBufferAccess<device_capabilities>::value;

const static bool geometryShader = impl::get_or_default_geometryShader<device_capabilities>::value;
const static bool tessellationShader = impl::get_or_default_tessellationShader<device_capabilities>::value;

const static bool depthBounds = impl::get_or_default_depthBounds<device_capabilities>::value;

const static bool wideLines = impl::get_or_default_wideLines<device_capabilities>::value;
const static bool largePoints = impl::get_or_default_largePoints<device_capabilities>::value;

const static bool alphaToOne = impl::get_or_default_alphaToOne<device_capabilities>::value;

const static bool pipelineStatisticsQuery = impl::get_or_default_pipelineStatisticsQuery<device_capabilities>::value;

const static bool shaderCullDistance = impl::get_or_default_shaderCullDistance<device_capabilities>::value;

const static bool shaderResourceResidency = impl::get_or_default_shaderResourceResidency<device_capabilities>::value;
const static bool shaderResourceMinLod = impl::get_or_default_shaderResourceMinLod<device_capabilities>::value;

// VK 1.1
// VK 1.2
const static bool bufferDeviceAddressMultiDevice = impl::get_or_default_bufferDeviceAddressMultiDevice<device_capabilities>::value;

// VK 1.3
const static bool robustImageAccess = impl::get_or_default_robustImageAccess<device_capabilities>::value;

// Nabla Core Extensions
const static bool robustBufferAccess2 = impl::get_or_default_robustBufferAccess2<device_capabilities>::value;
const static bool robustImageAccess2 = impl::get_or_default_robustImageAccess2<device_capabilities>::value;
const static bool nullDescriptor = impl::get_or_default_nullDescriptor<device_capabilities>::value;

// Extensions
const static uint64_t swapchainModeBitPattern = impl::get_or_default_swapchainModeBitPattern<device_capabilities>::value;

const static bool shaderInfoAMD = impl::get_or_default_shaderInfoAMD<device_capabilities>::value;

const static bool conditionalRendering = impl::get_or_default_conditionalRendering<device_capabilities>::value;
const static bool inheritedConditionalRendering = impl::get_or_default_inheritedConditionalRendering<device_capabilities>::value;

const static bool geometryShaderPassthrough = impl::get_or_default_geometryShaderPassthrough<device_capabilities>::value;

const static bool hdrMetadata = impl::get_or_default_hdrMetadata<device_capabilities>::value;

const static bool performanceCounterQueryPools = impl::get_or_default_performanceCounterQueryPools<device_capabilities>::value;
const static bool performanceCounterMultipleQueryPools = impl::get_or_default_performanceCounterMultipleQueryPools<device_capabilities>::value;

const static bool mixedAttachmentSamples = impl::get_or_default_mixedAttachmentSamples<device_capabilities>::value;

const static bool accelerationStructure = impl::get_or_default_accelerationStructure<device_capabilities>::value;
const static bool accelerationStructureIndirectBuild = impl::get_or_default_accelerationStructureIndirectBuild<device_capabilities>::value;
const static bool accelerationStructureHostCommands = impl::get_or_default_accelerationStructureHostCommands<device_capabilities>::value;

const static bool rayTracingPipeline = impl::get_or_default_rayTracingPipeline<device_capabilities>::value;
const static bool rayTraversalPrimitiveCulling = impl::get_or_default_rayTraversalPrimitiveCulling<device_capabilities>::value;

const static bool rayQuery = impl::get_or_default_rayQuery<device_capabilities>::value;

const static bool representativeFragmentTest = impl::get_or_default_representativeFragmentTest<device_capabilities>::value;

const static bool bufferMarkerAMD = impl::get_or_default_bufferMarkerAMD<device_capabilities>::value;

const static bool fragmentDensityMap = impl::get_or_default_fragmentDensityMap<device_capabilities>::value;
const static bool fragmentDensityMapDynamic = impl::get_or_default_fragmentDensityMapDynamic<device_capabilities>::value;
const static bool fragmentDensityMapNonSubsampledImages = impl::get_or_default_fragmentDensityMapNonSubsampledImages<device_capabilities>::value;

const static bool deviceCoherentMemory = impl::get_or_default_deviceCoherentMemory<device_capabilities>::value;

const static bool memoryPriority = impl::get_or_default_memoryPriority<device_capabilities>::value;

const static bool fragmentShaderSampleInterlock = impl::get_or_default_fragmentShaderSampleInterlock<device_capabilities>::value;
const static bool fragmentShaderPixelInterlock = impl::get_or_default_fragmentShaderPixelInterlock<device_capabilities>::value;
const static bool fragmentShaderShadingRateInterlock = impl::get_or_default_fragmentShaderShadingRateInterlock<device_capabilities>::value;

const static bool rectangularLines = impl::get_or_default_rectangularLines<device_capabilities>::value;
const static bool bresenhamLines = impl::get_or_default_bresenhamLines<device_capabilities>::value;
const static bool smoothLines = impl::get_or_default_smoothLines<device_capabilities>::value;
const static bool stippledRectangularLines = impl::get_or_default_stippledRectangularLines<device_capabilities>::value;
const static bool stippledBresenhamLines = impl::get_or_default_stippledBresenhamLines<device_capabilities>::value;
const static bool stippledSmoothLines = impl::get_or_default_stippledSmoothLines<device_capabilities>::value;

const static bool indexTypeUint8 = impl::get_or_default_indexTypeUint8<device_capabilities>::value;

const static bool deferredHostOperations = impl::get_or_default_deferredHostOperations<device_capabilities>::value;

const static bool pipelineExecutableInfo = impl::get_or_default_pipelineExecutableInfo<device_capabilities>::value;

const static bool deviceGeneratedCommands = impl::get_or_default_deviceGeneratedCommands<device_capabilities>::value;

const static bool rayTracingMotionBlur = impl::get_or_default_rayTracingMotionBlur<device_capabilities>::value;
const static bool rayTracingMotionBlurPipelineTraceRaysIndirect = impl::get_or_default_rayTracingMotionBlurPipelineTraceRaysIndirect<device_capabilities>::value;

const static bool fragmentDensityMapDeferred = impl::get_or_default_fragmentDensityMapDeferred<device_capabilities>::value;

const static bool rasterizationOrderColorAttachmentAccess = impl::get_or_default_rasterizationOrderColorAttachmentAccess<device_capabilities>::value;
const static bool rasterizationOrderDepthAttachmentAccess = impl::get_or_default_rasterizationOrderDepthAttachmentAccess<device_capabilities>::value;
const static bool rasterizationOrderStencilAttachmentAccess = impl::get_or_default_rasterizationOrderStencilAttachmentAccess<device_capabilities>::value;

const static bool cooperativeMatrixRobustBufferAccess = impl::get_or_default_cooperativeMatrixRobustBufferAccess<device_capabilities>::value;

// Nabla

#line 1 "C:/Users/fjlet/Desktop/Nabla/build/src/nbl/device/include/nbl/video/device_capabilities_traits_floats.hlsl"
// Limits Floats
// VK 1.0
static float maxSamplerLodBias() { return asfloat(maxSamplerLodBiasBitPattern); }

static float viewportBoundsRangeMin() { return asfloat(viewportBoundsRangeBitPatternMin); }
static float viewportBoundsRangeMax() { return asfloat(viewportBoundsRangeBitPatternMax); }

static float minInterpolationOffset() { return asfloat(minInterpolationOffsetBitPattern); }
static float maxInterpolationOffset() { return asfloat(maxInterpolationOffsetBitPattern); }

static float timestampPeriodInNanoSeconds() { return asfloat(timestampPeriodInNanoSecondsBitPattern); }

static float pointSizeRangeMin() { return asfloat(pointSizeRangeBitPatternMin); }
static float pointSizeRangeMax() { return asfloat(pointSizeRangeBitPatternMax); }
static float lineWidthRangeMin() { return asfloat(lineWidthRangeBitPatternMin); }
static float lineWidthRangeMax() { return asfloat(lineWidthRangeBitPatternMax); }
static float pointSizeGranularity() { return asfloat(pointSizeGranularityBitPattern); }
static float lineWidthGranularity() { return asfloat(lineWidthGranularityBitPattern); }

// VK 1.1
// VK 1.2
// VK 1.3
// Nabla Core Extensions
// Extensions
static float primitiveOverestimationSize() { return asfloat(primitiveOverestimationSizeBitPattern); }
static float maxExtraPrimitiveOverestimationSize() { return asfloat(maxExtraPrimitiveOverestimationSizeBitPattern); }
static float extraPrimitiveOverestimationSizeGranularity() { return asfloat(extraPrimitiveOverestimationSizeGranularityBitPattern); }

static float sampleLocationCoordinateRangeMin() { return asfloat(sampleLocationCoordinateRangeBitPatternMin); }
static float sampleLocationCoordinateRangeMax() { return asfloat(sampleLocationCoordinateRangeBitPatternMax); }

// Nabla
// Features Floats
// VK 1.0
// VK 1.1
// VK 1.2
// VK 1.3
// Nabla Core Extensions
// Extensions
// Nabla
#line 1 "C:/Users/fjlet/Desktop/Nabla/build/src/nbl/device/include/nbl/video/device_capabilities_traits_enums.hlsl"
// Limits Enums
// VK 1.0
// VK 1.1
static nbl::hlsl::ShaderStage subgroupOpsShaderStages() { return (nbl::hlsl::ShaderStage)subgroupOpsShaderStagesBitPattern; }

static nbl::hlsl::PointClippingBehavior pointClippingBehavior() { return (nbl::hlsl::PointClippingBehavior)pointClippingBehaviorBitPattern; }

// VK 1.2
static nbl::hlsl::ResolveModeFlags supportedDepthResolveModes() { return (nbl::hlsl::ResolveModeFlags)supportedDepthResolveModesBitPattern; }
static nbl::hlsl::ResolveModeFlags supportedStencilResolveModes() { return (nbl::hlsl::ResolveModeFlags)supportedStencilResolveModesBitPattern; }

// VK 1.3
static nbl::hlsl::ShaderStage requiredSubgroupSizeStages() { return (nbl::hlsl::ShaderStage)requiredSubgroupSizeStagesBitPattern; }

// Nabla Core Extensions
// Extensions
static nbl::hlsl::SampleCountFlags sampleLocationSampleCounts() { return (nbl::hlsl::SampleCountFlags)sampleLocationSampleCountsBitPattern; }

static nbl::hlsl::ShaderStage cooperativeMatrixSupportedStages() { return (nbl::hlsl::ShaderStage)cooperativeMatrixSupportedStagesBitPattern; }

// Nabla
static nbl::hlsl::SpirvVersion spirvVersion() { return (nbl::hlsl::SpirvVersion)spirvVersionBitPattern; }

// Features Enums
// VK 1.0
// VK 1.1
// VK 1.2
// VK 1.3
// Nabla Core Extensions
// Extensions
static nbl::hlsl::SwapchainMode swapchainMode() { return (nbl::hlsl::SwapchainMode)swapchainModeBitPattern; }

// Nabla
#line 48 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/device_capabilities_traits.hlsl"
};
}
}

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/float64_t.hlsl"
// define NBL_FORCE_EMULATED_FLOAT_64 to force using emulated float64

namespace nbl
{
namespace hlsl
{
template<typename device_caps = void>
#line 18 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/float64_t.hlsl"
using portable_float64_t = typename conditional<device_capabilities_traits<device_caps>::shaderFloat64, float64_t, emulated_float64_t<true, true> >::type;

#line 25 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/float64_t.hlsl"
//static_assert(sizeof(portable_float64_t) == sizeof(float64_t));

}
}

#line 7 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/int64_t.hlsl"
// define NBL_FORCE_EMULATED_INT_64 to force using emulated int64 types

namespace nbl
{
namespace hlsl
{
#line 20 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/int64_t.hlsl"
template<typename device_caps = void>
using portable_uint64_t = typename conditional<device_capabilities_traits<device_caps>::shaderInt64, uint64_t, emulated_uint64_t>::type;
template<typename device_caps = void>
using portable_int64_t = typename conditional<device_capabilities_traits<device_caps>::shaderInt64, int64_t, emulated_int64_t>::type;

#line 33 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/int64_t.hlsl"
}
}

#line 10 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
namespace nbl
{
namespace hlsl
{

namespace emulated_vector_impl
{

template<typename T>
struct _2_component_vec
{
 T x;
 T y;

_Static_assert(sizeof(T) <= 8);

inline void setComponent(uint32_t componentIdx, T val)
    {
        if (componentIdx == 0)
            x = val;
        if (componentIdx == 1)
            y = val;
    }

inline T getComponent(uint32_t componentIdx) 
    {
        if (componentIdx == 0)
            return x;
        if (componentIdx == 1)
            return y;

// TODO: avoid code duplication, make it constexpr
 //using TAsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
 //TAsUint invalidComponentValue = nbl::hlsl::_static_cast<TAsUint>(0xdeadbeefbadcaffeull);
 //return nbl::hlsl::bit_cast<T>(invalidComponentValue);
 return nbl::hlsl::undef<T>();
 }

const static uint32_t Dimension = 2;
};

template<typename T>
struct _3_component_vec
{
 T x;
 T y;
 T z;

inline void setComponent(uint32_t componentIdx, T val)
    {
        if (componentIdx == 0)
            x = val;
        if (componentIdx == 1)
            y = val;
        if (componentIdx == 2)
            z = val;
    }

inline T getComponent(uint32_t componentIdx) 
    {
        if (componentIdx == 0)
            return x;
        if (componentIdx == 1)
            return y;
        if (componentIdx == 2)
            return z;

// TODO: avoid code duplication, make it constexpr
 //using TAsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
 //TAsUint invalidComponentValue = nbl::hlsl::_static_cast<TAsUint>(0xdeadbeefbadcaffeull >> (64 - sizeof(T) * 8));
 //return nbl::hlsl::bit_cast<T>(invalidComponentValue);
 return nbl::hlsl::undef<T>();
 }

const static uint32_t Dimension = 3;
};

template<typename T>
struct _4_component_vec
{
 T x;
 T y;
 T z;
 T w;

inline void setComponent(uint32_t componentIdx, T val)
    {
        if (componentIdx == 0)
            x = val;
        if (componentIdx == 1)
            y = val;
        if (componentIdx == 2)
            z = val;
        if (componentIdx == 3)
            w = val;
    }

inline T getComponent(uint32_t componentIdx) 
    {
        if (componentIdx == 0)
            return x;
        if (componentIdx == 1)
            return y;
        if (componentIdx == 2)
            return z;
        if (componentIdx == 3)
            return w;

// TODO: avoid code duplication, make it constexpr
 //using TAsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
 //uint64_t invalidComponentValue = nbl::hlsl::_static_cast<TAsUint>(0xdeadbeefbadcaffeull >> (64 - sizeof(T) * 8));
 //return nbl::hlsl::bit_cast<T>(invalidComponentValue);
 return nbl::hlsl::undef<T>();
 }

const static uint32_t Dimension = 4;
};

template <typename ComponentType, typename CRTP ,typename __requires=void >
struct emulated_vector;

// Generic ComponentType vectors still have to be partial specialized based on whether they're fundamental and/or integral

#line 221 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
// Fundamental, integral
template <typename ComponentType, typename CRTP> 
struct emulated_vector<ComponentType, CRTP ,::nbl::hlsl::enable_if_t<(is_fundamental_v<ComponentType>&& concepts::IntegralLikeScalar<ComponentType>),void> > : CRTP
{
 // Creation for fundamental type
 using this_t = emulated_vector<ComponentType, CRTP>;using component_t = ComponentType;static inline this_t create(this_t other){ CRTP output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, other.getComponent(i));}inline component_t calcComponentSum() { component_t sum = CRTP::getComponent(0); [[unroll]] for (uint32_t i = 1u; i < CRTP::Dimension; ++i) sum = sum + CRTP::getComponent(i); return sum;} static inline this_t create(vector<component_t, CRTP::Dimension> other){ this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, other[i]); return output;}
 // Operators, including integral
 inline this_t operator~() { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i).operator~()); return output;}
 inline this_t operator& (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) & val); return output;}inline this_t operator& (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) & other.getComponent(i)); return output;}inline this_t operator&(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) & other[i]); return output;}
 inline this_t operator| (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) | val); return output;}inline this_t operator| (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) | other.getComponent(i)); return output;}inline this_t operator|(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) | other[i]); return output;}
 inline this_t operator^ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) ^ val); return output;}inline this_t operator^ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) ^ other.getComponent(i)); return output;}inline this_t operator^(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) ^ other[i]); return output;}
 inline this_t operator-() { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i).operator-()); return output;}
 inline this_t operator+ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + val); return output;}inline this_t operator+ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + other.getComponent(i)); return output;}inline this_t operator+(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + other[i]); return output;}
 inline this_t operator- (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - val); return output;}inline this_t operator- (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - other.getComponent(i)); return output;}inline this_t operator-(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - other[i]); return output;}
 inline this_t operator* (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * val); return output;}inline this_t operator* (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * other.getComponent(i)); return output;}inline this_t operator*(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * other[i]); return output;}
 inline this_t operator/ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / val); return output;}inline this_t operator/ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / other.getComponent(i)); return output;}inline this_t operator/(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / other[i]); return output;}
 // Comparison operators
 inline vector<bool, CRTP::Dimension> operator== (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) == other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator== (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) == other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator!= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) != other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator!= (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) != other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator< (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) < other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator< (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) < other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator<= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) <= other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator<= (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) <= other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator> (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) > other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator> (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) > other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator>= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) >= other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator>= (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) >= other[i]; return output;}
};

// Fundamental, not integral
template <typename ComponentType, typename CRTP> 
struct emulated_vector<ComponentType, CRTP ,::nbl::hlsl::enable_if_t<(is_fundamental_v<ComponentType> && !concepts::IntegralLikeScalar<ComponentType>),void> > : CRTP
{
 // Creation for fundamental type
 using this_t = emulated_vector<ComponentType, CRTP>;using component_t = ComponentType;static inline this_t create(this_t other){ CRTP output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, other.getComponent(i));}inline component_t calcComponentSum() { component_t sum = CRTP::getComponent(0); [[unroll]] for (uint32_t i = 1u; i < CRTP::Dimension; ++i) sum = sum + CRTP::getComponent(i); return sum;} static inline this_t create(vector<component_t, CRTP::Dimension> other){ this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, other[i]); return output;}
 // Operators
 inline this_t operator-() { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i).operator-()); return output;}
 inline this_t operator+ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + val); return output;}inline this_t operator+ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + other.getComponent(i)); return output;}inline this_t operator+(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + other[i]); return output;}
 inline this_t operator- (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - val); return output;}inline this_t operator- (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - other.getComponent(i)); return output;}inline this_t operator-(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - other[i]); return output;}
 inline this_t operator* (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * val); return output;}inline this_t operator* (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * other.getComponent(i)); return output;}inline this_t operator*(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * other[i]); return output;}
 inline this_t operator/ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / val); return output;}inline this_t operator/ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / other.getComponent(i)); return output;}inline this_t operator/(vector<component_t, CRTP::Dimension> other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / other[i]); return output;}
 // Comparison operators
 inline vector<bool, CRTP::Dimension> operator== (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) == other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator== (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) == other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator!= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) != other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator!= (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) != other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator< (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) < other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator< (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) < other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator<= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) <= other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator<= (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) <= other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator> (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) > other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator> (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) > other[i]; return output;}
 inline vector<bool, CRTP::Dimension> operator>= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) >= other.getComponent(i); return output;}inline vector<bool, CRTP::Dimension> operator>= (vector<component_t, CRTP::Dimension> other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) >= other[i]; return output;}
};

// Not fundamental, integral
template <typename ComponentType, typename CRTP> 
struct emulated_vector<ComponentType, CRTP ,::nbl::hlsl::enable_if_t<(!is_fundamental_v<ComponentType> && concepts::IntegralLikeScalar<ComponentType>),void> > : CRTP
{
 // Creation
 using this_t = emulated_vector<ComponentType, CRTP>;using component_t = ComponentType;static inline this_t create(this_t other){ CRTP output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, other.getComponent(i));}inline component_t calcComponentSum() { component_t sum = CRTP::getComponent(0); [[unroll]] for (uint32_t i = 1u; i < CRTP::Dimension; ++i) sum = sum + CRTP::getComponent(i); return sum;}
 // Operators, including integral
 inline this_t operator~() { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i).operator~()); return output;}
 inline this_t operator& (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) & val); return output;}inline this_t operator& (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) & other.getComponent(i)); return output;}
 inline this_t operator| (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) | val); return output;}inline this_t operator| (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) | other.getComponent(i)); return output;}
 inline this_t operator^ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) ^ val); return output;}inline this_t operator^ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) ^ other.getComponent(i)); return output;}
 inline this_t operator-() { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i).operator-()); return output;}
 inline this_t operator+ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + val); return output;}inline this_t operator+ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + other.getComponent(i)); return output;}
 inline this_t operator- (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - val); return output;}inline this_t operator- (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - other.getComponent(i)); return output;}
 inline this_t operator* (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * val); return output;}inline this_t operator* (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * other.getComponent(i)); return output;}
 inline this_t operator/ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / val); return output;}inline this_t operator/ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / other.getComponent(i)); return output;}
 // Comparison operators
 inline vector<bool, CRTP::Dimension> operator== (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) == other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator!= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) != other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator< (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) < other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator<= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) <= other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator> (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) > other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator>= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) >= other.getComponent(i); return output;}
};

// Not fundamental, not integral
template <typename ComponentType, typename CRTP> 
struct emulated_vector<ComponentType, CRTP ,::nbl::hlsl::enable_if_t<(!is_fundamental_v<ComponentType> && !concepts::IntegralLikeScalar<ComponentType>),void> > : CRTP
{
 // Creation
 using this_t = emulated_vector<ComponentType, CRTP>;using component_t = ComponentType;static inline this_t create(this_t other){ CRTP output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, other.getComponent(i));}inline component_t calcComponentSum() { component_t sum = CRTP::getComponent(0); [[unroll]] for (uint32_t i = 1u; i < CRTP::Dimension; ++i) sum = sum + CRTP::getComponent(i); return sum;}
 // Operators
 inline this_t operator-() { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i).operator-()); return output;}
 inline this_t operator+ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + val); return output;}inline this_t operator+ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) + other.getComponent(i)); return output;}
 inline this_t operator- (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - val); return output;}inline this_t operator- (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) - other.getComponent(i)); return output;}
 inline this_t operator* (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * val); return output;}inline this_t operator* (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) * other.getComponent(i)); return output;}
 inline this_t operator/ (component_t val) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / val); return output;}inline this_t operator/ (this_t other) { this_t output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, this_t::getComponent(i) / other.getComponent(i)); return output;}
 // Comparison operators
 inline vector<bool, CRTP::Dimension> operator== (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) == other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator!= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) != other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator< (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) < other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator<= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) <= other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator> (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) > other.getComponent(i); return output;}
 inline vector<bool, CRTP::Dimension> operator>= (this_t other) { vector<bool, CRTP::Dimension> output; [[unroll]] for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output[i] = CRTP::getComponent(i) >= other.getComponent(i); return output;}
};

// ----------------------------------------------------- EMULATED FLOAT SPECIALIZATION --------------------------------------------------------------------

#line 353 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
template <bool FastMath, bool FlushDenormToZero, typename CRTP>
struct emulated_vector<emulated_float64_t<FastMath, FlushDenormToZero>, CRTP> : CRTP
{
 using component_t = emulated_float64_t<FastMath, FlushDenormToZero>;
 using this_t = emulated_vector<component_t, CRTP>;

static inline this_t create(this_t other)
    {
        this_t output;

for (uint32_t i = 0u; i < CRTP::Dimension; ++i)
 output.setComponent(i, other.getComponent(i));

return output;
    }

template<typename T>
 static inline this_t create(vector<T, CRTP::Dimension> other)
 {
 this_t output;

for (uint32_t i = 0u; i < CRTP::Dimension; ++i)
 output.setComponent(i, component_t::create(other[i]));

return output;
    }

inline this_t operator+(this_t other) 
    {
        this_t output;

for (uint32_t i = 0u; i < CRTP::Dimension; ++i)
 output.setComponent(i, CRTP::getComponent(i) + other.getComponent(i));

return output;
    }
    inline this_t operator-(this_t other) 
    {
        this_t output;

for (uint32_t i = 0u; i < CRTP::Dimension; ++i)
 output.setComponent(i, CRTP::getComponent(i) - other.getComponent(i));

return output;
    }
    inline this_t operator*(this_t other) 
    {
        this_t output;

for (uint32_t i = 0u; i < CRTP::Dimension; ++i)
 output.setComponent(i, CRTP::getComponent(i) * other.getComponent(i));

return output;
    }

inline this_t operator+(emulated_float64_t<true, true> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(emulated_float64_t<true, true> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(emulated_float64_t<true, true> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(emulated_float64_t<true, false> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(emulated_float64_t<true, false> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(emulated_float64_t<true, false> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(emulated_float64_t<false, true> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(emulated_float64_t<false, true> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(emulated_float64_t<false, true> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(emulated_float64_t<false, false> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(emulated_float64_t<false, false> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(emulated_float64_t<false, false> val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(float32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(float32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(float32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(float64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(float64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(float64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(uint16_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(uint16_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(uint16_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(uint32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(uint32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(uint32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(uint64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(uint64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(uint64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(int16_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(int16_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(int16_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(int32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(int32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(int32_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}
 inline this_t operator+(int64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) + component_t::create(val)); return output;}inline this_t operator-(int64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) - component_t::create(val)); return output;}inline this_t operator*(int64_t val) { this_t output; for (uint32_t i = 0u; i < CRTP::Dimension; ++i) output.setComponent(i, CRTP::getComponent(i) * component_t::create(val)); return output;}

inline component_t calcComponentSum() 
 {
 component_t sum = component_t::create(0);
 for (uint32_t i = 0u; i < CRTP::Dimension; ++i)
 sum = sum + CRTP::getComponent(i);

return sum;
    }
};

template<typename T, uint32_t N>
struct CRTPParentStructSelector
{
 using type = void;
};
template<typename T>
struct CRTPParentStructSelector<T, 2>
{
 using type = _2_component_vec<T>;
};
template<typename T>
struct CRTPParentStructSelector<T, 3>
{
 using type = _3_component_vec<T>;
};
template<typename T>
struct CRTPParentStructSelector<T, 4>
{
 using type = _4_component_vec<T>;
};

}

template<typename T, uint32_t N>
using emulated_vector_t = emulated_vector_impl::emulated_vector<T, typename emulated_vector_impl::CRTPParentStructSelector<T, N>::type>;
template<typename T>
using emulated_vector_t2 = emulated_vector_impl::emulated_vector<T, typename emulated_vector_impl::CRTPParentStructSelector<T, 2>::type>;
template<typename T>
using emulated_vector_t3 = emulated_vector_impl::emulated_vector<T, typename emulated_vector_impl::CRTPParentStructSelector<T, 3>::type>;
template<typename T>
using emulated_vector_t4 = emulated_vector_impl::emulated_vector<T, typename emulated_vector_impl::CRTPParentStructSelector<T, 4>::type>;

// used this macro, because I can't make it work with templated array dimension
#line 484 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
template<typename ScalarType>struct array_get<emulated_vector_t2<ScalarType>, ScalarType, uint32_t>{ inline ScalarType operator()(const in emulated_vector_t2<ScalarType> vec, const uint32_t ix) { return vec.getComponent(ix); }};template<typename ScalarType>struct array_set<emulated_vector_t2<ScalarType>, ScalarType, uint32_t>{ void operator()([[vk::ext_reference]] inout emulated_vector_t2<ScalarType> vec, uint32_t index, ScalarType value) { vec.setComponent(index, value); }};
template<typename ScalarType>struct array_get<emulated_vector_t3<ScalarType>, ScalarType, uint32_t>{ inline ScalarType operator()(const in emulated_vector_t3<ScalarType> vec, const uint32_t ix) { return vec.getComponent(ix); }};template<typename ScalarType>struct array_set<emulated_vector_t3<ScalarType>, ScalarType, uint32_t>{ void operator()([[vk::ext_reference]] inout emulated_vector_t3<ScalarType> vec, uint32_t index, ScalarType value) { vec.setComponent(index, value); }};
template<typename ScalarType>struct array_get<emulated_vector_t4<ScalarType>, ScalarType, uint32_t>{ inline ScalarType operator()(const in emulated_vector_t4<ScalarType> vec, const uint32_t ix) { return vec.getComponent(ix); }};template<typename ScalarType>struct array_set<emulated_vector_t4<ScalarType>, ScalarType, uint32_t>{ void operator()([[vk::ext_reference]] inout emulated_vector_t4<ScalarType> vec, uint32_t index, ScalarType value) { vec.setComponent(index, value); }};

#line 498 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
template<typename T>struct vector_traits<emulated_vector_t<T, 2> >{ using scalar_type = T; const static uint32_t Dimension = 2; const static bool IsVector = true;};
template<typename T>struct vector_traits<emulated_vector_t<T, 3> >{ using scalar_type = T; const static uint32_t Dimension = 3; const static bool IsVector = true;};
template<typename T>struct vector_traits<emulated_vector_t<T, 4> >{ using scalar_type = T; const static uint32_t Dimension = 4; const static bool IsVector = true;};

namespace impl
{
template<typename To, typename From>
struct static_cast_helper<emulated_vector_t2<To>, vector<From, 2>, void>
{
 static inline emulated_vector_t2<To> cast(const in vector<From, 2> vec)
 {
 emulated_vector_t2<To> output;
 output.x = _static_cast<To, From>(vec.x);
 output.y = _static_cast<To, From>(vec.y);

return output;
    }
};

template<typename To, typename From>
struct static_cast_helper<emulated_vector_t3<To>, vector<From, 3>, void>
{
 static inline emulated_vector_t3<To> cast(const in vector<From, 3> vec)
 {
 emulated_vector_t3<To> output;
 output.x = _static_cast<To, From>(vec.x);
 output.y = _static_cast<To, From>(vec.y);
 output.z = _static_cast<To, From>(vec.z);

return output;
    }
};

template<typename To, typename From>
struct static_cast_helper<emulated_vector_t4<To>, vector<From, 4>, void>
{
 static inline emulated_vector_t4<To> cast(const in vector<From, 4> vec)
 {
 emulated_vector_t4<To> output;
 output.x = _static_cast<To, From>(vec.x);
 output.y = _static_cast<To, From>(vec.y);
 output.z = _static_cast<To, From>(vec.z);
 output.w = _static_cast<To, From>(vec.w);

return output;
    }
};

template<typename ToComponentType, typename FromComponentType, uint32_t N>
struct static_cast_helper<vector<ToComponentType, N>, emulated_vector_t<FromComponentType, N>, void>
{
 using OutputVecType = vector<ToComponentType, N>;
 using InputVecType = emulated_vector_t<FromComponentType, N>;

static inline OutputVecType cast(const in InputVecType vec)
 {
 array_get<InputVecType, FromComponentType> getter;
 array_set<OutputVecType, ToComponentType> setter;
 
 OutputVecType output;
 [[unroll]]
 for (int i = 0; i < N; ++i)
 setter(output, i, _static_cast<ToComponentType>(getter(vec, i)));

return output;
    }
};

#line 584 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
template<typename ToComponentType, typename FromComponentType>struct static_cast_helper<emulated_vector_t2 <ToComponentType>, emulated_vector_t2 <FromComponentType>, void>{ using OutputVecType = emulated_vector_t2 <ToComponentType>; using InputVecType = emulated_vector_t2 <FromComponentType>; static inline OutputVecType cast(const in InputVecType vec) { array_get<InputVecType, FromComponentType> getter; array_set<OutputVecType, ToComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 2; ++i) setter(output, i, _static_cast<ToComponentType>(getter(vec, i))); return output; }};
template<typename ToComponentType, typename FromComponentType>struct static_cast_helper<emulated_vector_t3 <ToComponentType>, emulated_vector_t3 <FromComponentType>, void>{ using OutputVecType = emulated_vector_t3 <ToComponentType>; using InputVecType = emulated_vector_t3 <FromComponentType>; static inline OutputVecType cast(const in InputVecType vec) { array_get<InputVecType, FromComponentType> getter; array_set<OutputVecType, ToComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 3; ++i) setter(output, i, _static_cast<ToComponentType>(getter(vec, i))); return output; }};
template<typename ToComponentType, typename FromComponentType>struct static_cast_helper<emulated_vector_t4 <ToComponentType>, emulated_vector_t4 <FromComponentType>, void>{ using OutputVecType = emulated_vector_t4 <ToComponentType>; using InputVecType = emulated_vector_t4 <FromComponentType>; static inline OutputVecType cast(const in InputVecType vec) { array_get<InputVecType, FromComponentType> getter; array_set<OutputVecType, ToComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 4; ++i) setter(output, i, _static_cast<ToComponentType>(getter(vec, i))); return output; }};

#line 605 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
template<typename ComponentType>struct Promote<emulated_vector_t2 <ComponentType>, ComponentType>{ using VecType = emulated_vector_t2 <ComponentType>; inline VecType operator()(const in ComponentType v) { array_set<VecType, ComponentType> setter; VecType promoted; [[unroll]] for (int i = 0; i < 2; ++i) setter(promoted, i, v); return promoted; }};
template<typename ComponentType>struct Promote<emulated_vector_t3 <ComponentType>, ComponentType>{ using VecType = emulated_vector_t3 <ComponentType>; inline VecType operator()(const in ComponentType v) { array_set<VecType, ComponentType> setter; VecType promoted; [[unroll]] for (int i = 0; i < 3; ++i) setter(promoted, i, v); return promoted; }};
template<typename ComponentType>struct Promote<emulated_vector_t4 <ComponentType>, ComponentType>{ using VecType = emulated_vector_t4 <ComponentType>; inline VecType operator()(const in ComponentType v) { array_set<VecType, ComponentType> setter; VecType promoted; [[unroll]] for (int i = 0; i < 4; ++i) setter(promoted, i, v); return promoted; }};

#line 628 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/emulated/vector_t.hlsl"
template<typename ComponentType>struct Truncate<emulated_vector_t2 <ComponentType>, emulated_vector_t2 <ComponentType> >{ using OutputVecType = emulated_vector_t2 <ComponentType>; using InputVecType = emulated_vector_t2 <ComponentType>; inline OutputVecType operator()(const in InputVecType vec) { array_get<InputVecType, ComponentType> getter; array_set<OutputVecType, ComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 2; ++i) setter(output, i, getter(vec, i)); return output; }};
template<typename ComponentType>struct Truncate<emulated_vector_t2 <ComponentType>, emulated_vector_t3 <ComponentType> >{ using OutputVecType = emulated_vector_t2 <ComponentType>; using InputVecType = emulated_vector_t3 <ComponentType>; inline OutputVecType operator()(const in InputVecType vec) { array_get<InputVecType, ComponentType> getter; array_set<OutputVecType, ComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 2; ++i) setter(output, i, getter(vec, i)); return output; }};
template<typename ComponentType>struct Truncate<emulated_vector_t2 <ComponentType>, emulated_vector_t4 <ComponentType> >{ using OutputVecType = emulated_vector_t2 <ComponentType>; using InputVecType = emulated_vector_t4 <ComponentType>; inline OutputVecType operator()(const in InputVecType vec) { array_get<InputVecType, ComponentType> getter; array_set<OutputVecType, ComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 2; ++i) setter(output, i, getter(vec, i)); return output; }};
template<typename ComponentType>struct Truncate<emulated_vector_t3 <ComponentType>, emulated_vector_t3 <ComponentType> >{ using OutputVecType = emulated_vector_t3 <ComponentType>; using InputVecType = emulated_vector_t3 <ComponentType>; inline OutputVecType operator()(const in InputVecType vec) { array_get<InputVecType, ComponentType> getter; array_set<OutputVecType, ComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 3; ++i) setter(output, i, getter(vec, i)); return output; }};
template<typename ComponentType>struct Truncate<emulated_vector_t3 <ComponentType>, emulated_vector_t4 <ComponentType> >{ using OutputVecType = emulated_vector_t3 <ComponentType>; using InputVecType = emulated_vector_t4 <ComponentType>; inline OutputVecType operator()(const in InputVecType vec) { array_get<InputVecType, ComponentType> getter; array_set<OutputVecType, ComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 3; ++i) setter(output, i, getter(vec, i)); return output; }};
template<typename ComponentType>struct Truncate<emulated_vector_t4 <ComponentType>, emulated_vector_t4 <ComponentType> >{ using OutputVecType = emulated_vector_t4 <ComponentType>; using InputVecType = emulated_vector_t4 <ComponentType>; inline OutputVecType operator()(const in InputVecType vec) { array_get<InputVecType, ComponentType> getter; array_set<OutputVecType, ComponentType> setter; OutputVecType output; [[unroll]] for (int i = 0; i < 4; ++i) setter(output, i, getter(vec, i)); return output; }};

} //namespace impl

}
}

#line 8 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/vector_t.hlsl"
namespace nbl
{
namespace hlsl
{
namespace portable_vector_impl
{
template<typename T, uint32_t N, bool fundamental = is_fundamental<T>::value>
struct portable_vector
{
 using type = vector<T, N>;
};

template<typename T, uint32_t N>
struct portable_vector<T, N, false>
{
 using type = emulated_vector_t<T, N>;
};

}

template<typename T, uint32_t N>
using portable_vector_t = typename portable_vector_impl::portable_vector<T, N>::type;

template<typename T>
using portable_vector_t2 = portable_vector_t<T, 2>;
template<typename T>
using portable_vector_t3 = portable_vector_t<T, 3>;
template<typename T>
using portable_vector_t4 = portable_vector_t<T, 4>;

// Float
template<typename device_caps = void>
using portable_float64_t2 = portable_vector_t2<portable_float64_t<device_caps> >;
template<typename device_caps = void>
using portable_float64_t3 = portable_vector_t3<portable_float64_t<device_caps> >;
template<typename device_caps = void>
using portable_float64_t4 = portable_vector_t4<portable_float64_t<device_caps> >;

// Uint
template<typename device_caps = void>
using portable_uint64_t2 = portable_vector_t2<portable_uint64_t<device_caps> >;
template<typename device_caps = void>
using portable_uint64_t3 = portable_vector_t3<portable_uint64_t<device_caps> >;
template<typename device_caps = void>
using portable_uint64_t4 = portable_vector_t4<portable_uint64_t<device_caps> >;

//Int
template<typename device_caps = void>
using portable_int64_t2 = portable_vector_t2<portable_int64_t<device_caps> >;
template<typename device_caps = void>
using portable_int64_t3 = portable_vector_t3<portable_int64_t<device_caps> >;
template<typename device_caps = void>
using portable_int64_t4 = portable_vector_t4<portable_int64_t<device_caps> >;

#line 89 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/portable/vector_t.hlsl"
}
}

#line 12 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
// TODO: mega macro to get functional plus, minus, plus_assign, minus_assign

namespace nbl
{
namespace hlsl
{
namespace morton
{

namespace impl
{

// Valid dimension for a morton code
template <uint16_t D>
const static bool Dimension = 1 < D && D < 5;

// --------------------------------------------------------- MORTON ENCODE/DECODE MASKS ---------------------------------------------------

const static uint16_t CodingStages = 5;

template<uint16_t Dim, uint16_t Bits, uint16_t Stage>
struct coding_mask;

template<uint16_t Dim, uint16_t Bits, uint16_t Stage, typename T = uint64_t>
const static T coding_mask_v = _static_cast<T>(coding_mask<Dim, Bits, Stage>::value);

template<typename storage_t, uint16_t Dim, uint16_t Bits>
const static portable_vector_t<storage_t, Dim> InterleaveMasks = _static_cast<portable_vector_t<storage_t, Dim> >(
 truncate<vector<uint64_t, Dim> >(
 vector<uint64_t, 4>(coding_mask_v<Dim, Bits, 0>, 
 coding_mask_v<Dim, Bits, 0> << 1, 
 coding_mask_v<Dim, Bits, 0> << 2, 
 coding_mask_v<Dim, Bits, 0> << 3)));

template<uint16_t Dim, uint16_t Bits>
struct sign_mask : integral_constant<uint64_t, uint64_t(1) << ((Bits - 1) * Dim)> {};

template<uint16_t Dim, uint16_t Bits, typename T = uint64_t>
const static T sign_mask_v = _static_cast<T>(sign_mask<Dim, Bits>::value);

template<typename storage_t, uint16_t Dim, uint16_t Bits>
const static portable_vector_t<storage_t, Dim> SignMasks = _static_cast<portable_vector_t<storage_t, Dim> >(
 truncate<vector<uint64_t, Dim> >(
 vector<uint64_t, 4>(sign_mask_v<Dim, Bits>, 
 sign_mask_v<Dim, Bits> << 1, 
 sign_mask_v<Dim, Bits> << 2, 
 sign_mask_v<Dim, Bits> << 3)));

// 0th stage will be special: to avoid masking twice during encode/decode, and to get a proper mask that only gets the relevant bits out of a morton code, the 0th stage
// mask also considers the total number of bits we're cnsidering for a code (all other masks operate on a bit-agnostic basis).

#line 74 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
// Final stage mask also counts exact number of bits, although maybe it's not necessary

#line 81 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
template<uint16_t Bits> struct coding_mask<2, Bits, 0>{ enum : uint64_t { _Bits = Bits }; const static uint64_t KilloffMask = _Bits * 2 < 64 ? (uint64_t(1) << (_Bits * 2)) - 1 : ~uint64_t(0); const static uint64_t value = uint64_t( 0x5555555555555555ull) & KilloffMask;}; // Groups bits by 1 on, 1 off
template<uint16_t Bits> struct coding_mask<2, Bits, 1>{ const static uint64_t value = uint64_t( 0x3333333333333333ull);}; // Groups bits by 2 on, 2 off
template<uint16_t Bits> struct coding_mask<2, Bits, 2>{ const static uint64_t value = uint64_t( 0x0F0F0F0F0F0F0F0Full);}; // Groups bits by 4 on, 4 off
template<uint16_t Bits> struct coding_mask<2, Bits, 3>{ const static uint64_t value = uint64_t( 0x00FF00FF00FF00FFull);}; // Groups bits by 8 on, 8 off
template<uint16_t Bits> struct coding_mask<2, Bits, 4>{ const static uint64_t value = uint64_t( 0x0000FFFF0000FFFFull);}; // Groups bits by 16 on, 16 off

template<uint16_t Bits> struct coding_mask<3, Bits, 0>{ enum : uint64_t { _Bits = Bits }; const static uint64_t KilloffMask = _Bits * 3 < 64 ? (uint64_t(1) << (_Bits * 3)) - 1 : ~uint64_t(0); const static uint64_t value = uint64_t( 0x9249249249249249ull) & KilloffMask;}; // Groups bits by 1 on, 2 off
template<uint16_t Bits> struct coding_mask<3, Bits, 1>{ const static uint64_t value = uint64_t( 0x30C30C30C30C30C3ull);}; // Groups bits by 2 on, 4 off
template<uint16_t Bits> struct coding_mask<3, Bits, 2>{ const static uint64_t value = uint64_t( 0xF00F00F00F00F00Full);}; // Groups bits by 4 on, 8 off
template<uint16_t Bits> struct coding_mask<3, Bits, 3>{ const static uint64_t value = uint64_t( 0x00FF0000FF0000FFull);}; // Groups bits by 8 on, 16 off
template<uint16_t Bits> struct coding_mask<3, Bits, 4>{ const static uint64_t value = uint64_t( 0xFFFF00000000FFFFull);}; // Groups bits by 16 on, 32 off

template<uint16_t Bits> struct coding_mask<4, Bits, 0>{ enum : uint64_t { _Bits = Bits }; const static uint64_t KilloffMask = _Bits * 4 < 64 ? (uint64_t(1) << (_Bits * 4)) - 1 : ~uint64_t(0); const static uint64_t value = uint64_t( 0x1111111111111111ull) & KilloffMask;}; // Groups bits by 1 on, 3 off
template<uint16_t Bits> struct coding_mask<4, Bits, 1>{ const static uint64_t value = uint64_t( 0x0303030303030303ull);}; // Groups bits by 2 on, 6 off
template<uint16_t Bits> struct coding_mask<4, Bits, 2>{ const static uint64_t value = uint64_t( 0x000F000F000F000Full);}; // Groups bits by 4 on, 12 off
template<uint16_t Bits> struct coding_mask<4, Bits, 3>{ const static uint64_t value = uint64_t( 0x000000FF000000FFull);}; // Groups bits by 8 on, 24 off
template<uint16_t Bits> struct coding_mask<4, Bits, 4>{ const static uint64_t value = uint64_t( 0x000000000000FFFFull);}; // Groups bits by 16 on, 48 off (unused but here for completion + likely keeps compiler from complaining)

template<uint16_t Dim, uint16_t Bits> struct coding_mask<Dim, Bits, CodingStages>{ enum : uint64_t { _Bits = Bits }; const static uint64_t value = (uint64_t(1) << _Bits) - 1;};

// ----------------------------------------------------------------- MORTON TRANSCODER ---------------------------------------------------
template<uint16_t Dim, uint16_t Bits, typename encode_t ,typename __requires=::nbl::hlsl::enable_if_t<(Dimension<Dim> && Dim * Bits <= 64 && 8 * sizeof(encode_t) == mpl::max_v<uint64_t, mpl::round_up_to_pot_v<Dim * Bits>, uint64_t(16)>),void> >
struct Transcoder
{
 template<typename decode_t = conditional_t<(Bits > 16), vector<uint32_t, Dim>, vector<uint16_t, Dim> >
 ,::nbl::hlsl::enable_if_t<(concepts::IntVector<decode_t> && 8 * sizeof(typename vector_traits<decode_t>::scalar_type) >= Bits),bool> = true>
 /**
 * @brief Interleaves each coordinate with `Dim - 1` zeros inbetween each bit, and left-shifts each by their coordinate index
 *
 * @param [in] decodedValue Cartesian coordinates to interleave and shift
 */
 static inline portable_vector_t<encode_t, Dim> interleaveShift(const in decode_t decodedValue)
 {
 left_shift_operator<portable_vector_t<encode_t, Dim> > leftShift;
 portable_vector_t<encode_t, Dim> interleaved = _static_cast<portable_vector_t<encode_t, Dim> >(decodedValue) & coding_mask_v<Dim, Bits, CodingStages, encode_t>;

#line 126 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
 if (Bits > (uint16_t(1) << 4)) { interleaved = interleaved | leftShift(interleaved, (uint16_t(1) << 4) * (Dim - 1)); interleaved = interleaved & coding_mask_v<Dim, Bits, 4, encode_t>; }
 if (Bits > (uint16_t(1) << 3)) { interleaved = interleaved | leftShift(interleaved, (uint16_t(1) << 3) * (Dim - 1)); interleaved = interleaved & coding_mask_v<Dim, Bits, 3, encode_t>; }
 if (Bits > (uint16_t(1) << 2)) { interleaved = interleaved | leftShift(interleaved, (uint16_t(1) << 2) * (Dim - 1)); interleaved = interleaved & coding_mask_v<Dim, Bits, 2, encode_t>; }
 if (Bits > (uint16_t(1) << 1)) { interleaved = interleaved | leftShift(interleaved, (uint16_t(1) << 1) * (Dim - 1)); interleaved = interleaved & coding_mask_v<Dim, Bits, 1, encode_t>; }
 if (Bits > (uint16_t(1) << 0)) { interleaved = interleaved | leftShift(interleaved, (uint16_t(1) << 0) * (Dim - 1)); interleaved = interleaved & coding_mask_v<Dim, Bits, 0, encode_t>; }

// After interleaving, shift each coordinate left by their index
 return leftShift(interleaved, truncate<vector<uint16_t, Dim> >(vector<uint16_t, 4>(0, 1, 2, 3)));
 }

array_get<portable_vector_t<encode_t, Dim>, encode_t> getter;
 encode_t encoded = getter(interleaveShifted, 0);

[[unroll]]
 for (uint16_t i = 1; i < Dim; i++)
 encoded = encoded | getter(interleaveShifted, i);

return encoded;
    }

template<typename decode_t = conditional_t<(Bits > 16), vector<uint32_t, Dim>, vector<uint16_t, Dim> >
 ,::nbl::hlsl::enable_if_t<(concepts::IntVector<decode_t> && 8 * sizeof(typename vector_traits<decode_t>::scalar_type) >= Bits),bool> = true>
 /**
 * @brief Decodes a Morton code back to a vector of cartesian coordinates
 *
 * @param [in] encodedValue Representation of a Morton code (binary code, not the morton class defined below)
 */
 static inline decode_t decode(const in encode_t encodedValue)
 {
 arithmetic_right_shift_operator<encode_t> encodedRightShift;
 portable_vector_t<encode_t, Dim> decoded;
 array_set<portable_vector_t<encode_t, Dim>, encode_t> setter;
 // Write initial values into decoded
 [[unroll]]
 for (uint16_t i = 0; i < Dim; i++)
 setter(decoded, i, encodedRightShift(encodedValue, i));

arithmetic_right_shift_operator<portable_vector_t<encode_t, Dim> > rightShift;

#line 184 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
 if (Bits > (uint16_t(1) << 0)) { decoded = decoded & coding_mask_v<Dim, Bits, 0, encode_t>; decoded = decoded | rightShift(decoded, (uint16_t(1) << 0) * (Dim - 1)); }
 if (Bits > (uint16_t(1) << 1)) { decoded = decoded & coding_mask_v<Dim, Bits, 1, encode_t>; decoded = decoded | rightShift(decoded, (uint16_t(1) << 1) * (Dim - 1)); }
 if (Bits > (uint16_t(1) << 2)) { decoded = decoded & coding_mask_v<Dim, Bits, 2, encode_t>; decoded = decoded | rightShift(decoded, (uint16_t(1) << 2) * (Dim - 1)); }
 if (Bits > (uint16_t(1) << 3)) { decoded = decoded & coding_mask_v<Dim, Bits, 3, encode_t>; decoded = decoded | rightShift(decoded, (uint16_t(1) << 3) * (Dim - 1)); }
 if (Bits > (uint16_t(1) << 4)) { decoded = decoded & coding_mask_v<Dim, Bits, 4, encode_t>; decoded = decoded | rightShift(decoded, (uint16_t(1) << 4) * (Dim - 1)); }

// If `Bits` is greater than half the bitwidth of the decode type, then we can avoid `&`ing against the last mask since duplicated MSB get truncated
 if (Bits > 4 * sizeof(typename vector_traits<decode_t>::scalar_type))
 return _static_cast<decode_t>(decoded);
 else
 return _static_cast<decode_t>(decoded & coding_mask_v<Dim, Bits, CodingStages, encode_t>);
 }
};

// ---------------------------------------------------- COMPARISON OPERATORS ---------------------------------------------------------------
// Here because no partial specialization of methods
// `BitsAlreadySpread` assumes both pre-interleaved and pre-shifted

template<bool Signed, uint16_t Bits, typename storage_t, bool BitsAlreadySpread, typename I>
const static bool Comparable = concepts::IntegralLikeScalar && is_signed_v == Signed && ((BitsAlreadySpread && sizeof(I) == sizeof(storage_t)) || (!BitsAlreadySpread && 8 * sizeof(I) == mpl::max_v<uint64_t, mpl::round_up_to_pot_v<Bits>, uint64_t(16)>));

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, bool BitsAlreadySpread>
struct Equals;

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t>
struct Equals<Signed, Bits, D, storage_t, true>
{
 template<typename I ,::nbl::hlsl::enable_if_t<(Comparable<Signed, Bits, storage_t, true, I>),bool> = true>
 static inline vector<bool, D> __call(const in storage_t value, const in portable_vector_t<I, D> rhs)
 {
 const portable_vector_t<storage_t, D> zeros = _static_cast<portable_vector_t<storage_t, D> >(truncate<vector<uint64_t, D> >(vector<uint64_t, 4>(0,0,0,0)));
 
 const portable_vector_t<storage_t, D> rhsCasted = _static_cast<portable_vector_t<storage_t, D> >(rhs);
 const portable_vector_t<storage_t, D> xored = rhsCasted ^ value;
 equal_to<portable_vector_t<storage_t, D> > equal;
 return equal(xored, zeros);
 }
};

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t>
struct Equals<Signed, Bits, D, storage_t, false>
{
 template<typename I ,::nbl::hlsl::enable_if_t<(Comparable<Signed, Bits, storage_t, false, I>),bool> = true>
 static inline vector<bool, D> __call(const in storage_t value, const in vector<I, D> rhs)
 {
 using right_sign_t = conditional_t<Signed, make_signed_t<storage_t>, make_unsigned_t<storage_t> >;
 const portable_vector_t<right_sign_t, D> interleaved = _static_cast<portable_vector_t<right_sign_t, D> >(Transcoder<D, Bits, storage_t>::interleaveShift(rhs));
 return Equals<Signed, Bits, D, storage_t, true>::template __call<right_sign_t>(value, interleaved);
 }
};

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, bool BitsAlreadySpread, typename ComparisonOp>
struct BaseComparison;

// Aux variable that has only the sign bit for the first of D dimensions
template<uint16_t Bits, uint16_t D>
const static uint64_t SignMask = uint64_t(1) << (D * (Bits - 1));

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, typename ComparisonOp>
struct BaseComparison<Signed, Bits, D, storage_t, true, ComparisonOp>
{
 template<typename I ,::nbl::hlsl::enable_if_t<(Comparable<Signed, Bits, storage_t, true, I>),bool> = true>
 static inline vector<bool, D> __call(const in storage_t value, const in portable_vector_t<I, D> rhs)
 {
 ComparisonOp comparison;
 if (Signed)
 {
 // Obtain a vector of deinterleaved coordinates and flip their sign bits
 portable_vector_t<storage_t, D> thisCoord = (InterleaveMasks<storage_t, D, Bits> & value) ^ SignMasks<storage_t, D, Bits>;
 // rhs already deinterleaved, just have to cast type and flip sign
 const portable_vector_t<storage_t, D> rhsCoord = _static_cast<portable_vector_t<storage_t, D> >(rhs) ^ SignMasks<storage_t, D, Bits>;

return comparison(thisCoord, rhsCoord);
 }
 else 
 {
 // Obtain a vector of deinterleaved coordinates
 portable_vector_t<storage_t, D> thisCoord = InterleaveMasks<storage_t, D, Bits> & value;
 // rhs already deinterleaved, just have to cast type
 const portable_vector_t<storage_t, D> rhsCoord = _static_cast<portable_vector_t<storage_t, D> >(rhs);

return comparison(thisCoord, rhsCoord);
        }
        
    }
};

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, typename ComparisonOp>
struct BaseComparison<Signed, Bits, D, storage_t, false, ComparisonOp>
{
 template<typename I ,::nbl::hlsl::enable_if_t<(Comparable<Signed, Bits, storage_t, false, I>),bool> = true>
 static inline vector<bool, D> __call(const in storage_t value, const in vector<I, D> rhs)
 {
 using right_sign_t = conditional_t<Signed, make_signed_t<storage_t>, make_unsigned_t<storage_t> >;
 const portable_vector_t<right_sign_t, D> interleaved = _static_cast<portable_vector_t<right_sign_t, D> >(Transcoder<D, Bits, storage_t>::interleaveShift(rhs));
 return BaseComparison<Signed, Bits, D, storage_t, true, ComparisonOp>::template __call<right_sign_t>(value, interleaved);
 }
};

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, bool BitsAlreadySpread>
struct LessThan : BaseComparison<Signed, Bits, D, storage_t, BitsAlreadySpread, less<portable_vector_t<storage_t, D> > > {};

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, bool BitsAlreadySpread>
struct LessEquals : BaseComparison<Signed, Bits, D, storage_t, BitsAlreadySpread, less_equal<portable_vector_t<storage_t, D> > > {};

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, bool BitsAlreadySpread>
struct GreaterThan : BaseComparison<Signed, Bits, D, storage_t, BitsAlreadySpread, greater<portable_vector_t<storage_t, D> > > {};

template<bool Signed, uint16_t Bits, uint16_t D, typename storage_t, bool BitsAlreadySpread>
struct GreaterEquals : BaseComparison<Signed, Bits, D, storage_t, BitsAlreadySpread, greater_equal<portable_vector_t<storage_t, D> > > {};

} //namespace impl

// Making this even slightly less ugly is blocked by https://github.com/microsoft/DirectXShaderCompiler/issues/7006
// In particular, `Masks` should be a `const static` member field instead of appearing in every method using it
template<bool Signed, uint16_t Bits, uint16_t D, typename _uint64_t = uint64_t ,typename __requires=::nbl::hlsl::enable_if_t<(impl::Dimension<D> && D * Bits <= 64),void> >
struct code
{
 using this_t = code<Signed, Bits, D, _uint64_t>;
 using this_signed_t = code<true, Bits, D, _uint64_t>;
 const static uint16_t TotalBitWidth = D * Bits;
 using storage_t = conditional_t<(TotalBitWidth > 16), conditional_t<(TotalBitWidth > 32), _uint64_t, uint32_t>, uint16_t>;

storage_t value;

// ---------------------------------------------------- CONSTRUCTORS ---------------------------------------------------------------

#line 319 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
 /**
 * @brief Creates a Morton code from a set of integral cartesian coordinates
 *
 * @param [in] cartesian Coordinates to encode. Signedness MUST match the signedness of this Morton code class
 */
 template<typename I>
 static inline enable_if_t<is_integral_v && is_scalar_v && (is_signed_v == Signed) && (8 * sizeof(I) >= Bits), this_t>
 create(const in vector<I, D> cartesian)
 {
 this_t retVal;
 retVal.value = impl::Transcoder<D, Bits, storage_t>::encode(cartesian);
 return retVal;
 }

// CPP can also have an actual constructor

#line 355 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
    // ------------------------------------------------------- BITWISE OPERATORS -------------------------------------------------

inline this_t operator&(const in this_t rhs) 
    {
        this_t retVal;
        retVal.value = value & rhs.value;
        return retVal;
    }

inline this_t operator|(const in this_t rhs) 
    {
        this_t retVal;
        retVal.value = value | rhs.value;
        return retVal;
    }

inline this_t operator^(const in this_t rhs) 
    {
        this_t retVal;
        retVal.value = value ^ rhs.value;
        return retVal;
    }

inline this_t operator~() 
    {
        this_t retVal;
        retVal.value = ~value;
        return retVal;
    }

// Only valid in CPP

#line 394 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
    // ------------------------------------------------------- UNARY ARITHMETIC OPERATORS -------------------------------------------------

inline this_signed_t operator-() 
 {
 this_t zero;
 zero.value = _static_cast<storage_t>(0);
#line 403 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
 return zero - this;

}

// ------------------------------------------------------- BINARY ARITHMETIC OPERATORS -------------------------------------------------

// put 1 bits everywhere in the bits the current axis is not using
 // then extract just the axis bits for the right hand coordinate
 // carry-1 will propagate the bits across the already set bits
 // then clear out the bits not belonging to current axis
 // Note: Its possible to clear on `this` and fill on `rhs` but that will
 // disable optimizations, we expect the compiler to optimize a lot if the
 // value of `rhs` is known at compile time, e.g. `static_cast<Morton<N>>(glm::ivec3(1,0,0))`
 inline this_t operator+(const in this_t rhs) 
 {
 bit_not<portable_vector_t<storage_t, D> > bitnot;
 // For each coordinate, leave its bits intact and turn every other bit ON
 const portable_vector_t<storage_t, D> counterMaskedValue = bitnot(impl::InterleaveMasks<storage_t, D, Bits>) | value;
 // For each coordinate in rhs, leave its bits intact and turn every other bit OFF
 const portable_vector_t<storage_t, D> maskedRhsValue = impl::InterleaveMasks<storage_t, D, Bits> & rhs.value;
 // Add these coordinate-wise, then turn all bits not belonging to the current coordinate OFF
 const portable_vector_t<storage_t, D> interleaveShiftedResult = (counterMaskedValue + maskedRhsValue) & impl::InterleaveMasks<storage_t, D, Bits>;
 // Re-encode the result
 array_get<portable_vector_t<storage_t, D>, storage_t> getter;
 this_t retVal;
 retVal.value = getter(interleaveShiftedResult, 0);
 [[unroll]]
 for (uint16_t i = 1; i < D; i++)
 retVal.value = retVal.value | getter(interleaveShiftedResult, i);

return retVal;
    }

// This is the dual trick of the one used for addition: set all other bits to 0 so borrows propagate
 inline this_t operator-(const in this_t rhs) 
 {
 // For each coordinate, leave its bits intact and turn every other bit OFF
 const portable_vector_t<storage_t, D> maskedValue = impl::InterleaveMasks<storage_t, D, Bits> & value;
 // Do the same for each coordinate in rhs
 const portable_vector_t<storage_t, D> maskedRhsValue = impl::InterleaveMasks<storage_t, D, Bits> & rhs.value;
 // Subtract these coordinate-wise, then turn all bits not belonging to the current coordinate OFF
 const portable_vector_t<storage_t, D> interleaveShiftedResult = (maskedValue - maskedRhsValue) & impl::InterleaveMasks<storage_t, D, Bits>;
 // Re-encode the result
 array_get<portable_vector_t<storage_t, D>, storage_t> getter;
 this_t retVal;
 retVal.value = getter(interleaveShiftedResult, 0);
 [[unroll]]
 for (uint16_t i = 1; i < D; i++)
 retVal.value = retVal.value | getter(interleaveShiftedResult, i);

return retVal;
    }

// ------------------------------------------------------- COMPARISON OPERATORS -------------------------------------------------

inline bool operator==(const in this_t rhs) 
    {
        return value == rhs.value;
    }

template<bool BitsAlreadySpread, typename I 
 ,::nbl::hlsl::enable_if_t<(impl::Comparable<Signed, Bits, storage_t, BitsAlreadySpread, I>),bool> = true>
 inline vector<bool, D> equal(const in vector<I, D> rhs) 
 {
 return impl::Equals<Signed, Bits, D, storage_t, BitsAlreadySpread>::template __call(value, rhs);
 }

inline bool operator!=(const in this_t rhs) 
    {
        return value != rhs.value;
    }

template<bool BitsAlreadySpread, typename I
 ,::nbl::hlsl::enable_if_t<(impl::Comparable<Signed, Bits, storage_t, BitsAlreadySpread, I>),bool> = true>
 inline vector<bool, D> notEqual(const in vector<I, D> rhs) 
 {
 return !equal<BitsAlreadySpread, I>(rhs);
 }

template<bool BitsAlreadySpread, typename I
 ,::nbl::hlsl::enable_if_t<(impl::Comparable<Signed, Bits, storage_t, BitsAlreadySpread, I>),bool> = true>
 inline vector<bool, D> lessThan(const in vector<I, D> rhs) 
 {
 return impl::LessThan<Signed, Bits, D, storage_t, BitsAlreadySpread>::template __call(value, rhs);
 }

template<bool BitsAlreadySpread, typename I
 ,::nbl::hlsl::enable_if_t<(impl::Comparable<Signed, Bits, storage_t, BitsAlreadySpread, I>),bool> = true>
 inline vector<bool, D> lessThanEquals(const in vector<I, D> rhs) 
 {
 return impl::LessEquals<Signed, Bits, D, storage_t, BitsAlreadySpread>::template __call(value, rhs);
 }

template<bool BitsAlreadySpread, typename I
 ,::nbl::hlsl::enable_if_t<(impl::Comparable<Signed, Bits, storage_t, BitsAlreadySpread, I>),bool> = true>
 inline vector<bool, D> greaterThan(const in vector<I, D> rhs) 
 {
 return impl::GreaterThan<Signed, Bits, D, storage_t, BitsAlreadySpread>::template __call(value, rhs);
 }

template<bool BitsAlreadySpread, typename I
 ,::nbl::hlsl::enable_if_t<(impl::Comparable<Signed, Bits, storage_t, BitsAlreadySpread, I>),bool> = true>
 inline vector<bool, D> greaterThanEquals(const in vector<I, D> rhs) 
 {
 return impl::GreaterEquals<Signed, Bits, D, storage_t, BitsAlreadySpread>::template __call(value, rhs);
 }

};

} //namespace morton

// Specialize the `static_cast_helper`
namespace impl
{

// I must be of same signedness as the morton code, and be wide enough to hold each component
template<typename I, uint16_t Bits, uint16_t D, typename _uint64_t> 
struct static_cast_helper<vector<I, D>, morton::code<is_signed_v, Bits, D, _uint64_t> ,::nbl::hlsl::enable_if_t<(concepts::IntegralScalar && 8 * sizeof(I) >= Bits),void> >
{
 static inline vector<I, D> cast(const in morton::code<is_signed_v, Bits, D, _uint64_t> val)
 {
 using storage_t = typename morton::code<is_signed_v, Bits, D, _uint64_t>::storage_t;
 return morton::impl::Transcoder<D, Bits, storage_t>::decode(val.value);
 }
};

} // namespace impl

template<bool Signed, uint16_t Bits, uint16_t D, typename _uint64_t>
struct left_shift_operator<morton::code<Signed, Bits, D, _uint64_t> >
{
 using type_t = morton::code<Signed, Bits, D, _uint64_t>;
 using storage_t = typename type_t::storage_t;

inline type_t operator()(const in type_t operand, uint16_t bits)
 {
 left_shift_operator<storage_t> valueLeftShift;
 type_t retVal;
 // Shift every coordinate by `bits`
 retVal.value = valueLeftShift(operand.value, bits * D);
 return retVal;
 }
};

template<uint16_t Bits, uint16_t D, typename _uint64_t>
struct arithmetic_right_shift_operator<morton::code<false, Bits, D, _uint64_t> >
{
 using type_t = morton::code<false, Bits, D, _uint64_t>;
 using storage_t = typename type_t::storage_t;

inline type_t operator()(const in type_t operand, uint16_t bits)
 {
 arithmetic_right_shift_operator<storage_t> valueArithmeticRightShift;
 type_t retVal;
 // Shift every coordinate by `bits`
 retVal.value = valueArithmeticRightShift(operand.value, bits * D);
 return retVal;
 }
};

// This one's uglier - have to unpack to get the expected behaviour
template<uint16_t Bits, uint16_t D, typename _uint64_t>
struct arithmetic_right_shift_operator<morton::code<true, Bits, D, _uint64_t> >
{
 using type_t = morton::code<true, Bits, D, _uint64_t>;
 using scalar_t = conditional_t<(Bits > 16), int32_t, int16_t>;

inline type_t operator()(const in type_t operand, uint16_t bits)
 {
 vector<scalar_t, D> cartesian = _static_cast<vector<scalar_t, D> >(operand);
 cartesian >>= scalar_t(bits);
 return type_t::create(cartesian);
 }
};

#line 603 "C:/Users/fjlet/Desktop/Nabla/include/nbl/builtin/hlsl/morton.hlsl"
} //namespace hlsl
} //namespace nbl

#line 12 "C:/Users/fjlet/Desktop/Nabla/examples_tests/12_Mortons/app_resources/common.hlsl"
const static uint16_t smallBits_2 = 8;
const static uint16_t mediumBits_2 = 16;
const static uint16_t fullBits_2 = 32;
const static uint16_t smallBits_3 = 5;
const static uint16_t mediumBits_3 = 10;
const static uint16_t fullBits_3 = 21;
const static uint16_t smallBits_4 = 4;
const static uint16_t mediumBits_4 = 8;
const static uint16_t fullBits_4 = 16;

using namespace nbl::hlsl;
struct InputTestValues
{
	// Both tests
	uint32_t shift;

// Emulated int tests
	uint64_t generatedA;
	uint64_t generatedB;
	
	// Morton tests
	uint64_t coordX;
	uint64_t coordY;
	uint64_t coordZ;
	uint64_t coordW;
};

struct TestValues
{
	// Emulated int tests
	emulated_uint64_t emulatedAnd;
	emulated_uint64_t emulatedOr;
	emulated_uint64_t emulatedXor;
	emulated_uint64_t emulatedNot;
	emulated_uint64_t emulatedPlus;
	emulated_uint64_t emulatedMinus;
	// These are bools but stored as uint because you can't store bools, causes a SPIR-V issue
	uint32_t emulatedLess;
	uint32_t emulatedLessEqual;
	uint32_t emulatedGreater;
	uint32_t emulatedGreaterEqual;
	emulated_uint64_t emulatedLeftShifted;
	emulated_uint64_t emulatedUnsignedRightShifted;
	emulated_int64_t  emulatedSignedRightShifted;

// Morton tests - for each dimension let's do one small, medium and full-szied (max bits possible) test to cover representation with
	// 16, 32 and 64-bit types. Could make it more exhaustive with macros (test all possible bitwidths)
	// For emulated mortons, we store only the emulated uint64 representing it, because DXC complains about bitcasts otherwise

// Plus
	morton::code<false, smallBits_2, 2>					 mortonPlus_small_2;
	morton::code<false, mediumBits_2, 2>				 mortonPlus_medium_2;
	morton::code<false, fullBits_2, 2>					 mortonPlus_full_2;
	morton::code<false, fullBits_2, 2, emulated_uint64_t> mortonPlus_emulated_2;
	
	morton::code<false, smallBits_3, 3>					 mortonPlus_small_3;
	morton::code<false, mediumBits_3, 3>				 mortonPlus_medium_3;
	morton::code<false, fullBits_3, 3>					 mortonPlus_full_3;
	morton::code<false, fullBits_3, 3, emulated_uint64_t> mortonPlus_emulated_3;
	
	morton::code<false, smallBits_4, 4>					 mortonPlus_small_4;
	morton::code<false, mediumBits_4, 4>				 mortonPlus_medium_4;
	morton::code<false, fullBits_4, 4>					 mortonPlus_full_4;
	morton::code<false, fullBits_4, 4, emulated_uint64_t> mortonPlus_emulated_4;
	
	// Minus
	morton::code<false, smallBits_2, 2>					 mortonMinus_small_2;
	morton::code<false, mediumBits_2, 2>				 mortonMinus_medium_2;
	morton::code<false, fullBits_2, 2>					 mortonMinus_full_2;
	morton::code<false, fullBits_2, 2, emulated_uint64_t> mortonMinus_emulated_2;
	
	morton::code<false, smallBits_3, 3>					 mortonMinus_small_3;
	morton::code<false, mediumBits_3, 3>				 mortonMinus_medium_3;
	morton::code<false, fullBits_3, 3>					 mortonMinus_full_3;
	morton::code<false, fullBits_3, 3, emulated_uint64_t> mortonMinus_emulated_3;
	
	morton::code<false, smallBits_4, 4>					 mortonMinus_small_4;
	morton::code<false, mediumBits_4, 4>				 mortonMinus_medium_4;
	morton::code<false, fullBits_4, 4>					 mortonMinus_full_4;
	morton::code<false, fullBits_4, 4, emulated_uint64_t> mortonMinus_emulated_4;

// Coordinate-wise equality (these are bools)
	uint32_t2 mortonEqual_small_2;
	uint32_t2 mortonEqual_medium_2;
	uint32_t2 mortonEqual_full_2;
	uint32_t2 mortonEqual_emulated_2;

uint32_t3 mortonEqual_small_3;
	uint32_t3 mortonEqual_medium_3;
	uint32_t3 mortonEqual_full_3;
	uint32_t3 mortonEqual_emulated_3;

uint32_t4 mortonEqual_small_4;
	uint32_t4 mortonEqual_medium_4;
	uint32_t4 mortonEqual_full_4;
	uint32_t4 mortonEqual_emulated_4;

// Coordinate-wise unsigned inequality (just testing with less, again these are bools)
	uint32_t2 mortonUnsignedLess_small_2;
	uint32_t2 mortonUnsignedLess_medium_2;
	uint32_t2 mortonUnsignedLess_full_2;
	uint32_t2 mortonUnsignedLess_emulated_2;

uint32_t3 mortonUnsignedLess_small_3;
	uint32_t3 mortonUnsignedLess_medium_3;
	uint32_t3 mortonUnsignedLess_full_3;
	uint32_t3 mortonUnsignedLess_emulated_3;

uint32_t4 mortonUnsignedLess_small_4;
	uint32_t4 mortonUnsignedLess_medium_4;
	uint32_t4 mortonUnsignedLess_full_4;
	uint32_t4 mortonUnsignedLess_emulated_4;

// Coordinate-wise signed inequality (bools)
	uint32_t2 mortonSignedLess_small_2;
	uint32_t2 mortonSignedLess_medium_2;
	uint32_t2 mortonSignedLess_full_2;
	uint32_t2 mortonSignedLess_emulated_2;

uint32_t3 mortonSignedLess_small_3;
	uint32_t3 mortonSignedLess_medium_3;
	uint32_t3 mortonSignedLess_full_3;
	uint32_t3 mortonSignedLess_emulated_3;

uint32_t4 mortonSignedLess_small_4;
	uint32_t4 mortonSignedLess_medium_4;
	uint32_t4 mortonSignedLess_full_4;
	uint32_t4 mortonSignedLess_emulated_4;

// Left-shift
	morton::code<false, smallBits_2, 2>					 mortonLeftShift_small_2;
	morton::code<false, mediumBits_2, 2>				 mortonLeftShift_medium_2;
	morton::code<false, fullBits_2, 2>					 mortonLeftShift_full_2;
	morton::code<false, fullBits_2, 2, emulated_uint64_t> mortonLeftShift_emulated_2;

morton::code<false, smallBits_3, 3>					 mortonLeftShift_small_3;
	morton::code<false, mediumBits_3, 3>				 mortonLeftShift_medium_3;
	morton::code<false, fullBits_3, 3>					 mortonLeftShift_full_3;
	morton::code<false, fullBits_3, 3, emulated_uint64_t> mortonLeftShift_emulated_3;

morton::code<false, smallBits_4, 4>					 mortonLeftShift_small_4;
	morton::code<false, mediumBits_4, 4>				 mortonLeftShift_medium_4;
	morton::code<false, fullBits_4, 4>					 mortonLeftShift_full_4;
	morton::code<false, fullBits_4, 4, emulated_uint64_t> mortonLeftShift_emulated_4;

// Unsigned right-shift
	morton::code<false, smallBits_2, 2>					 mortonUnsignedRightShift_small_2;
	morton::code<false, mediumBits_2, 2>				 mortonUnsignedRightShift_medium_2;
	morton::code<false, fullBits_2, 2>					 mortonUnsignedRightShift_full_2;
	morton::code<false, fullBits_2, 2, emulated_uint64_t> mortonUnsignedRightShift_emulated_2;

morton::code<false, smallBits_3, 3>					 mortonUnsignedRightShift_small_3;
	morton::code<false, mediumBits_3, 3>				 mortonUnsignedRightShift_medium_3;
	morton::code<false, fullBits_3, 3>					 mortonUnsignedRightShift_full_3;
	morton::code<false, fullBits_3, 3, emulated_uint64_t> mortonUnsignedRightShift_emulated_3;

morton::code<false, smallBits_4, 4>					 mortonUnsignedRightShift_small_4;
	morton::code<false, mediumBits_4, 4>				 mortonUnsignedRightShift_medium_4;
	morton::code<false, fullBits_4, 4>					 mortonUnsignedRightShift_full_4;
	morton::code<false, fullBits_4, 4, emulated_uint64_t> mortonUnsignedRightShift_emulated_4;

// Signed right-shift
	morton::code<true, smallBits_2, 2>					 mortonSignedRightShift_small_2;
	morton::code<true, mediumBits_2, 2>					 mortonSignedRightShift_medium_2;
	morton::code<true, fullBits_2, 2>					 mortonSignedRightShift_full_2;
	morton::code<true, fullBits_2, 2, emulated_uint64_t> mortonSignedRightShift_emulated_2;

morton::code<true, smallBits_3, 3>					 mortonSignedRightShift_small_3;
	morton::code<true, mediumBits_3, 3>					 mortonSignedRightShift_medium_3;
	morton::code<true, fullBits_3, 3>					 mortonSignedRightShift_full_3;
	morton::code<true, fullBits_3, 3, emulated_uint64_t> mortonSignedRightShift_emulated_3;

morton::code<true, smallBits_4, 4>					 mortonSignedRightShift_small_4;
	morton::code<true, mediumBits_4, 4>					 mortonSignedRightShift_medium_4;
	morton::code<true, fullBits_4, 4>					 mortonSignedRightShift_full_4;
	morton::code<true, fullBits_4, 4, emulated_uint64_t> mortonSignedRightShift_emulated_4;

void fillTestValues(const in InputTestValues input)
	{
		emulated_uint64_t emulatedA = _static_cast<emulated_uint64_t>(input.generatedA);
		emulated_uint64_t emulatedB = _static_cast<emulated_uint64_t>(input.generatedB);

// Emulated int tests
		emulatedAnd = emulatedA & emulatedB;
		emulatedOr = emulatedA | emulatedB;
		emulatedXor = emulatedA ^ emulatedB;
		emulatedNot = emulatedA.operator~();
		emulatedPlus = emulatedA + emulatedB;
		emulatedMinus = emulatedA - emulatedB;
		emulatedLess = uint32_t(emulatedA < emulatedB);
		emulatedLessEqual = uint32_t(emulatedA <= emulatedB);
		emulatedGreater = uint32_t(emulatedA > emulatedB);
		emulatedGreaterEqual = uint32_t(emulatedA >= emulatedB);

left_shift_operator<emulated_uint64_t> leftShift;
		emulatedLeftShifted = leftShift(emulatedA, input.shift);

arithmetic_right_shift_operator<emulated_uint64_t> unsignedRightShift;
		emulatedUnsignedRightShifted = unsignedRightShift(emulatedA, input.shift);

arithmetic_right_shift_operator<emulated_int64_t> signedRightShift;
		emulatedSignedRightShifted = signedRightShift(_static_cast<emulated_int64_t>(emulatedA), input.shift);

// Morton tests
		uint64_t2 Vec2A = { input.coordX, input.coordY };
		uint64_t2 Vec2B = { input.coordZ, input.coordW };

uint64_t3 Vec3A = { input.coordX, input.coordY, input.coordZ };
		uint64_t3 Vec3B = { input.coordY, input.coordZ, input.coordW };

uint64_t4 Vec4A = { input.coordX, input.coordY, input.coordZ, input.coordW };
		uint64_t4 Vec4B = { input.coordY, input.coordZ, input.coordW, input.coordX };

int64_t2 Vec2ASigned = int64_t2(Vec2A);
		int64_t2 Vec2BSigned = int64_t2(Vec2B);

int64_t3 Vec3ASigned = int64_t3(Vec3A);
		int64_t3 Vec3BSigned = int64_t3(Vec3B);

int64_t4 Vec4ASigned = int64_t4(Vec4A);
		int64_t4 Vec4BSigned = int64_t4(Vec4B);
		
		morton::code<false, smallBits_2, 2> morton_small_2A = morton::code<false, smallBits_2, 2>::create(Vec2A);
		morton::code<false, mediumBits_2, 2> morton_medium_2A = morton::code<false, mediumBits_2, 2>::create(Vec2A);
		morton::code<false, fullBits_2, 2> morton_full_2A = morton::code<false, fullBits_2, 2>::create(Vec2A);
		morton::code<false, fullBits_2, 2, emulated_uint64_t> morton_emulated_2A = morton::code<false, fullBits_2, 2, emulated_uint64_t>::create(Vec2A);
		morton::code<false, smallBits_2, 2> morton_small_2B = morton::code<false, smallBits_2, 2>::create(Vec2B);
		morton::code<false, mediumBits_2, 2> morton_medium_2B = morton::code<false, mediumBits_2, 2>::create(Vec2B);
		morton::code<false, fullBits_2, 2> morton_full_2B = morton::code<false, fullBits_2, 2>::create(Vec2B);
		morton::code<false, fullBits_2, 2, emulated_uint64_t> morton_emulated_2B = morton::code<false, fullBits_2, 2, emulated_uint64_t>::create(Vec2B);

morton::code<false, smallBits_3, 3> morton_small_3A = morton::code<false, smallBits_3, 3>::create(Vec3A);
		morton::code<false, mediumBits_3, 3> morton_medium_3A = morton::code<false, mediumBits_3, 3>::create(Vec3A);
		morton::code<false, fullBits_3, 3> morton_full_3A = morton::code<false, fullBits_3, 3>::create(Vec3A);
		morton::code<false, fullBits_3, 3, emulated_uint64_t> morton_emulated_3A = morton::code<false, fullBits_3, 3, emulated_uint64_t>::create(Vec3A);
		morton::code<false, smallBits_3, 3> morton_small_3B = morton::code<false, smallBits_3, 3>::create(Vec3B);
		morton::code<false, mediumBits_3, 3> morton_medium_3B = morton::code<false, mediumBits_3, 3>::create(Vec3B);
		morton::code<false, fullBits_3, 3> morton_full_3B = morton::code<false, fullBits_3, 3>::create(Vec3B);
		morton::code<false, fullBits_3, 3, emulated_uint64_t> morton_emulated_3B = morton::code<false, fullBits_3, 3, emulated_uint64_t>::create(Vec3B);

morton::code<false, smallBits_4, 4> morton_small_4A = morton::code<false, smallBits_4, 4>::create(Vec4A);
		morton::code<false, mediumBits_4, 4> morton_medium_4A = morton::code<false, mediumBits_4, 4>::create(Vec4A);
		morton::code<false, fullBits_4, 4> morton_full_4A = morton::code<false, fullBits_4, 4>::create(Vec4A);
		morton::code<false, fullBits_4, 4, emulated_uint64_t> morton_emulated_4A = morton::code<false, fullBits_4, 4, emulated_uint64_t>::create(Vec4A);
		morton::code<false, smallBits_4, 4> morton_small_4B = morton::code<false, smallBits_4, 4>::create(Vec4B);
		morton::code<false, mediumBits_4, 4> morton_medium_4B = morton::code<false, mediumBits_4, 4>::create(Vec4B);
		morton::code<false, fullBits_4, 4> morton_full_4B = morton::code<false, fullBits_4, 4>::create(Vec4B);
		morton::code<false, fullBits_4, 4, emulated_uint64_t> morton_emulated_4B = morton::code<false, fullBits_4, 4, emulated_uint64_t>::create(Vec4B);

morton::code<true, smallBits_2, 2> morton_small_2_signed = morton::code<true, smallBits_2, 2>::create(Vec2ASigned);
		morton::code<true, mediumBits_2, 2> morton_medium_2_signed = morton::code<true, mediumBits_2, 2>::create(Vec2ASigned);
		morton::code<true, fullBits_2, 2> morton_full_2_signed = morton::code<true, fullBits_2, 2>::create(Vec2ASigned);
		morton::code<true, fullBits_2, 2, emulated_uint64_t> morton_emulated_2_signed = morton::code<true, fullBits_2, 2, emulated_uint64_t>::create(Vec2ASigned);

morton::code<true, smallBits_3, 3> morton_small_3_signed = morton::code<true, smallBits_3, 3>::create(Vec3ASigned);
		morton::code<true, mediumBits_3, 3> morton_medium_3_signed = morton::code<true, mediumBits_3, 3>::create(Vec3ASigned);
		morton::code<true, fullBits_3, 3> morton_full_3_signed = morton::code<true, fullBits_3, 3>::create(Vec3ASigned);
		morton::code<true, fullBits_3, 3, emulated_uint64_t> morton_emulated_3_signed = morton::code<true, fullBits_3, 3, emulated_uint64_t>::create(Vec3ASigned);

morton::code<true, smallBits_4, 4> morton_small_4_signed = morton::code<true, smallBits_4, 4>::create(Vec4ASigned);
		morton::code<true, mediumBits_4, 4> morton_medium_4_signed = morton::code<true, mediumBits_4, 4>::create(Vec4ASigned);
		morton::code<true, fullBits_4, 4> morton_full_4_signed = morton::code<true, fullBits_4, 4>::create(Vec4ASigned);
		morton::code<true, fullBits_4, 4, emulated_uint64_t> morton_emulated_4_signed = morton::code<true, fullBits_4, 4, emulated_uint64_t>::create(Vec4ASigned);

uint16_t castedShift = uint16_t(input.shift);
		mortonUnsignedLess_emulated_4 = uint32_t4(morton_emulated_4A.lessThan<false>(uint16_t4(Vec4B)));
		mortonSignedLess_emulated_2 = uint32_t2(morton_emulated_2_signed.lessThan<false>(int32_t2(Vec2BSigned)));
		mortonSignedLess_emulated_3 = uint32_t3(morton_emulated_3_signed.lessThan<false>(int32_t3(Vec3BSigned)));
		mortonSignedLess_emulated_4 = uint32_t4(morton_emulated_4_signed.lessThan<false>(int16_t4(Vec4BSigned)));
		arithmetic_right_shift_operator<morton::code<true, fullBits_2, 2, emulated_uint64_t> > rightShiftSignedEmulated2;
		mortonSignedRightShift_emulated_2 = rightShiftSignedEmulated2(morton_emulated_2_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_3, 3, emulated_uint64_t> > rightShiftSignedEmulated3;
		mortonSignedRightShift_emulated_3 = rightShiftSignedEmulated3(morton_emulated_3_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_4, 4, emulated_uint64_t> > rightShiftSignedEmulated4;
		mortonSignedRightShift_emulated_4 = rightShiftSignedEmulated4(morton_emulated_4_signed, castedShift);

/*
		// Plus
		mortonPlus_small_2 = morton_small_2A + morton_small_2B;
		mortonPlus_medium_2 = morton_medium_2A + morton_medium_2B;
		mortonPlus_full_2 = morton_full_2A + morton_full_2B;
		mortonPlus_emulated_2 = morton_emulated_2A + morton_emulated_2B;
		
		mortonPlus_small_3 = morton_small_3A + morton_small_3B;
		mortonPlus_medium_3 = morton_medium_3A + morton_medium_3B;
		mortonPlus_full_3 = morton_full_3A + morton_full_3B;
		mortonPlus_emulated_3 = morton_emulated_3A + morton_emulated_3B;

mortonPlus_small_4 = morton_small_4A + morton_small_4B;
		mortonPlus_medium_4 = morton_medium_4A + morton_medium_4B;
		mortonPlus_full_4 = morton_full_4A + morton_full_4B;
		mortonPlus_emulated_4 = morton_emulated_4A + morton_emulated_4B;
		
		// Minus
		mortonMinus_small_2 = morton_small_2A - morton_small_2B;
		mortonMinus_medium_2 = morton_medium_2A - morton_medium_2B;
		mortonMinus_full_2 = morton_full_2A - morton_full_2B;
		mortonMinus_emulated_2 = morton_emulated_2A - morton_emulated_2B;

mortonMinus_small_3 = morton_small_3A - morton_small_3B;
		mortonMinus_medium_3 = morton_medium_3A - morton_medium_3B;
		mortonMinus_full_3 = morton_full_3A - morton_full_3B;
		mortonMinus_emulated_3 = morton_emulated_3A - morton_emulated_3B;

mortonMinus_small_4 = morton_small_4A - morton_small_4B;
		mortonMinus_medium_4 = morton_medium_4A - morton_medium_4B;
		mortonMinus_full_4 = morton_full_4A - morton_full_4B;
		mortonMinus_emulated_4 = morton_emulated_4A - morton_emulated_4B;

// Coordinate-wise equality
		mortonEqual_small_2 = uint32_t2(morton_small_2A.equal<false>(uint16_t2(Vec2B)));
		mortonEqual_medium_2 = uint32_t2(morton_medium_2A.equal<false>(uint16_t2(Vec2B)));
		mortonEqual_full_2 = uint32_t2(morton_full_2A.equal<false>(uint32_t2(Vec2B)));
		mortonEqual_emulated_2 = uint32_t2(morton_emulated_2A.equal<false>(uint32_t2(Vec2B)));

mortonEqual_small_3 = uint32_t3(morton_small_3A.equal<false>(uint16_t3(Vec3B)));
		mortonEqual_medium_3 = uint32_t3(morton_medium_3A.equal<false>(uint16_t3(Vec3B)));
		mortonEqual_full_3 = uint32_t3(morton_full_3A.equal<false>(uint32_t3(Vec3B)));
		mortonEqual_emulated_3 = uint32_t3(morton_emulated_3A.equal<false>(uint32_t3(Vec3B)));

mortonEqual_small_4 = uint32_t4(morton_small_4A.equal<false>(uint16_t4(Vec4B)));
		mortonEqual_medium_4 = uint32_t4(morton_medium_4A.equal<false>(uint16_t4(Vec4B)));
		mortonEqual_full_4 = uint32_t4(morton_full_4A.equal<false>(uint16_t4(Vec4B)));
		mortonEqual_emulated_4 = uint32_t4(morton_emulated_4A.equal<false>(uint16_t4(Vec4B)));
		
		// Coordinate-wise unsigned inequality (just testing with less)
		mortonUnsignedLess_small_2 = uint32_t2(morton_small_2A.lessThan<false>(uint16_t2(Vec2B)));
		mortonUnsignedLess_medium_2 = uint32_t2(morton_medium_2A.lessThan<false>(uint16_t2(Vec2B)));
		mortonUnsignedLess_full_2 = uint32_t2(morton_full_2A.lessThan<false>(uint32_t2(Vec2B)));
		mortonUnsignedLess_emulated_2 = uint32_t2(morton_emulated_2A.lessThan<false>(uint32_t2(Vec2B)));
		
		mortonUnsignedLess_small_3 = uint32_t3(morton_small_3A.lessThan<false>(uint16_t3(Vec3B)));
		mortonUnsignedLess_medium_3 = uint32_t3(morton_medium_3A.lessThan<false>(uint16_t3(Vec3B)));
		mortonUnsignedLess_full_3 = uint32_t3(morton_full_3A.lessThan<false>(uint32_t3(Vec3B)));
		mortonUnsignedLess_emulated_3 = uint32_t3(morton_emulated_3A.lessThan<false>(uint32_t3(Vec3B)));
		
		mortonUnsignedLess_small_4 = uint32_t4(morton_small_4A.lessThan<false>(uint16_t4(Vec4B)));
		mortonUnsignedLess_medium_4 = uint32_t4(morton_medium_4A.lessThan<false>(uint16_t4(Vec4B)));
		mortonUnsignedLess_full_4 = uint32_t4(morton_full_4A.lessThan<false>(uint16_t4(Vec4B)));
		//mortonUnsignedLess_emulated_4 = uint32_t4(morton_emulated_4A.lessThan<false>(uint16_t4(Vec4B)));
		
		// Coordinate-wise signed inequality
		mortonSignedLess_small_2 = uint32_t2(morton_small_2_signed.lessThan<false>(int16_t2(Vec2BSigned)));
		mortonSignedLess_medium_2 = uint32_t2(morton_medium_2_signed.lessThan<false>(int16_t2(Vec2BSigned)));
		mortonSignedLess_full_2 = uint32_t2(morton_full_2_signed.lessThan<false>(int32_t2(Vec2BSigned)));
		//mortonSignedLess_emulated_2 = uint32_t2(morton_emulated_2_signed.lessThan<false>(int32_t2(Vec2BSigned)));

mortonSignedLess_small_3 = uint32_t3(morton_small_3_signed.lessThan<false>(int16_t3(Vec3BSigned)));
		mortonSignedLess_medium_3 = uint32_t3(morton_medium_3_signed.lessThan<false>(int16_t3(Vec3BSigned)));
		mortonSignedLess_full_3 = uint32_t3(morton_full_3_signed.lessThan<false>(int32_t3(Vec3BSigned)));
		//mortonSignedLess_emulated_3 = uint32_t3(morton_emulated_3_signed.lessThan<false>(int32_t3(Vec3BSigned)));

mortonSignedLess_small_4 = uint32_t4(morton_small_4_signed.lessThan<false>(int16_t4(Vec4BSigned)));
		mortonSignedLess_medium_4 = uint32_t4(morton_medium_4_signed.lessThan<false>(int16_t4(Vec4BSigned)));
		mortonSignedLess_full_4 = uint32_t4(morton_full_4_signed.lessThan<false>(int16_t4(Vec4BSigned)));
		//mortonSignedLess_emulated_4 = uint32_t4(morton_emulated_4_signed.lessThan<false>(int16_t4(Vec4BSigned)));
		
		// Left-shift
		uint16_t castedShift = uint16_t(input.shift);
		left_shift_operator<morton::code<false, smallBits_2, 2> > leftShiftSmall2;
		mortonLeftShift_small_2 = leftShiftSmall2(morton_small_2A, castedShift);
		left_shift_operator<morton::code<false, mediumBits_2, 2> > leftShiftMedium2;
		mortonLeftShift_medium_2 = leftShiftMedium2(morton_medium_2A, castedShift);
		left_shift_operator<morton::code<false, fullBits_2, 2> > leftShiftFull2;
		mortonLeftShift_full_2 = leftShiftFull2(morton_full_2A, castedShift);
		left_shift_operator<morton::code<false, fullBits_2, 2, emulated_uint64_t> > leftShiftEmulated2;
		mortonLeftShift_emulated_2 = leftShiftEmulated2(morton_emulated_2A, castedShift);

left_shift_operator<morton::code<false, smallBits_3, 3> > leftShiftSmall3;
		mortonLeftShift_small_3 = leftShiftSmall3(morton_small_3A, castedShift);
		left_shift_operator<morton::code<false, mediumBits_3, 3> > leftShiftMedium3;
		mortonLeftShift_medium_3 = leftShiftMedium3(morton_medium_3A, castedShift);
		left_shift_operator<morton::code<false, fullBits_3, 3> > leftShiftFull3;
		mortonLeftShift_full_3 = leftShiftFull3(morton_full_3A, castedShift);
		left_shift_operator<morton::code<false, fullBits_3, 3, emulated_uint64_t> > leftShiftEmulated3;
		mortonLeftShift_emulated_3 = leftShiftEmulated3(morton_emulated_3A, castedShift);

left_shift_operator<morton::code<false, smallBits_4, 4> > leftShiftSmall4;
		mortonLeftShift_small_4 = leftShiftSmall4(morton_small_4A, castedShift);
		left_shift_operator<morton::code<false, mediumBits_4, 4> > leftShiftMedium4;
		mortonLeftShift_medium_4 = leftShiftMedium4(morton_medium_4A, castedShift);
		left_shift_operator<morton::code<false, fullBits_4, 4> > leftShiftFull4;
		mortonLeftShift_full_4 = leftShiftFull4(morton_full_4A, castedShift);
		left_shift_operator<morton::code<false, fullBits_4, 4, emulated_uint64_t> > leftShiftEmulated4;
		mortonLeftShift_emulated_4 = leftShiftEmulated4(morton_emulated_4A, castedShift);
		
		// Unsigned right-shift
		arithmetic_right_shift_operator<morton::code<false, smallBits_2, 2> > rightShiftSmall2;
		mortonUnsignedRightShift_small_2 = rightShiftSmall2(morton_small_2A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, mediumBits_2, 2> > rightShiftMedium2;
		mortonUnsignedRightShift_medium_2 = rightShiftMedium2(morton_medium_2A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, fullBits_2, 2> > rightShiftFull2;
		mortonUnsignedRightShift_full_2 = rightShiftFull2(morton_full_2A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, fullBits_2, 2, emulated_uint64_t> > rightShiftEmulated2;
		mortonUnsignedRightShift_emulated_2 = rightShiftEmulated2(morton_emulated_2A, castedShift);

arithmetic_right_shift_operator<morton::code<false, smallBits_3, 3> > rightShiftSmall3;
		mortonUnsignedRightShift_small_3 = rightShiftSmall3(morton_small_3A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, mediumBits_3, 3> > rightShiftMedium3;
		mortonUnsignedRightShift_medium_3 = rightShiftMedium3(morton_medium_3A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, fullBits_3, 3> > rightShiftFull3;
		mortonUnsignedRightShift_full_3 = rightShiftFull3(morton_full_3A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, fullBits_3, 3, emulated_uint64_t> > rightShiftEmulated3;
		mortonUnsignedRightShift_emulated_3 = rightShiftEmulated3(morton_emulated_3A, castedShift);

arithmetic_right_shift_operator<morton::code<false, smallBits_4, 4> > rightShiftSmall4;
		mortonUnsignedRightShift_small_4 = rightShiftSmall4(morton_small_4A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, mediumBits_4, 4> > rightShiftMedium4;
		mortonUnsignedRightShift_medium_4 = rightShiftMedium4(morton_medium_4A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, fullBits_4, 4> > rightShiftFull4;
		mortonUnsignedRightShift_full_4 = rightShiftFull4(morton_full_4A, castedShift);
		arithmetic_right_shift_operator<morton::code<false, fullBits_4, 4, emulated_uint64_t> > rightShiftEmulated4;
		mortonUnsignedRightShift_emulated_4 = rightShiftEmulated4(morton_emulated_4A, castedShift);

// Signed right-shift
		arithmetic_right_shift_operator<morton::code<true, smallBits_2, 2> > rightShiftSignedSmall2;
		mortonSignedRightShift_small_2 = rightShiftSignedSmall2(morton_small_2_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, mediumBits_2, 2> > rightShiftSignedMedium2;
		mortonSignedRightShift_medium_2 = rightShiftSignedMedium2(morton_medium_2_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_2, 2> > rightShiftSignedFull2;
		mortonSignedRightShift_full_2 = rightShiftSignedFull2(morton_full_2_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_2, 2, emulated_uint64_t> > rightShiftSignedEmulated2;
		//mortonSignedRightShift_emulated_2 = rightShiftSignedEmulated2(morton_emulated_2_signed, castedShift);

arithmetic_right_shift_operator<morton::code<true, smallBits_3, 3> > rightShiftSignedSmall3;
		mortonSignedRightShift_small_3 = rightShiftSignedSmall3(morton_small_3_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, mediumBits_3, 3> > rightShiftSignedMedium3;
		mortonSignedRightShift_medium_3 = rightShiftSignedMedium3(morton_medium_3_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_3, 3> > rightShiftSignedFull3;
		mortonSignedRightShift_full_3 = rightShiftSignedFull3(morton_full_3_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_3, 3, emulated_uint64_t> > rightShiftSignedEmulated3;
		//mortonSignedRightShift_emulated_3 = rightShiftSignedEmulated3(morton_emulated_3_signed, castedShift);

arithmetic_right_shift_operator<morton::code<true, smallBits_4, 4> > rightShiftSignedSmall4;
		mortonSignedRightShift_small_4 = rightShiftSignedSmall4(morton_small_4_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, mediumBits_4, 4> > rightShiftSignedMedium4;
		mortonSignedRightShift_medium_4 = rightShiftSignedMedium4(morton_medium_4_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_4, 4> > rightShiftSignedFull4;
		mortonSignedRightShift_full_4 = rightShiftSignedFull4(morton_full_4_signed, castedShift);
		arithmetic_right_shift_operator<morton::code<true, fullBits_4, 4, emulated_uint64_t> > rightShiftSignedEmulated4;
		//mortonSignedRightShift_emulated_4 = rightShiftSignedEmulated4(morton_emulated_4_signed, castedShift);
		*/
	}
};

#line 9 "C:/Users/fjlet/Desktop/Nabla/examples_tests/12_Mortons/app_resources/mortonTest.comp.hlsl"
[[vk::binding(0, 0)]] RWStructuredBuffer<InputTestValues> inputTestValues;
[[vk::binding(1, 0)]] RWStructuredBuffer<TestValues> outputTestValues;

[numthreads(256, 1, 1)]
void main(uint3 invocationID : SV_DispatchThreadID)
{
    if (invocationID.x == 0)
        outputTestValues[0].fillTestValues(inputTestValues[0]);
}