PropertyAttributes.h

#pragma once
 
 
#include <Foundation/Basics.h>
#include <Foundation/Math/ColorScheme.h>
#include <Foundation/Reflection/Reflection.h>
 
class PL_FOUNDATION_DLL plPropertyAttribute : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plPropertyAttribute, plReflectedClass);
};
 
class PL_FOUNDATION_DLL plReadOnlyAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plReadOnlyAttribute, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plHiddenAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plHiddenAttribute, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plTemporaryAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plTemporaryAttribute, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plCategoryAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plCategoryAttribute, plPropertyAttribute);
 
public:
  plCategoryAttribute() = default;
  plCategoryAttribute(const char* szCategory)
    : m_sCategory(szCategory)
  {
  }
 
  const char* GetCategory() const { return m_sCategory; }
 
private:
  plUntrackedString m_sCategory;
};
 
class PL_FOUNDATION_DLL plInDevelopmentAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plInDevelopmentAttribute, plPropertyAttribute);
 
public:
  enum Phase
  {
    Alpha,
    Beta
  };
 
  plInDevelopmentAttribute() = default;
  plInDevelopmentAttribute(plInt32 iPhase) { m_Phase = iPhase; }
 
  const char* GetString() const;
 
  plInt32 m_Phase = Phase::Beta;
};
 
 
class PL_FOUNDATION_DLL plTitleAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plTitleAttribute, plPropertyAttribute);
 
public:
  plTitleAttribute() = default;
  plTitleAttribute(const char* szTitle)
    : m_sTitle(szTitle)
  {
  }
 
  const char* GetTitle() const { return m_sTitle; }
 
private:
  plUntrackedString m_sTitle;
};
 
class PL_FOUNDATION_DLL plIconAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plIconAttribute, plPropertyAttribute);
 
public:
  plIconAttribute() = default;
  plIconAttribute(const char* szIcon)
    : m_sIcon(szIcon)
  {
  }
 
  const char* GetIcon() const { return m_sIcon; }
 
private:
  plUntrackedString m_sIcon;
};
 
class PL_FOUNDATION_DLL plColorAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plColorAttribute, plPropertyAttribute);
 
public:
  plColorAttribute() = default;
  plColorAttribute(const plColor& color)
    : m_Color(color)
  {
  }
  const plColor& GetColor() const { return m_Color; }
 
private:
  plColor m_Color;
};
 
class PL_FOUNDATION_DLL plExposeColorAlphaAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plExposeColorAlphaAttribute, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plSuffixAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plSuffixAttribute, plPropertyAttribute);
 
public:
  plSuffixAttribute() = default;
  plSuffixAttribute(const char* szSuffix)
    : m_sSuffix(szSuffix)
  {
  }
 
  const char* GetSuffix() const { return m_sSuffix; }
 
private:
  plUntrackedString m_sSuffix;
};
 
class PL_FOUNDATION_DLL plMinValueTextAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plMinValueTextAttribute, plPropertyAttribute);
 
public:
  plMinValueTextAttribute() = default;
  plMinValueTextAttribute(const char* szText)
    : m_sText(szText)
  {
  }
 
  const char* GetText() const { return m_sText; }
 
private:
  plUntrackedString m_sText;
};
 
class PL_FOUNDATION_DLL plDefaultValueAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plDefaultValueAttribute, plPropertyAttribute);
 
public:
  plDefaultValueAttribute() = default;
 
  plDefaultValueAttribute(const plVariant& value)
    : m_Value(value)
  {
  }
 
  plDefaultValueAttribute(plInt32 value)
    : m_Value(value)
  {
  }
 
  plDefaultValueAttribute(float value)
    : m_Value(value)
  {
  }
 
  plDefaultValueAttribute(double value)
    : m_Value(value)
  {
  }
 
  plDefaultValueAttribute(plStringView value)
    : m_Value(plVariant(value, false))
  {
  }
 
  plDefaultValueAttribute(const char* value)
    : m_Value(plVariant(plStringView(value), false))
  {
  }
 
  const plVariant& GetValue() const { return m_Value; }
 
private:
  plVariant m_Value;
};
 
class PL_FOUNDATION_DLL plClampValueAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plClampValueAttribute, plPropertyAttribute);
 
public:
  plClampValueAttribute() = default;
  plClampValueAttribute(const plVariant& min, const plVariant& max)
    : m_MinValue(min)
    , m_MaxValue(max)
  {
  }
 
  const plVariant& GetMinValue() const { return m_MinValue; }
  const plVariant& GetMaxValue() const { return m_MaxValue; }
 
protected:
  plVariant m_MinValue;
  plVariant m_MaxValue;
};
 
class PL_FOUNDATION_DLL plGroupAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plGroupAttribute, plPropertyAttribute);
 
public:
  plGroupAttribute();
  plGroupAttribute(const char* szGroup, float fOrder = -1.0f);
  plGroupAttribute(const char* szGroup, const char* szIconName, float fOrder = -1.0f);
 
  const char* GetGroup() const { return m_sGroup; }
  const char* GetIconName() const { return m_sIconName; }
  float GetOrder() const { return m_fOrder; }
 
private:
  plUntrackedString m_sGroup;
  plUntrackedString m_sIconName;
  float m_fOrder = -1.0f;
};
 
class PL_FOUNDATION_DLL plTypeWidgetAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plTypeWidgetAttribute, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plContainerWidgetAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plContainerWidgetAttribute, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plTagSetWidgetAttribute : public plContainerWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plTagSetWidgetAttribute, plContainerWidgetAttribute);
 
public:
  plTagSetWidgetAttribute() = default;
  plTagSetWidgetAttribute(const char* szTagFilter)
    : m_sTagFilter(szTagFilter)
  {
  }
 
  const char* GetTagFilter() const { return m_sTagFilter; }
 
private:
  plUntrackedString m_sTagFilter;
};
 
class PL_FOUNDATION_DLL plNoTemporaryTransactionsAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plNoTemporaryTransactionsAttribute, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plExposedParametersAttribute : public plContainerWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plExposedParametersAttribute, plContainerWidgetAttribute);
 
public:
  plExposedParametersAttribute() = default;
  plExposedParametersAttribute(const char* szParametersSource)
    : m_sParametersSource(szParametersSource)
  {
  }
 
  const char* GetParametersSource() const { return m_sParametersSource; }
 
private:
  plUntrackedString m_sParametersSource;
};
 
class PL_FOUNDATION_DLL plDynamicDefaultValueAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plDynamicDefaultValueAttribute, plTypeWidgetAttribute);
 
public:
  plDynamicDefaultValueAttribute() = default;
  plDynamicDefaultValueAttribute(const char* szClassSource,
    const char* szClassType, const char* szClassProperty = nullptr)
    : m_sClassSource(szClassSource)
    , m_sClassType(szClassType)
    , m_sClassProperty(szClassProperty)
  {
  }
 
  const char* GetClassSource() const { return m_sClassSource; }
  const char* GetClassType() const { return m_sClassType; }
  const char* GetClassProperty() const { return m_sClassProperty; }
 
private:
  plUntrackedString m_sClassSource;
  plUntrackedString m_sClassType;
  plUntrackedString m_sClassProperty;
};
 
 
class PL_FOUNDATION_DLL plContainerAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plContainerAttribute, plPropertyAttribute);
 
public:
  plContainerAttribute() = default;
  plContainerAttribute(bool bCanAdd, bool bCanDelete, bool bCanMove)
  {
    m_bCanAdd = bCanAdd;
    m_bCanDelete = bCanDelete;
    m_bCanMove = bCanMove;
  }
 
  bool CanAdd() const { return m_bCanAdd; }
  bool CanDelete() const { return m_bCanDelete; }
  bool CanMove() const { return m_bCanMove; }
 
private:
  bool m_bCanAdd = false;
  bool m_bCanDelete = false;
  bool m_bCanMove = false;
};
 
struct plDependencyFlags
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    None = 0,              
    Thumbnail = PL_BIT(0), 
    Transform = PL_BIT(1), 
    Package = PL_BIT(2),   
    Default = 0
  };
 
  struct Bits
  {
    StorageType Thumbnail : 1;
    StorageType Transform : 1;
    StorageType Package : 1;
  };
};
 
PL_DECLARE_FLAGS_OPERATORS(plDependencyFlags);
PL_DECLARE_REFLECTABLE_TYPE(PL_FOUNDATION_DLL, plDependencyFlags);
 
class PL_FOUNDATION_DLL plFileBrowserAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plFileBrowserAttribute, plTypeWidgetAttribute);
 
public:
  // Predefined common type filters
  static constexpr plStringView Meshes = "*.obj;*.fbx;*.gltf;*.glb"_plsv;
  static constexpr plStringView MeshesWithAnimations = "*.fbx;*.gltf;*.glb"_plsv;
  static constexpr plStringView ImagesLdrOnly = "*.dds;*.tga;*.png;*.jpg;*.jpeg"_plsv;
  static constexpr plStringView ImagesHdrOnly = "*.hdr;*.exr"_plsv;
  static constexpr plStringView ImagesLdrAndHdr = "*.dds;*.tga;*.png;*.jpg;*.jpeg;*.hdr;*.exr"_plsv;
  static constexpr plStringView CubemapsLdrAndHdr = "*.dds;*.hdr"_plsv;
 
  plFileBrowserAttribute() = default;
  plFileBrowserAttribute(plStringView sDialogTitle, plStringView sTypeFilter, plStringView sCustomAction = {}, plBitflags<plDependencyFlags> depencyFlags = plDependencyFlags::Transform | plDependencyFlags::Thumbnail)
    : m_sDialogTitle(sDialogTitle)
    , m_sTypeFilter(sTypeFilter)
    , m_sCustomAction(sCustomAction)
    , m_DependencyFlags(depencyFlags)
  {
  }
 
  plStringView GetDialogTitle() const { return m_sDialogTitle; }
  plStringView GetTypeFilter() const { return m_sTypeFilter; }
  plStringView GetCustomAction() const { return m_sCustomAction; }
  plBitflags<plDependencyFlags> GetDependencyFlags() const { return m_DependencyFlags; }
 
private:
  plUntrackedString m_sDialogTitle;
  plUntrackedString m_sTypeFilter;
  plUntrackedString m_sCustomAction;
  plBitflags<plDependencyFlags> m_DependencyFlags;
};
 
class PL_FOUNDATION_DLL plExternalFileBrowserAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plExternalFileBrowserAttribute, plTypeWidgetAttribute);
 
public:
  plExternalFileBrowserAttribute() = default;
  plExternalFileBrowserAttribute(plStringView sDialogTitle, plStringView sTypeFilter)
    : m_sDialogTitle(sDialogTitle)
    , m_sTypeFilter(sTypeFilter)
  {
  }
 
  plStringView GetDialogTitle() const { return m_sDialogTitle; }
  plStringView GetTypeFilter() const { return m_sTypeFilter; }
 
private:
  plUntrackedString m_sDialogTitle;
  plUntrackedString m_sTypeFilter;
};
 
class PL_FOUNDATION_DLL plAssetBrowserAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plAssetBrowserAttribute, plTypeWidgetAttribute);
 
public:
  plAssetBrowserAttribute() = default;
  plAssetBrowserAttribute(const char* szTypeFilter, plBitflags<plDependencyFlags> depencyFlags = plDependencyFlags::Thumbnail | plDependencyFlags::Package)
    : m_DependencyFlags(depencyFlags)
  {
    SetTypeFilter(szTypeFilter);
  }
 
  plAssetBrowserAttribute(const char* szTypeFilter, const char* szRequiredTag, plBitflags<plDependencyFlags> depencyFlags = plDependencyFlags::Thumbnail | plDependencyFlags::Package)
    : m_DependencyFlags(depencyFlags)
  {
    SetTypeFilter(szTypeFilter);
    m_sRequiredTag = szRequiredTag;
  }
 
  void SetTypeFilter(const char* szTypeFilter)
  {
    plStringBuilder sTemp(";", szTypeFilter, ";");
    m_sTypeFilter = sTemp;
  }
 
  const char* GetTypeFilter() const { return m_sTypeFilter; }
  plBitflags<plDependencyFlags> GetDependencyFlags() const { return m_DependencyFlags; }
 
  const char* GetRequiredTag() const { return m_sRequiredTag; }
 
private:
  plUntrackedString m_sTypeFilter;
  plUntrackedString m_sRequiredTag;
  plBitflags<plDependencyFlags> m_DependencyFlags;
};
 
class PL_FOUNDATION_DLL plDynamicEnumAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plDynamicEnumAttribute, plTypeWidgetAttribute);
 
public:
  plDynamicEnumAttribute() = default;
  plDynamicEnumAttribute(const char* szDynamicEnumName)
    : m_sDynamicEnumName(szDynamicEnumName)
  {
  }
 
  const char* GetDynamicEnumName() const { return m_sDynamicEnumName; }
 
private:
  plUntrackedString m_sDynamicEnumName;
};
 
class PL_FOUNDATION_DLL plDynamicStringEnumAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plDynamicStringEnumAttribute, plTypeWidgetAttribute);
 
public:
  plDynamicStringEnumAttribute() = default;
  plDynamicStringEnumAttribute(const char* szDynamicEnumName)
    : m_sDynamicEnumName(szDynamicEnumName)
  {
  }
 
  const char* GetDynamicEnumName() const { return m_sDynamicEnumName; }
 
private:
  plUntrackedString m_sDynamicEnumName;
};
 
class PL_FOUNDATION_DLL plDynamicBitflagsAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plDynamicBitflagsAttribute, plTypeWidgetAttribute);
 
public:
  plDynamicBitflagsAttribute() = default;
  plDynamicBitflagsAttribute(plStringView sDynamicName)
    : m_sDynamicBitflagsName(sDynamicName)
  {
  }
 
  plStringView GetDynamicBitflagsName() const { return m_sDynamicBitflagsName; }
 
private:
  plUntrackedString m_sDynamicBitflagsName;
};
 
 
class PL_FOUNDATION_DLL plManipulatorAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plManipulatorAttribute, plPropertyAttribute);
 
public:
  plManipulatorAttribute(const char* szProperty1, const char* szProperty2 = nullptr, const char* szProperty3 = nullptr,
    const char* szProperty4 = nullptr, const char* szProperty5 = nullptr, const char* szProperty6 = nullptr);
 
  plUntrackedString m_sProperty1;
  plUntrackedString m_sProperty2;
  plUntrackedString m_sProperty3;
  plUntrackedString m_sProperty4;
  plUntrackedString m_sProperty5;
  plUntrackedString m_sProperty6;
};
 
 
class PL_FOUNDATION_DLL plSphereManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plSphereManipulatorAttribute, plManipulatorAttribute);
 
public:
  plSphereManipulatorAttribute();
  plSphereManipulatorAttribute(const char* szOuterRadiusProperty, const char* szInnerRadiusProperty = nullptr);
 
  const plUntrackedString& GetOuterRadiusProperty() const { return m_sProperty1; }
  const plUntrackedString& GetInnerRadiusProperty() const { return m_sProperty2; }
};
 
 
 
class PL_FOUNDATION_DLL plCapsuleManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plCapsuleManipulatorAttribute, plManipulatorAttribute);
 
public:
  plCapsuleManipulatorAttribute();
  plCapsuleManipulatorAttribute(const char* szHeightProperty, const char* szRadiusProperty);
 
  const plUntrackedString& GetLengthProperty() const { return m_sProperty1; }
  const plUntrackedString& GetRadiusProperty() const { return m_sProperty2; }
};
 
 
 
class PL_FOUNDATION_DLL plBoxManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plBoxManipulatorAttribute, plManipulatorAttribute);
 
public:
  plBoxManipulatorAttribute();
  plBoxManipulatorAttribute(const char* szSizeProperty, float fSizeScale, bool bRecenterParent, const char* szOffsetProperty = nullptr, const char* szRotationProperty = nullptr);
 
  bool m_bRecenterParent = false;
  float m_fSizeScale = 1.0f;
 
  const plUntrackedString& GetSizeProperty() const { return m_sProperty1; }
  const plUntrackedString& GetOffsetProperty() const { return m_sProperty2; }
  const plUntrackedString& GetRotationProperty() const { return m_sProperty3; }
};
 
 
class PL_FOUNDATION_DLL plNonUniformBoxManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plNonUniformBoxManipulatorAttribute, plManipulatorAttribute);
 
public:
  plNonUniformBoxManipulatorAttribute();
  plNonUniformBoxManipulatorAttribute(
    const char* szNegXProp, const char* szPosXProp, const char* szNegYProp, const char* szPosYProp, const char* szNegZProp, const char* szPosZProp);
  plNonUniformBoxManipulatorAttribute(const char* szSizeX, const char* szSizeY, const char* szSizeZ);
 
  bool HasSixAxis() const { return !m_sProperty4.IsEmpty(); }
 
  const plUntrackedString& GetNegXProperty() const { return m_sProperty1; }
  const plUntrackedString& GetPosXProperty() const { return m_sProperty2; }
  const plUntrackedString& GetNegYProperty() const { return m_sProperty3; }
  const plUntrackedString& GetPosYProperty() const { return m_sProperty4; }
  const plUntrackedString& GetNegZProperty() const { return m_sProperty5; }
  const plUntrackedString& GetPosZProperty() const { return m_sProperty6; }
 
  const plUntrackedString& GetSizeXProperty() const { return m_sProperty1; }
  const plUntrackedString& GetSizeYProperty() const { return m_sProperty2; }
  const plUntrackedString& GetSizeZProperty() const { return m_sProperty3; }
};
 
 
class PL_FOUNDATION_DLL plConeLengthManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plConeLengthManipulatorAttribute, plManipulatorAttribute);
 
public:
  plConeLengthManipulatorAttribute();
  plConeLengthManipulatorAttribute(const char* szRadiusProperty);
 
  const plUntrackedString& GetRadiusProperty() const { return m_sProperty1; }
};
 
 
class PL_FOUNDATION_DLL plConeAngleManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plConeAngleManipulatorAttribute, plManipulatorAttribute);
 
public:
  plConeAngleManipulatorAttribute();
  plConeAngleManipulatorAttribute(const char* szAngleProperty, float fScale = 1.0f, const char* szRadiusProperty = nullptr);
 
  const plUntrackedString& GetAngleProperty() const { return m_sProperty1; }
  const plUntrackedString& GetRadiusProperty() const { return m_sProperty2; }
 
  float m_fScale;
};
 
 
class PL_FOUNDATION_DLL plTransformManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plTransformManipulatorAttribute, plManipulatorAttribute);
 
public:
  plTransformManipulatorAttribute();
  plTransformManipulatorAttribute(const char* szTranslateProperty, const char* szRotateProperty = nullptr, const char* szScaleProperty = nullptr, const char* szOffsetTranslation = nullptr, const char* szOffsetRotation = nullptr);
 
  const plUntrackedString& GetTranslateProperty() const { return m_sProperty1; }
  const plUntrackedString& GetRotateProperty() const { return m_sProperty2; }
  const plUntrackedString& GetScaleProperty() const { return m_sProperty3; }
  const plUntrackedString& GetGetOffsetTranslationProperty() const { return m_sProperty4; }
  const plUntrackedString& GetGetOffsetRotationProperty() const { return m_sProperty5; }
};
 
 
class PL_FOUNDATION_DLL plBoneManipulatorAttribute : public plManipulatorAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plBoneManipulatorAttribute, plManipulatorAttribute);
 
public:
  plBoneManipulatorAttribute();
  plBoneManipulatorAttribute(const char* szTransformProperty, const char* szBindTo);
 
  const plUntrackedString& GetTransformProperty() const { return m_sProperty1; }
};
 
 
struct plVisualizerAnchor
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    Center = 0,
    PosX = PL_BIT(0),
    NegX = PL_BIT(1),
    PosY = PL_BIT(2),
    NegY = PL_BIT(3),
    PosZ = PL_BIT(4),
    NegZ = PL_BIT(5),
 
    Default = Center
  };
 
  struct Bits
  {
    StorageType PosX : 1;
    StorageType NegX : 1;
    StorageType PosY : 1;
    StorageType NegY : 1;
    StorageType PosZ : 1;
    StorageType NegZ : 1;
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_FOUNDATION_DLL, plVisualizerAnchor);
 
 
class PL_FOUNDATION_DLL plVisualizerAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plVisualizerAttribute, plPropertyAttribute);
 
public:
  plVisualizerAttribute(const char* szProperty1, const char* szProperty2 = nullptr, const char* szProperty3 = nullptr,
    const char* szProperty4 = nullptr, const char* szProperty5 = nullptr);
 
  plUntrackedString m_sProperty1;
  plUntrackedString m_sProperty2;
  plUntrackedString m_sProperty3;
  plUntrackedString m_sProperty4;
  plUntrackedString m_sProperty5;
  plBitflags<plVisualizerAnchor> m_Anchor;
};
 
 
class PL_FOUNDATION_DLL plBoxVisualizerAttribute : public plVisualizerAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plBoxVisualizerAttribute, plVisualizerAttribute);
 
public:
  plBoxVisualizerAttribute();
  plBoxVisualizerAttribute(const char* szSizeProperty, float fSizeScale = 1.0f, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr, plBitflags<plVisualizerAnchor> anchor = plVisualizerAnchor::Center, plVec3 vOffsetOrScale = plVec3::MakeZero(), const char* szOffsetProperty = nullptr, const char* szRotationProperty = nullptr);
 
  const plUntrackedString& GetSizeProperty() const { return m_sProperty1; }
  const plUntrackedString& GetColorProperty() const { return m_sProperty2; }
  const plUntrackedString& GetOffsetProperty() const { return m_sProperty3; }
  const plUntrackedString& GetRotationProperty() const { return m_sProperty4; }
 
  float m_fSizeScale = 1.0f;
  plColor m_Color;
  plVec3 m_vOffsetOrScale;
};
 
 
class PL_FOUNDATION_DLL plSphereVisualizerAttribute : public plVisualizerAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plSphereVisualizerAttribute, plVisualizerAttribute);
 
public:
  plSphereVisualizerAttribute();
  plSphereVisualizerAttribute(const char* szRadiusProperty, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr, plBitflags<plVisualizerAnchor> anchor = plVisualizerAnchor::Center, plVec3 vOffsetOrScale = plVec3::MakeZero(), const char* szOffsetProperty = nullptr);
 
  const plUntrackedString& GetRadiusProperty() const { return m_sProperty1; }
  const plUntrackedString& GetColorProperty() const { return m_sProperty2; }
  const plUntrackedString& GetOffsetProperty() const { return m_sProperty3; }
 
  plColor m_Color;
  plVec3 m_vOffsetOrScale;
};
 
 
 
class PL_FOUNDATION_DLL plCapsuleVisualizerAttribute : public plVisualizerAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plCapsuleVisualizerAttribute, plVisualizerAttribute);
 
public:
  plCapsuleVisualizerAttribute();
  plCapsuleVisualizerAttribute(const char* szHeightProperty, const char* szRadiusProperty, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr, plBitflags<plVisualizerAnchor> anchor = plVisualizerAnchor::Center);
 
  const plUntrackedString& GetHeightProperty() const { return m_sProperty1; }
  const plUntrackedString& GetRadiusProperty() const { return m_sProperty2; }
  const plUntrackedString& GetColorProperty() const { return m_sProperty3; }
 
  plColor m_Color;
};
 
 
class PL_FOUNDATION_DLL plCylinderVisualizerAttribute : public plVisualizerAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plCylinderVisualizerAttribute, plVisualizerAttribute);
 
public:
  plCylinderVisualizerAttribute();
  plCylinderVisualizerAttribute(plEnum<plBasisAxis> axis, const char* szHeightProperty, const char* szRadiusProperty, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr, plBitflags<plVisualizerAnchor> anchor = plVisualizerAnchor::Center, plVec3 vOffsetOrScale = plVec3::MakeZero(), const char* szOffsetProperty = nullptr);
  plCylinderVisualizerAttribute(const char* szAxisProperty, const char* szHeightProperty, const char* szRadiusProperty, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr, plBitflags<plVisualizerAnchor> anchor = plVisualizerAnchor::Center, plVec3 vOffsetOrScale = plVec3::MakeZero(), const char* szOffsetProperty = nullptr);
 
  const plUntrackedString& GetAxisProperty() const { return m_sProperty5; }
  const plUntrackedString& GetHeightProperty() const { return m_sProperty1; }
  const plUntrackedString& GetRadiusProperty() const { return m_sProperty2; }
  const plUntrackedString& GetColorProperty() const { return m_sProperty3; }
  const plUntrackedString& GetOffsetProperty() const { return m_sProperty4; }
 
  plColor m_Color;
  plVec3 m_vOffsetOrScale;
  plEnum<plBasisAxis> m_Axis;
};
 
 
class PL_FOUNDATION_DLL plDirectionVisualizerAttribute : public plVisualizerAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plDirectionVisualizerAttribute, plVisualizerAttribute);
 
public:
  plDirectionVisualizerAttribute();
  plDirectionVisualizerAttribute(plEnum<plBasisAxis> axis, float fScale, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr, const char* szLengthProperty = nullptr);
  plDirectionVisualizerAttribute(const char* szAxisProperty, float fScale, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr, const char* szLengthProperty = nullptr);
 
  const plUntrackedString& GetColorProperty() const { return m_sProperty1; }
  const plUntrackedString& GetLengthProperty() const { return m_sProperty2; }
  const plUntrackedString& GetAxisProperty() const { return m_sProperty3; }
 
  plEnum<plBasisAxis> m_Axis;
  plColor m_Color;
  float m_fScale;
};
 
 
class PL_FOUNDATION_DLL plConeVisualizerAttribute : public plVisualizerAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plConeVisualizerAttribute, plVisualizerAttribute);
 
public:
  plConeVisualizerAttribute();
 
  plConeVisualizerAttribute(plEnum<plBasisAxis> axis, const char* szAngleProperty, float fScale, const char* szRadiusProperty, const plColor& fixedColor = plColorScheme::LightUI(plColorScheme::Grape), const char* szColorProperty = nullptr);
 
  const plUntrackedString& GetAngleProperty() const { return m_sProperty1; }
  const plUntrackedString& GetRadiusProperty() const { return m_sProperty2; }
  const plUntrackedString& GetColorProperty() const { return m_sProperty3; }
 
  plEnum<plBasisAxis> m_Axis;
  plColor m_Color;
  float m_fScale;
};
 
 
class PL_FOUNDATION_DLL plCameraVisualizerAttribute : public plVisualizerAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plCameraVisualizerAttribute, plVisualizerAttribute);
 
public:
  plCameraVisualizerAttribute();
 
  plCameraVisualizerAttribute(const char* szModeProperty, const char* szFovProperty, const char* szOrthoDimProperty, const char* szNearPlaneProperty, const char* szFarPlaneProperty);
 
  const plUntrackedString& GetModeProperty() const { return m_sProperty1; }
  const plUntrackedString& GetFovProperty() const { return m_sProperty2; }
  const plUntrackedString& GetOrthoDimProperty() const { return m_sProperty3; }
  const plUntrackedString& GetNearPlaneProperty() const { return m_sProperty4; }
  const plUntrackedString& GetFarPlaneProperty() const { return m_sProperty5; }
};
 
 
// Implementation moved here as it requires plPropertyAttribute to be fully defined.
template <typename Type>
const Type* plRTTI::GetAttributeByType() const
{
  for (const auto* pAttr : m_Attributes)
  {
    if (pAttr->GetDynamicRTTI()->IsDerivedFrom<Type>())
      return static_cast<const Type*>(pAttr);
  }
  if (GetParentType() != nullptr)
    return GetParentType()->GetAttributeByType<Type>();
  else
    return nullptr;
}
 
template <typename Type>
const Type* plAbstractProperty::GetAttributeByType() const
{
  for (const auto* pAttr : m_Attributes)
  {
    if (pAttr->GetDynamicRTTI()->IsDerivedFrom<Type>())
      return static_cast<const Type*>(pAttr);
  }
  return nullptr;
}
 
 
class PL_FOUNDATION_DLL plMaxArraySizeAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plMaxArraySizeAttribute, plPropertyAttribute);
 
public:
  plMaxArraySizeAttribute() = default;
  plMaxArraySizeAttribute(plUInt32 uiMaxSize) { m_uiMaxSize = uiMaxSize; }
 
  const plUInt32& GetMaxSize() const { return m_uiMaxSize; }
 
private:
  plUInt32 m_uiMaxSize = 0;
};
 
 
class PL_FOUNDATION_DLL plPreventDuplicatesAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plPreventDuplicatesAttribute, plPropertyAttribute);
 
public:
  plPreventDuplicatesAttribute() = default;
};
 
 
class PL_FOUNDATION_DLL plExcludeFromScript : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plExcludeFromScript, plPropertyAttribute);
};
 
class PL_FOUNDATION_DLL plScriptableFunctionAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plScriptableFunctionAttribute, plPropertyAttribute);
 
  enum ArgType : plUInt8
  {
    In,
    Out,
    Inout
  };
 
  plScriptableFunctionAttribute(ArgType argType1 = In, const char* szArg1 = nullptr, ArgType argType2 = In, const char* szArg2 = nullptr,
    ArgType argType3 = In, const char* szArg3 = nullptr, ArgType argType4 = In, const char* szArg4 = nullptr, ArgType argType5 = In,
    const char* szArg5 = nullptr, ArgType argType6 = In, const char* szArg6 = nullptr);
 
  plUInt32 GetArgumentCount() const { return m_ArgNames.GetCount(); }
  const char* GetArgumentName(plUInt32 uiIndex) const { return m_ArgNames[uiIndex]; }
 
  ArgType GetArgumentType(plUInt32 uiIndex) const { return static_cast<ArgType>(m_ArgTypes[uiIndex]); }
 
private:
  plHybridArray<plUntrackedString, 6> m_ArgNames;
  plHybridArray<plUInt8, 6> m_ArgTypes;
};
 
class PL_FOUNDATION_DLL plFunctionArgumentAttributes : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plFunctionArgumentAttributes, plPropertyAttribute);
 
  plFunctionArgumentAttributes() = default;
  plFunctionArgumentAttributes(plUInt32 uiArgIndex, const plPropertyAttribute* pAttribute1, const plPropertyAttribute* pAttribute2 = nullptr, const plPropertyAttribute* pAttribute3 = nullptr, const plPropertyAttribute* pAttribute4 = nullptr);
  ~plFunctionArgumentAttributes();
 
  plUInt32 GetArgumentIndex() const { return m_uiArgIndex; }
  plArrayPtr<const plPropertyAttribute* const> GetArgumentAttributes() const { return m_ArgAttributes; }
 
private:
  plUInt32 m_uiArgIndex = 0;
  plHybridArray<const plPropertyAttribute*, 4> m_ArgAttributes;
};
 
class PL_FOUNDATION_DLL plDynamicPinAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plDynamicPinAttribute, plPropertyAttribute);
 
public:
  plDynamicPinAttribute() = default;
  plDynamicPinAttribute(const char* szProperty);
 
  const plUntrackedString& GetProperty() const { return m_sProperty; }
 
private:
  plUntrackedString m_sProperty;
};
 
 
class PL_FOUNDATION_DLL plLongOpAttribute : public plPropertyAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plLongOpAttribute, plPropertyAttribute);
 
public:
  plLongOpAttribute() = default;
  plLongOpAttribute(const char* szOpTypeName)
    : m_sOpTypeName(szOpTypeName)
  {
  }
 
  plUntrackedString m_sOpTypeName;
};
 
 
class PL_FOUNDATION_DLL plGameObjectReferenceAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plGameObjectReferenceAttribute, plTypeWidgetAttribute);
 
public:
  plGameObjectReferenceAttribute() = default;
};
 
 
class PL_FOUNDATION_DLL plImageSliderUiAttribute : public plTypeWidgetAttribute
{
  PL_ADD_DYNAMIC_REFLECTION(plImageSliderUiAttribute, plTypeWidgetAttribute);
 
public:
  plImageSliderUiAttribute() = default;
  plImageSliderUiAttribute(const char* szImageGenerator)
  {
    m_sImageGenerator = szImageGenerator;
  }
 
  plUntrackedString m_sImageGenerator;
};