mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Add specific initialization of Flags and FlagBits. (#489)

Browse Source 
Resolves #488.
This commit is contained in:
Andreas Süßenbach 2020-01-16 12:12:31 +01:00 committed by Markus Tavenrath
parent bb5b19deda
commit 33b244859b
4 changed files with 623 additions and 603 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
VulkanHppGenerator.cpp
View File

@ -896,8 +896,9 @@ void VulkanHppGenerator::appendBitmask(std::string & str, std::string const& bit
str += replaceWithMap(templateString, { { "enumName", emptyEnumName } }); str += replaceWithMap(templateString, { { "enumName", emptyEnumName } });
} }
} }
std::string name = (enumName.empty() ? emptyEnumName : enumName);
str += "\n" str += "\n"
" using " + bitmaskName + " = Flags<" + (enumName.empty() ? emptyEnumName : enumName) + ", Vk" + bitmaskName + ">;\n"; " using " + bitmaskName + " = Flags<" + name + ", Vk" + bitmaskName + ", " + name + (enumValues.empty() ? "(0)" : "::" + enumValues.front().vkValue) + ">;\n";
if (!enumValues.empty()) if (!enumValues.empty())
{ {
@ -2774,7 +2775,20 @@ bool VulkanHppGenerator::appendStructConstructorArgument(std::string & str, bool
{ {
str += constructStandardArray(memberData.type.compose(), memberData.arraySizes) + " const& "; str += constructStandardArray(memberData.type.compose(), memberData.arraySizes) + " const& ";
} }
str += memberData.name + "_ = {}"; str += memberData.name + "_ = ";
auto enumIt = m_enums.find(memberData.type.type);
if (enumIt != m_enums.end() && memberData.type.postfix.empty())
{
// enum arguments might need special initialization
assert(memberData.type.prefix.empty() && memberData.arraySizes.empty() && !enumIt->second.values.empty());
str += "VULKAN_HPP_NAMESPACE::" + stripPrefix(memberData.type.type, "Vk") + "::" + enumIt->second.values.front().vkValue;
}
else
{
// all the rest can be initialized with just {}
str += "{}";
}
listedArgument = true; listedArgument = true;
} }
return listedArgument; return listedArgument;
@ -2843,10 +2857,20 @@ void VulkanHppGenerator::appendStructMembers(std::string & str, std::pair<std::s
str += " : " + member.bitCount; // except for bitfield members, where no default member initializatin is supported (up to C++20) str += " : " + member.bitCount; // except for bitfield members, where no default member initializatin is supported (up to C++20)
} }
else else
{
auto enumIt = m_enums.find(member.type.type);
if (enumIt != m_enums.end() && member.type.postfix.empty())
{
// enum arguments might need special initialization
assert(member.type.prefix.empty() && member.arraySizes.empty() && !enumIt->second.values.empty());
str += " = VULKAN_HPP_NAMESPACE::" + stripPrefix(member.type.type, "Vk") + "::" + enumIt->second.values.front().vkValue;
}
else
{ {
str += constructCArraySizes(member.arraySizes) + " = {}"; str += constructCArraySizes(member.arraySizes) + " = {}";
} }
} }
}
str += ";\n"; str += ";\n";
} }
} }
@ -4622,20 +4646,20 @@ int main(int argc, char **argv)
enum { allFlags = 0 }; enum { allFlags = 0 };
}; };
template <typename BitType, typename MaskType = VkFlags> template <typename BitType, typename MaskType, BitType defaultValue>
class Flags class Flags
{ {
public: public:
// constructors // constructors
VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT
: m_mask(0) : m_mask(static_cast<MaskType>(defaultValue))
{} {}
VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_NOEXCEPT
: m_mask(static_cast<MaskType>(bit)) : m_mask(static_cast<MaskType>(bit))
{} {}
VULKAN_HPP_CONSTEXPR Flags(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags(Flags<BitType, MaskType, defaultValue> const& rhs) VULKAN_HPP_NOEXCEPT
: m_mask(rhs.m_mask) : m_mask(rhs.m_mask)
{} {}
@ -4644,32 +4668,32 @@ int main(int argc, char **argv)
{} {}
// relational operators // relational operators
VULKAN_HPP_CONSTEXPR bool operator<(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator<(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask < rhs.m_mask; return m_mask < rhs.m_mask;
} }
VULKAN_HPP_CONSTEXPR bool operator<=(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator<=(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask <= rhs.m_mask; return m_mask <= rhs.m_mask;
} }
VULKAN_HPP_CONSTEXPR bool operator>(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator>(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask > rhs.m_mask; return m_mask > rhs.m_mask;
} }
VULKAN_HPP_CONSTEXPR bool operator>=(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator>=(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask >= rhs.m_mask; return m_mask >= rhs.m_mask;
} }
VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask == rhs.m_mask; return m_mask == rhs.m_mask;
} }
VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask != rhs.m_mask; return m_mask != rhs.m_mask;
} }
@ -4681,46 +4705,46 @@ int main(int argc, char **argv)
} }
// bitwise operators // bitwise operators
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags<BitType, MaskType, defaultValue> operator&(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask & rhs.m_mask); return Flags<BitType, MaskType, defaultValue>(m_mask & rhs.m_mask);
} }
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags<BitType, MaskType, defaultValue> operator|(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask | rhs.m_mask); return Flags<BitType, MaskType, defaultValue>(m_mask | rhs.m_mask);
} }
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags<BitType, MaskType, defaultValue> operator^(Flags<BitType, MaskType, defaultValue> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask ^ rhs.m_mask); return Flags<BitType, MaskType, defaultValue>(m_mask ^ rhs.m_mask);
} }
VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags<BitType, MaskType, defaultValue> operator~() const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask ^ FlagTraits<BitType>::allFlags); return Flags<BitType, MaskType, defaultValue>(m_mask ^ FlagTraits<BitType>::allFlags);
} }
// assignment operators // assignment operators
Flags<BitType> & operator=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT Flags<BitType, MaskType, defaultValue> & operator=(Flags<BitType, MaskType, defaultValue> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask = rhs.m_mask; m_mask = rhs.m_mask;
return *this; return *this;
} }
Flags<BitType> & operator|=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT Flags<BitType, MaskType, defaultValue> & operator|=(Flags<BitType, MaskType, defaultValue> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask |= rhs.m_mask; m_mask |= rhs.m_mask;
return *this; return *this;
} }
Flags<BitType> & operator&=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT Flags<BitType, MaskType, defaultValue> & operator&=(Flags<BitType, MaskType, defaultValue> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask &= rhs.m_mask; m_mask &= rhs.m_mask;
return *this; return *this;
} }
Flags<BitType> & operator^=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT Flags<BitType, MaskType, defaultValue> & operator^=(Flags<BitType, MaskType, defaultValue> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask ^= rhs.m_mask; m_mask ^= rhs.m_mask;
return *this; return *this;
@ -4742,57 +4766,57 @@ int main(int argc, char **argv)
}; };
// relational operators // relational operators
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR bool operator<(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator<(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags > bit; return flags > bit;
} }
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR bool operator<=(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator<=(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags >= bit; return flags >= bit;
} }
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR bool operator>(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator>(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags < bit; return flags < bit;
} }
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR bool operator>=(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator>=(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags <= bit; return flags <= bit;
} }
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags == bit; return flags == bit;
} }
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags != bit; return flags != bit;
} }
// bitwise operators // bitwise operators
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags<BitType, MaskType, defaultValue> operator&(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags & bit; return flags & bit;
} }
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags<BitType, MaskType, defaultValue> operator|(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags | bit; return flags | bit;
} }
template <typename BitType> template <typename BitType, typename MaskType, BitType defaultValue>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR Flags<BitType, MaskType, defaultValue> operator^(BitType bit, Flags<BitType, MaskType, defaultValue> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags ^ bit; return flags ^ bit;
} }

2
samples/RayTracing/CameraManipulator.hpp
View File

@ -29,7 +29,7 @@ namespace vk
enum class Mode { Examine, Fly, Walk, Trackball }; enum class Mode { Examine, Fly, Walk, Trackball };
enum class MouseButton { None, Left, Middle, Right }; enum class MouseButton { None, Left, Middle, Right };
enum class ModifierFlagBits { Shift = 1, Ctrl = 2, Alt = 4 }; enum class ModifierFlagBits { Shift = 1, Ctrl = 2, Alt = 4 };
using ModifierFlags = vk::Flags<ModifierFlagBits, uint32_t>; using ModifierFlags = vk::Flags<ModifierFlagBits, uint32_t, ModifierFlagBits::Shift>;
public: public:
CameraManipulator(); CameraManipulator();

4
tests/DispatchLoaderDynamic/DispatchLoaderDynamic.cpp
View File

@ -23,10 +23,6 @@
#include <iostream> #include <iostream>
#include <map> #include <map>
static char const* AppName = "DispatchLoaderDynamic";
static char const* EngineName = "Vulkan.hpp";
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE; VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE;
int main(int /*argc*/, char ** /*argv*/) int main(int /*argc*/, char ** /*argv*/)

1112
vulkan/vulkan.hpp
View File

File diff suppressed because it is too large Load Diff