Merge pull request #1132 from Saalvage/more-constexpr

More support for constexpr

README.md

@@ -29,13 +29,12 @@ To build the local samples and tests you'll have to clone this repository and ru
 1. Open a shell which provides git and clone the repository with:
     ```git clone --recurse-submodules https://github.com/KhronosGroup/Vulkan-Hpp.git```
 2. Change the current directory to the newly created Vulkan-Hpp directory.
-3. Create a new folder named ```build``` and change the current directory to the newly created folder.
+3. Create a build environment with CMake
-4. Create a build environment with CMake
+    ```cmake -D DSAMPLES_BUILD_WITH_LOCAL_VULKAN_HPP=ON -DSAMPLES_BUILD=ON -DTESTS_BUILD_WITH_LOCAL_VULKAN_HPP=ON -DTESTS_BUILD=ON -B build```
-    ```cmake -D DSAMPLES_BUILD_WITH_LOCAL_VULKAN_HPP=ON -DSAMPLES_BUILD=ON -DTESTS_BUILD_WITH_LOCAL_VULKAN_HPP=ON -DTESTS_BUILD=ON -G "<generator>" ..```
+    You might have to specify a generator via `-G`, for a full list of generators execute ```cmake -G```.
-    For a full list of generators execute ```cmake -G```.
     *  To rebuild `vulkan.hpp` from the `vk.xml`  XML registry file, add the
        `-DVULKAN_HPP_RUN_GENERATOR=ON` option to the CMake command line.
-5. Either open the generated project with an IDE, e.g. Visual Studio or launch the build process with ```cmake --build .```.
+4. Either open the generated project with an IDE, e.g. Visual Studio or launch the build process with ```cmake --build .```.
 
 Optional: To update the Vulkan-Hpp and its submodules execute ```git pull --recurse-submodules```.
 

VulkanHppGenerator.cpp

@@ -6027,14 +6027,12 @@ std::string VulkanHppGenerator::generateCommandVoidGetValue( std::string const &
   }
 }
 
-std::string VulkanHppGenerator::generateConstexprString( std::pair<std::string, StructureData> const & structData,
+std::string VulkanHppGenerator::generateConstexprString( std::string const & structName ) const
-                                                         bool assignmentOperator ) const
 {
-  // structs with a union (and VkBaseInStructure and VkBaseOutStructure) can't be a constexpr!
+  // structs with a VkBaseInStructure and VkBaseOutStructure can't be a constexpr!
-  bool isConstExpression = !containsUnion( structData.first ) && ( structData.first != "VkBaseInStructure" ) &&
+  bool isConstExpression = ( structName != "VkBaseInStructure" ) && ( structName != "VkBaseOutStructure" );
-                           ( structData.first != "VkBaseOutStructure" );
   return isConstExpression ? ( std::string( "VULKAN_HPP_CONSTEXPR" ) +
-                               ( ( containsArray( structData.first ) || assignmentOperator ) ? "_14 " : " " ) )
+                               ( ( containsUnion( structName ) || containsArray( structName ) ) ? "_14 " : " " ) )
                            : "";
 }
 
@@ -11545,7 +11543,7 @@ std::string
 
   std::string str = replaceWithMap( constructors,
                                     { { "arguments", arguments },
-                                      { "constexpr", generateConstexprString( structData, false ) },
+                                      { "constexpr", generateConstexprString( structData.first ) },
                                       { "initializers", initializers },
                                       { "structName", stripPrefix( structData.first, "Vk" ) } } );
 
@@ -11971,7 +11969,7 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const &
   if ( member.type.type != "VkStructureType" )  // filter out StructureType, which is supposed to be immutable !
   {
     static const std::string templateString = R"(
-    ${structureName} & set${MemberName}( ${memberType} ${reference}${memberName}_ ) VULKAN_HPP_NOEXCEPT
+    ${constexpr}${structureName} & set${MemberName}( ${memberType} ${reference}${memberName}_ ) VULKAN_HPP_NOEXCEPT
     {
       ${assignment};
       return *this;
@@ -11982,8 +11980,9 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const &
       member.arraySizes.empty()
         ? member.type.compose( "VULKAN_HPP_NAMESPACE" )
         : generateStandardArray( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes );
+    bool        isReinterpretation = !member.bitCount.empty() && beginsWith( member.type.type, "Vk" );
     std::string assignment;
-    if ( !member.bitCount.empty() && beginsWith( member.type.type, "Vk" ) )
+    if ( isReinterpretation )
     {
       assignment = member.name + " = " + "*reinterpret_cast<" + member.type.type + "*>(&" + member.name + "_)";
     }
@@ -11995,6 +11994,7 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const &
     str += replaceWithMap(
       templateString,
       { { "assignment", assignment },
+        { "constexpr", isReinterpretation ? "" : "VULKAN_HPP_CONSTEXPR_14 " },
         { "memberName", member.name },
         { "MemberName", startUpperCase( member.name ) },
         { "memberType", memberType },
@@ -12196,8 +12196,10 @@ std::string VulkanHppGenerator::generateUnion( std::pair<std::string, StructureD
           : ( "const " +
               generateStandardArray( memberIt->type.compose( "VULKAN_HPP_NAMESPACE" ), memberIt->arraySizes ) + "&" );
 
+      // In a majority of cases this can be constexpr in C++11 as well, however, determining when exactly
+      // that is the case is a lot more involved and probably not worth it.
       static const std::string constructorTemplate = R"(
-    ${unionName}( ${memberType} ${argumentName}_${defaultAssignment} )
+    VULKAN_HPP_CONSTEXPR_14 ${unionName}( ${memberType} ${argumentName}_${defaultAssignment} )
       : ${memberName}( ${argumentName}_ )
     {})";
 
@@ -12266,10 +12268,6 @@ ${enter}  union ${unionName}
   {
     using NativeType = Vk${unionName};
 #if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
-    ${unionName}( VULKAN_HPP_NAMESPACE::${unionName} const & rhs ) VULKAN_HPP_NOEXCEPT
-    {
-      memcpy( static_cast<void *>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::${unionName} ) );
-    }
 ${constructors}
 #endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
 
@@ -12277,12 +12275,6 @@ ${constructors}
 ${setters}
 #endif /*VULKAN_HPP_NO_UNION_SETTERS*/
 
-    VULKAN_HPP_NAMESPACE::${unionName} & operator=( VULKAN_HPP_NAMESPACE::${unionName} const & rhs ) VULKAN_HPP_NOEXCEPT
-    {
-      memcpy( static_cast<void*>( this ), &rhs, sizeof( VULKAN_HPP_NAMESPACE::${unionName} ) );
-      return *this;
-    }
-
     operator Vk${unionName} const &() const
     {
       return *reinterpret_cast<const Vk${unionName}*>( this );

VulkanHppGenerator.hpp

@@ -775,8 +775,7 @@ private:
                                            bool                             definition,
                                            std::map<size_t, size_t> const & vectorParamIndices,
                                            size_t                           returnParamIndex ) const;
-  std::string generateConstexprString( std::pair<std::string, StructureData> const & structData,
+  std::string generateConstexprString( std::string const & structName ) const;
-                                       bool                                          assignmentOperator ) const;
   std::string generateDestroyCommand( std::string const & name, CommandData const & commandData ) const;
   std::string generateDispatchLoaderDynamicCommandAssignment( std::string const & commandName,
                                                               CommandData const & commandData,