Code/UnitTests/FoundationTest/Reflection/ReflectionTestClasses.cpp - dev - redgpu/ezEngine

Code/UnitTests/FoundationTest/Reflection/ReflectionTestClasses.cpp
536 строк16 KB
Sanakan8472
Particle editor default value fixes (#1468)
04 янв 2025, 19:37
04 янв 2025, 19:375f6ac03
#include <FoundationTest/FoundationTestPCH.h>

#include <FoundationTest/Reflection/ReflectionTestClasses.h>

// clang-format off
EZ_BEGIN_STATIC_REFLECTED_ENUM(ezExampleEnum, 1)
  EZ_ENUM_CONSTANTS(ezExampleEnum::Value1, ezExampleEnum::Value2)
  EZ_ENUM_CONSTANT(ezExampleEnum::Value3),
EZ_END_STATIC_REFLECTED_ENUM;

EZ_BEGIN_STATIC_REFLECTED_BITFLAGS(ezExampleBitflags, 1)
  EZ_BITFLAGS_CONSTANTS(ezExampleBitflags::Value1, ezExampleBitflags::Value2)
  EZ_BITFLAGS_CONSTANT(ezExampleBitflags::Value3),
EZ_END_STATIC_REFLECTED_BITFLAGS;


EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezAbstractTestClass, 1, ezRTTINoAllocator)
EZ_END_DYNAMIC_REFLECTED_TYPE;


EZ_BEGIN_STATIC_REFLECTED_TYPE(ezAbstractTestStruct, ezNoBase, 1, ezRTTINoAllocator);
EZ_END_STATIC_REFLECTED_TYPE;


EZ_BEGIN_STATIC_REFLECTED_TYPE(ezTestStruct, ezNoBase, 7, ezRTTIDefaultAllocator<ezTestStruct>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_MEMBER_PROPERTY("Float", m_fFloat1)->AddAttributes(new ezDefaultValueAttribute(1.1f)),
    EZ_MEMBER_PROPERTY_READ_ONLY("Vector", m_vProperty3)->AddAttributes(new ezDefaultValueAttribute(ezVec3(3.0f,4.0f,5.0f))),
    EZ_ACCESSOR_PROPERTY("Int", GetInt, SetInt)->AddAttributes(new ezDefaultValueAttribute(2)),
    EZ_MEMBER_PROPERTY("UInt8", m_UInt8)->AddAttributes(new ezDefaultValueAttribute(6)),
    EZ_MEMBER_PROPERTY("Variant", m_variant)->AddAttributes(new ezDefaultValueAttribute("Test")),
    EZ_MEMBER_PROPERTY("Angle", m_Angle)->AddAttributes(new ezDefaultValueAttribute(ezAngle::MakeFromDegree(0.5))),
    EZ_MEMBER_PROPERTY("DataBuffer", m_DataBuffer)->AddAttributes(new ezDefaultValueAttribute(ezTestStruct::GetDefaultDataBuffer())),
    EZ_MEMBER_PROPERTY("vVec3I", m_vVec3I)->AddAttributes(new ezDefaultValueAttribute(ezVec3I32(1,2,3))),
    EZ_MEMBER_PROPERTY("VarianceAngle", m_VarianceAngle)->AddAttributes(new ezDefaultValueAttribute(ezVarianceTypeAngle(ezAngle::MakeFromDegree(90.0f), 0.5f))),
  }
  EZ_END_PROPERTIES;
}
EZ_END_STATIC_REFLECTED_TYPE;

EZ_BEGIN_STATIC_REFLECTED_TYPE(ezTestStruct3, ezNoBase, 71, ezRTTIDefaultAllocator<ezTestStruct3>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_MEMBER_PROPERTY("Float", m_fFloat1)->AddAttributes(new ezDefaultValueAttribute(33.3f)),
    EZ_ACCESSOR_PROPERTY("Int", GetInt, SetInt),
    EZ_MEMBER_PROPERTY("UInt8", m_UInt8),
  }
  EZ_END_PROPERTIES;
  EZ_BEGIN_FUNCTIONS
  {
    EZ_CONSTRUCTOR_PROPERTY(),
    EZ_CONSTRUCTOR_PROPERTY(double, ezInt16),
  }
  EZ_END_FUNCTIONS;
}
EZ_END_STATIC_REFLECTED_TYPE;

EZ_BEGIN_STATIC_REFLECTED_TYPE(ezTypedObjectStruct, ezNoBase, 1, ezRTTIDefaultAllocator<ezTypedObjectStruct>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_MEMBER_PROPERTY("Float", m_fFloat1)->AddAttributes(new ezDefaultValueAttribute(33.3f)),
    EZ_MEMBER_PROPERTY("Int", m_iInt32),
    EZ_MEMBER_PROPERTY("UInt8", m_UInt8),
  }
  EZ_END_PROPERTIES;
}
EZ_END_STATIC_REFLECTED_TYPE;

EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezTestClass1, 11, ezRTTIDefaultAllocator<ezTestClass1>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_MEMBER_PROPERTY("SubStruct", m_Struct),
    // EZ_MEMBER_PROPERTY("MyVector", m_MyVector), Intentionally not reflected
    EZ_MEMBER_PROPERTY("Color", m_Color),
    EZ_ACCESSOR_PROPERTY_READ_ONLY("SubVector", GetVector)->AddAttributes(new ezDefaultValueAttribute(ezVec3(3, 4, 5)))
  }
    EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;

ezInt32 ezTestClass2Allocator::m_iAllocs = 0;
ezInt32 ezTestClass2Allocator::m_iDeallocs = 0;

EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezTestClass2, 22, ezTestClass2Allocator)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_ACCESSOR_PROPERTY("CharPtr", GetCharPtr, SetCharPtr)->AddAttributes(new ezDefaultValueAttribute("AAA")),
    EZ_ACCESSOR_PROPERTY("String", GetString, SetString)->AddAttributes(new ezDefaultValueAttribute("BBB")),
    EZ_ACCESSOR_PROPERTY("StringView", GetStringView, SetStringView)->AddAttributes(new ezDefaultValueAttribute("CCC")),
    EZ_MEMBER_PROPERTY("Time", m_Time),
    EZ_ENUM_MEMBER_PROPERTY("Enum", ezExampleEnum, m_enumClass),
    EZ_BITFLAGS_MEMBER_PROPERTY("Bitflags", ezExampleBitflags, m_bitflagsClass),
    EZ_ARRAY_MEMBER_PROPERTY("Array", m_array),
    EZ_MEMBER_PROPERTY("Variant", m_Variant),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;

EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezTestClass2b, 24, ezRTTIDefaultAllocator<ezTestClass2b>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_ACCESSOR_PROPERTY("Text2b", GetText, SetText),
    EZ_MEMBER_PROPERTY("SubStruct", m_Struct),
    EZ_MEMBER_PROPERTY("Color", m_Color),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;

EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezTestArrays, 1, ezRTTIDefaultAllocator<ezTestArrays>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_ARRAY_MEMBER_PROPERTY("Hybrid", m_Hybrid),
    EZ_ARRAY_MEMBER_PROPERTY("HybridChar", m_HybridChar),
    EZ_ARRAY_MEMBER_PROPERTY("Dynamic", m_Dynamic),
    EZ_ARRAY_MEMBER_PROPERTY("Deque", m_Deque),
    EZ_ARRAY_MEMBER_PROPERTY("Custom", m_CustomVariant),

    EZ_ARRAY_MEMBER_PROPERTY_READ_ONLY("HybridRO", m_Hybrid),
    EZ_ARRAY_MEMBER_PROPERTY_READ_ONLY("HybridCharRO", m_HybridChar),
    EZ_ARRAY_MEMBER_PROPERTY_READ_ONLY("DynamicRO", m_Dynamic),
    EZ_ARRAY_MEMBER_PROPERTY_READ_ONLY("DequeRO", m_Deque),
    EZ_ARRAY_MEMBER_PROPERTY_READ_ONLY("CustomRO", m_CustomVariant),

    EZ_ARRAY_ACCESSOR_PROPERTY("AcHybrid", GetCount, GetValue, SetValue, Insert, Remove),
    EZ_ARRAY_ACCESSOR_PROPERTY_READ_ONLY("AcHybridRO", GetCount, GetValue),
    EZ_ARRAY_ACCESSOR_PROPERTY("AcHybridChar", GetCountChar, GetValueChar, SetValueChar, InsertChar, RemoveChar),
    EZ_ARRAY_ACCESSOR_PROPERTY_READ_ONLY("AcHybridCharRO", GetCountChar, GetValueChar),
    EZ_ARRAY_ACCESSOR_PROPERTY("AcDynamic", GetCountDyn, GetValueDyn, SetValueDyn, InsertDyn, RemoveDyn),
    EZ_ARRAY_ACCESSOR_PROPERTY_READ_ONLY("AcDynamicRO", GetCountDyn, GetValueDyn),
    EZ_ARRAY_ACCESSOR_PROPERTY("AcDeque", GetCountDeq, GetValueDeq, SetValueDeq, InsertDeq, RemoveDeq),
    EZ_ARRAY_ACCESSOR_PROPERTY_READ_ONLY("AcDequeRO", GetCountDeq, GetValueDeq),
    EZ_ARRAY_ACCESSOR_PROPERTY("AcCustom", GetCountCustom, GetValueCustom, SetValueCustom, InsertCustom, RemoveCustom),
    EZ_ARRAY_ACCESSOR_PROPERTY_READ_ONLY("AcCustomRO", GetCountCustom, GetValueCustom),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;
// clang-format on

ezUInt32 ezTestArrays::GetCount() const
{
  return m_Hybrid.GetCount();
}
double ezTestArrays::GetValue(ezUInt32 uiIndex) const
{
  return m_Hybrid[uiIndex];
}
void ezTestArrays::SetValue(ezUInt32 uiIndex, double value)
{
  m_Hybrid[uiIndex] = value;
}
void ezTestArrays::Insert(ezUInt32 uiIndex, double value)
{
  m_Hybrid.InsertAt(uiIndex, value);
}
void ezTestArrays::Remove(ezUInt32 uiIndex)
{
  m_Hybrid.RemoveAtAndCopy(uiIndex);
}

ezUInt32 ezTestArrays::GetCountChar() const
{
  return m_HybridChar.GetCount();
}
const char* ezTestArrays::GetValueChar(ezUInt32 uiIndex) const
{
  return m_HybridChar[uiIndex];
}
void ezTestArrays::SetValueChar(ezUInt32 uiIndex, const char* value)
{
  m_HybridChar[uiIndex] = value;
}
void ezTestArrays::InsertChar(ezUInt32 uiIndex, const char* value)
{
  m_HybridChar.InsertAt(uiIndex, value);
}
void ezTestArrays::RemoveChar(ezUInt32 uiIndex)
{
  m_HybridChar.RemoveAtAndCopy(uiIndex);
}

ezUInt32 ezTestArrays::GetCountDyn() const
{
  return m_Dynamic.GetCount();
}
const ezTestStruct3& ezTestArrays::GetValueDyn(ezUInt32 uiIndex) const
{
  return m_Dynamic[uiIndex];
}
void ezTestArrays::SetValueDyn(ezUInt32 uiIndex, const ezTestStruct3& value)
{
  m_Dynamic[uiIndex] = value;
}
void ezTestArrays::InsertDyn(ezUInt32 uiIndex, const ezTestStruct3& value)
{
  m_Dynamic.InsertAt(uiIndex, value);
}
void ezTestArrays::RemoveDyn(ezUInt32 uiIndex)
{
  m_Dynamic.RemoveAtAndCopy(uiIndex);
}

ezUInt32 ezTestArrays::GetCountDeq() const
{
  return m_Deque.GetCount();
}
const ezTestArrays& ezTestArrays::GetValueDeq(ezUInt32 uiIndex) const
{
  return m_Deque[uiIndex];
}
void ezTestArrays::SetValueDeq(ezUInt32 uiIndex, const ezTestArrays& value)
{
  m_Deque[uiIndex] = value;
}
void ezTestArrays::InsertDeq(ezUInt32 uiIndex, const ezTestArrays& value)
{
  m_Deque.InsertAt(uiIndex, value);
}
void ezTestArrays::RemoveDeq(ezUInt32 uiIndex)
{
  m_Deque.RemoveAtAndCopy(uiIndex);
}

ezUInt32 ezTestArrays::GetCountCustom() const
{
  return m_CustomVariant.GetCount();
}
ezVarianceTypeAngle ezTestArrays::GetValueCustom(ezUInt32 uiIndex) const
{
  return m_CustomVariant[uiIndex];
}
void ezTestArrays::SetValueCustom(ezUInt32 uiIndex, ezVarianceTypeAngle value)
{
  m_CustomVariant[uiIndex] = value;
}
void ezTestArrays::InsertCustom(ezUInt32 uiIndex, ezVarianceTypeAngle value)
{
  m_CustomVariant.InsertAt(uiIndex, value);
}
void ezTestArrays::RemoveCustom(ezUInt32 uiIndex)
{
  m_CustomVariant.RemoveAtAndCopy(uiIndex);
}

// clang-format off
EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezTestSets, 1, ezRTTIDefaultAllocator<ezTestSets>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_SET_MEMBER_PROPERTY("Set", m_SetMember),
    EZ_SET_MEMBER_PROPERTY_READ_ONLY("SetRO", m_SetMember),
    EZ_SET_ACCESSOR_PROPERTY("AcSet", GetSet, Insert, Remove),
    EZ_SET_ACCESSOR_PROPERTY_READ_ONLY("AcSetRO", GetSet),
    EZ_SET_MEMBER_PROPERTY("HashSet", m_HashSetMember),
    EZ_SET_MEMBER_PROPERTY_READ_ONLY("HashSetRO", m_HashSetMember),
    EZ_SET_ACCESSOR_PROPERTY("HashAcSet", GetHashSet, HashInsert, HashRemove),
    EZ_SET_ACCESSOR_PROPERTY_READ_ONLY("HashAcSetRO", GetHashSet),
    EZ_SET_ACCESSOR_PROPERTY("AcPseudoSet", GetPseudoSet, PseudoInsert, PseudoRemove),
    EZ_SET_ACCESSOR_PROPERTY_READ_ONLY("AcPseudoSetRO", GetPseudoSet),
    EZ_SET_ACCESSOR_PROPERTY("AcPseudoSet2", GetPseudoSet2, PseudoInsert2, PseudoRemove2),
    EZ_SET_ACCESSOR_PROPERTY_READ_ONLY("AcPseudoSet2RO", GetPseudoSet2),
    EZ_SET_ACCESSOR_PROPERTY("AcPseudoSet2b", GetPseudoSet2, PseudoInsert2b, PseudoRemove2b),
    EZ_SET_MEMBER_PROPERTY("CustomHashSet", m_CustomVariant),
    EZ_SET_MEMBER_PROPERTY_READ_ONLY("CustomHashSetRO", m_CustomVariant),
    EZ_SET_ACCESSOR_PROPERTY("CustomHashAcSet", GetCustomHashSet, CustomHashInsert, CustomHashRemove),
    EZ_SET_ACCESSOR_PROPERTY_READ_ONLY("CustomHashAcSetRO", GetCustomHashSet),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;
// clang-format on

const ezSet<double>& ezTestSets::GetSet() const
{
  return m_SetAccessor;
}

void ezTestSets::Insert(double value)
{
  m_SetAccessor.Insert(value);
}

void ezTestSets::Remove(double value)
{
  m_SetAccessor.Remove(value);
}


const ezHashSet<ezInt64>& ezTestSets::GetHashSet() const
{
  return m_HashSetAccessor;
}

void ezTestSets::HashInsert(ezInt64 value)
{
  m_HashSetAccessor.Insert(value);
}

void ezTestSets::HashRemove(ezInt64 value)
{
  m_HashSetAccessor.Remove(value);
}

const ezDeque<int>& ezTestSets::GetPseudoSet() const
{
  return m_Deque;
}

void ezTestSets::PseudoInsert(int value)
{
  if (!m_Deque.Contains(value))
    m_Deque.PushBack(value);
}

void ezTestSets::PseudoRemove(int value)
{
  m_Deque.RemoveAndCopy(value);
}


ezArrayPtr<const ezString> ezTestSets::GetPseudoSet2() const
{
  return m_Array;
}

void ezTestSets::PseudoInsert2(const ezString& value)
{
  if (!m_Array.Contains(value))
    m_Array.PushBack(value);
}

void ezTestSets::PseudoRemove2(const ezString& value)
{
  m_Array.RemoveAndCopy(value);
}

void ezTestSets::PseudoInsert2b(const char* value)
{
  if (!m_Array.Contains(value))
    m_Array.PushBack(value);
}

void ezTestSets::PseudoRemove2b(const char* value)
{
  m_Array.RemoveAndCopy(value);
}

const ezHashSet<ezVarianceTypeAngle>& ezTestSets::GetCustomHashSet() const
{
  return m_CustomVariant;
}

void ezTestSets::CustomHashInsert(ezVarianceTypeAngle value)
{
  m_CustomVariant.Insert(value);
}

void ezTestSets::CustomHashRemove(ezVarianceTypeAngle value)
{
  m_CustomVariant.Remove(value);
}

// clang-format off
EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezTestMaps, 1, ezRTTIDefaultAllocator<ezTestMaps>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_MAP_MEMBER_PROPERTY("Map", m_MapMember),
    EZ_MAP_MEMBER_PROPERTY_READ_ONLY("MapRO", m_MapMember),
    EZ_MAP_WRITE_ACCESSOR_PROPERTY("AcMap", GetContainer, Insert, Remove),
    EZ_MAP_MEMBER_PROPERTY("HashTable", m_HashTableMember),
    EZ_MAP_MEMBER_PROPERTY_READ_ONLY("HashTableRO", m_HashTableMember),
    EZ_MAP_WRITE_ACCESSOR_PROPERTY("AcHashTable", GetContainer2, Insert2, Remove2),
    EZ_MAP_ACCESSOR_PROPERTY("Accessor", GetKeys3, GetValue3, Insert3, Remove3),
    EZ_MAP_ACCESSOR_PROPERTY_READ_ONLY("AccessorRO", GetKeys3, GetValue3),
    EZ_MAP_MEMBER_PROPERTY("CustomVariant", m_CustomVariant),
    EZ_MAP_MEMBER_PROPERTY_READ_ONLY("CustomVariantRO", m_CustomVariant),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;
// clang-format on

bool ezTestMaps::operator==(const ezTestMaps& rhs) const
{
  for (ezUInt32 i = 0; i < m_Accessor3.GetCount(); i++)
  {
    bool bRes = false;
    for (ezUInt32 j = 0; j < rhs.m_Accessor3.GetCount(); j++)
    {
      if (m_Accessor3[i].m_Key == rhs.m_Accessor3[j].m_Key)
      {
        if (m_Accessor3[i].m_Value == rhs.m_Accessor3[j].m_Value)
          bRes = true;
      }
    }
    if (!bRes)
      return false;
  }
  return m_MapMember == rhs.m_MapMember && m_MapAccessor == rhs.m_MapAccessor && m_HashTableMember == rhs.m_HashTableMember && m_HashTableAccessor == rhs.m_HashTableAccessor && m_CustomVariant == rhs.m_CustomVariant;
}

const ezMap<ezString, ezInt64>& ezTestMaps::GetContainer() const
{
  return m_MapAccessor;
}

void ezTestMaps::Insert(const char* szKey, ezInt64 value)
{
  m_MapAccessor.Insert(szKey, value);
}

void ezTestMaps::Remove(const char* szKey)
{
  m_MapAccessor.Remove(szKey);
}

const ezHashTable<ezString, ezString>& ezTestMaps::GetContainer2() const
{
  return m_HashTableAccessor;
}

void ezTestMaps::Insert2(const char* szKey, const ezString& value)
{
  m_HashTableAccessor.Insert(szKey, value);
}


void ezTestMaps::Remove2(const char* szKey)
{
  m_HashTableAccessor.Remove(szKey);
}

const ezRangeView<const char*, ezUInt32> ezTestMaps::GetKeys3() const
{
  return ezRangeView<const char*, ezUInt32>([this]() -> ezUInt32
    { return 0; },
    [this]() -> ezUInt32
    { return m_Accessor3.GetCount(); },
    [this](ezUInt32& ref_uiIt)
    { ++ref_uiIt; },
    [this](const ezUInt32& uiIt) -> const char*
    { return m_Accessor3[uiIt].m_Key; });
}

void ezTestMaps::Insert3(const char* szKey, const ezVariant& value)
{
  for (auto&& t : m_Accessor3)
  {
    if (t.m_Key == szKey)
    {
      t.m_Value = value;
      return;
    }
  }
  auto&& t = m_Accessor3.ExpandAndGetRef();
  t.m_Key = szKey;
  t.m_Value = value;
}

void ezTestMaps::Remove3(const char* szKey)
{
  for (ezUInt32 i = 0; i < m_Accessor3.GetCount(); i++)
  {
    const Tuple& t = m_Accessor3[i];
    if (t.m_Key == szKey)
    {
      m_Accessor3.RemoveAtAndSwap(i);
      break;
    }
  }
}

bool ezTestMaps::GetValue3(const char* szKey, ezVariant& out_value) const
{
  for (const auto& t : m_Accessor3)
  {
    if (t.m_Key == szKey)
    {
      out_value = t.m_Value;
      return true;
    }
  }
  return false;
}

// clang-format off
EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezTestPtr, 1, ezRTTIDefaultAllocator<ezTestPtr>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_ACCESSOR_PROPERTY("ConstCharPtr", GetString, SetString),
    EZ_ACCESSOR_PROPERTY("ArraysPtr", GetArrays, SetArrays)->AddFlags(ezPropertyFlags::PointerOwner),
    EZ_MEMBER_PROPERTY("ArraysPtrDirect", m_pArraysDirect)->AddFlags(ezPropertyFlags::PointerOwner),
    EZ_ARRAY_MEMBER_PROPERTY("PtrArray", m_ArrayPtr)->AddFlags(ezPropertyFlags::PointerOwner),
    EZ_SET_MEMBER_PROPERTY("PtrSet", m_SetPtr)->AddFlags(ezPropertyFlags::PointerOwner),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;


EZ_BEGIN_STATIC_REFLECTED_TYPE(ezTestEnumStruct, ezNoBase, 1, ezRTTIDefaultAllocator<ezTestEnumStruct>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_ENUM_MEMBER_PROPERTY("m_enum", ezExampleEnum, m_enum),
    EZ_ENUM_MEMBER_PROPERTY("m_enumClass", ezExampleEnum, m_enumClass),
    EZ_ENUM_ACCESSOR_PROPERTY("m_enum2", ezExampleEnum, GetEnum, SetEnum),
    EZ_ENUM_ACCESSOR_PROPERTY("m_enumClass2", ezExampleEnum,  GetEnumClass, SetEnumClass),
  }
  EZ_END_PROPERTIES;
}
EZ_END_STATIC_REFLECTED_TYPE;

EZ_BEGIN_STATIC_REFLECTED_TYPE(ezTestBitflagsStruct, ezNoBase, 1, ezRTTIDefaultAllocator<ezTestBitflagsStruct>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_BITFLAGS_MEMBER_PROPERTY("m_bitflagsClass", ezExampleBitflags, m_bitflagsClass),
    EZ_BITFLAGS_ACCESSOR_PROPERTY("m_bitflagsClass2", ezExampleBitflags, GetBitflagsClass, SetBitflagsClass),
  }
  EZ_END_PROPERTIES;
}
EZ_END_STATIC_REFLECTED_TYPE;
// clang-format on