flags enum stuff

src/dependency/minidef/src/CppGen.cpp

@@ -55,6 +55,9 @@ namespace Gen
     constexpr char EnumField1[] =
         R"END(            %s,
 )END";
+    constexpr char EnumFieldNumbered2[] =
+        R"END(            %s = %s,
+)END";
 
     constexpr char EnumNamesStart2[] =
         R"END(        };
@@ -71,6 +74,25 @@ namespace Gen
     };
 )END";
 
+    constexpr char EnumFlagOperators12[] =
+        R"END(    inline %s::Enum operator| (const %s::Enum& a, const %s::Enum& b)
+    {
+        return a | b;
+    }
+    inline %s::Enum operator& (const %s::Enum& a, const %s::Enum& b)
+    {
+        return a & b;
+    }
+    inline %s::Enum operator|= (%s::Enum& a, const %s::Enum& b)
+    {
+        return a |= b;
+    }
+    inline %s::Enum operator&= (%s::Enum& a, const %s::Enum& b)
+    {
+        return a &= b;
+    }
+)END";
+
     constexpr char FileEnd[] =
         R"END(}
 )END";
@@ -124,6 +146,7 @@ namespace Gen
         }
 
         // Failed to resolve hash, the type definition chaned since the file was saved! try to match by name.
+        *obj = {};
         int32_t nameMatchIdx = serializer.TypeBuf.FindDefByName(typeName);
         if (nameMatchIdx < 0)
         {
@@ -328,6 +351,7 @@ void CppFileWriter::WriteEnums(const Def::DefinitionFile& definitions)
     for (int32_t enumIdx = 0; enumIdx < definitions.EnumCount; ++enumIdx)
     {
         const Def::Enum& e = definitions.Enums[enumIdx];
+        bool isFlagsEnum = (uint32_t)e.EnumFlags & (uint32_t)Def::EEnumFlags::FlagsEnum;
 
         if (!IsValid(e.EnumType))
         {
@@ -335,12 +359,24 @@ void CppFileWriter::WriteEnums(const Def::DefinitionFile& definitions)
             continue;
         }
 
-        char Buf[Def::MaxNameLength]{0};
+        char enumTypeNameBuf[Def::MaxNameLength]{0};
-        PrintTypeName(Buf, sizeof(Buf), e.EnumType, definitions);
+        PrintTypeName(enumTypeNameBuf, sizeof(enumTypeNameBuf), e.EnumType, definitions);
-        Write(WriteTemplates::EnumHeader4, e.Name, definitions.TypeCount + enumIdx, e.EntryCount, Buf);
+        Write(WriteTemplates::EnumHeader4, e.Name, definitions.TypeCount + enumIdx, e.EntryCount, enumTypeNameBuf);
         for (int32_t entryIdx = 0; entryIdx < e.EntryCount; ++entryIdx)
         {
-            Write(WriteTemplates::EnumField1, e.EntryNames[entryIdx]);
+            if (isFlagsEnum)
+            {
+                char numBuf[64] = "0";
+                if (entryIdx > 0)
+                {
+                    bx::snprintf(numBuf, sizeof(numBuf), "1 << %u", entryIdx - 1);
+                }
+                Write(WriteTemplates::EnumFieldNumbered2, e.EntryNames[entryIdx], numBuf);
+            }
+            else
+            {
+                Write(WriteTemplates::EnumField1, e.EntryNames[entryIdx]);
+            }
         }
 
         Write(WriteTemplates::EnumNamesStart2, "EntryNames", Def::MaxNameLength);
@@ -359,6 +395,23 @@ void CppFileWriter::WriteEnums(const Def::DefinitionFile& definitions)
         }
 
         Write(WriteTemplates::EnumNamesEnd);
+
+        if (isFlagsEnum)
+        {
+            Write(WriteTemplates::EnumFlagOperators12,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name,
+                  e.Name);
+        }
     }
 }
 void CppFileWriter::WriteTypes(const Def::DefinitionFile& definitions)

src/dependency/minidef/src/MiniDef.cpp

@@ -283,6 +283,12 @@ Parser::Result Parser::HandleEnum()
         e.EnumType = {(uint16_t)Gen::KnownType::i32, Def::EFieldType::DefinedClass};
     }
 
+    if (CmpAdvance("Flags", Res) && Res == OK)
+    {
+        e.EnumFlags = (Def::EEnumFlags)((uint32_t)e.EnumFlags | (uint32_t)Def::EEnumFlags::FlagsEnum);
+        CHECK(SkipWhitespace());
+    }
+
     CHECK(ExpectChar("{"));
     CHECK(SkipWhitespace());
     while (!CmpAdvance("}", Res))

src/dependency/minidef/src/TypeDef.h

@@ -25,6 +25,12 @@ namespace Def
         DynamicArray = 1 << 0,
     };
 
+    enum class EEnumFlags : uint32_t
+    {
+        None = 0,
+        FlagsEnum = 1,
+    };
+
     struct TypeRef
     {
         uint16_t TypeIdx = UINT16_MAX;
@@ -58,6 +64,7 @@ namespace Def
         char ExtraStringFieldNames[MaxExtraEnumFields][MaxNameLength];
         char ExtraStringFields[MaxFields][MaxExtraEnumFields][MaxNameLength];
         char Name[MaxNameLength]{0};
+        EEnumFlags EnumFlags = EEnumFlags::None;
         uint32_t Hash = 0;
     };