Merge pull request #64 from SHADE-DP/SP3-4-editor_fix

New editor widgets and windows
Add new editor widgets
Handle remaining reflected types for component view (arithmetic and enumerations)
Add simple profiler

SHADE_Engine/src/ECS_Base/UnitTesting/SHTestComponents.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../Components/SHComponent.h"
+#include <rttr/registration>
 
 namespace SHADE
 {
@@ -27,4 +28,50 @@ namespace SHADE
 		std::string value{};
 	};
 
+	class SHComponent_ENUM : public SHComponent
+	{
+	public:
+		enum class Option
+		{
+		  OPT_A,
+			OPT_B,
+			OPT_C
+		};
+
+		bool boolTest{};
+		int intTest{};
+		float floatTest{};
+		double doubleTest{};
+		long longTest{};
+		uint8_t uint8Test{};
+		uint16_t uint16Test{};
+		uint32_t uint32Test{};
+		uint64_t uint64Test{};
+
+		
+		Option option;
+		RTTR_ENABLE()
+	};
+
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+		registration::enumeration<SHComponent_ENUM::Option>("Option")
+		(
+			value("Option A", SHComponent_ENUM::Option::OPT_A),
+			value("Option B", SHComponent_ENUM::Option::OPT_B),
+			value("Option C", SHComponent_ENUM::Option::OPT_C)
+		);
+		rttr::registration::class_<SHComponent_ENUM>("Enum Component")
+		.property("Option", &SHComponent_ENUM::option)
+		.property("boolTest", &SHComponent_ENUM::boolTest)
+		.property("intTest", &SHComponent_ENUM::intTest)( metadata("MIN", 0.0f), metadata("MAX", 1.f))
+		.property("floatTest", &SHComponent_ENUM::floatTest)(metadata("MIN", 0.0f), metadata("MAX", 1.f))
+		.property("doubleTest", &SHComponent_ENUM::doubleTest)(metadata("MIN", 0.0f), metadata("MAX", 1.f))
+		.property("uint8Test", &SHComponent_ENUM::uint8Test)(metadata("MIN", 0.0f), metadata("MAX", 1.f))
+		.property("uint16Test", &SHComponent_ENUM::uint16Test)(metadata("MIN", 0.0f), metadata("MAX", 1.f))
+		.property("uint32Test", &SHComponent_ENUM::uint32Test)(metadata("MIN", 0.0f), metadata("MAX", 1.f))
+		.property("uint64Test", &SHComponent_ENUM::uint64Test)(metadata("MIN", 0.0f), metadata("MAX", 1.f));
+	}
+
 }

SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp

@@ -12,6 +12,7 @@
 #include "Editor/IconsMaterialDesign.h"
 #include "ECS_Base/Components/SHComponent.h"
 #include "Editor/SHEditorWidgets.hpp"
+#include "Reflection/SHReflectionMetadata.h"
 namespace SHADE
 {
   template<typename T, std::enable_if_t<std::is_base_of<SHComponent, T>::value, bool> = true>
@@ -55,7 +56,124 @@ namespace SHADE
       {
         auto const& type = property.get_type();
 
-        if (type == rttr::type::get<SHVec4>())
+        if(type.is_enumeration())
+        {
+          auto enumAlign = type.get_enumeration();
+          auto names = enumAlign.get_names();
+          std::vector<const char*> list;
+          for(auto const& name : names)
+            list.push_back(name.data());
+          ComboBox(property.get_name().data(), list, [component, property]{return property.get_value(component).to_int();}, [component, property](int const& idx)
+          {
+            auto enumAlign = property.get_enumeration();
+            auto values = enumAlign.get_values();
+            auto it = std::next(values.begin(), idx);
+            property.set_value(component, *it);
+          });
+        }
+        else if(type.is_arithmetic())
+        {
+          if (type == rttr::type::get<bool>())
+          {
+            CheckBox(property.get_name().data(), [component, property]{return property.get_value(component).to_bool();}, [component, property](bool const& result){property.set_value(component, result);});
+          }
+          //else if (type == rttr::type::get<char>())
+          //{
+          //  
+          //}
+          else if (type == rttr::type::get<int8_t>() || type == rttr::type::get<int16_t>() || type == rttr::type::get<int32_t>() || type == rttr::type::get<int64_t>())
+          {
+            auto metaMin = property.get_metadata(META::min);
+            auto metaMax = property.get_metadata(META::max);
+            if(metaMin && metaMax)
+            {
+              SliderInt(property.get_name().data(), metaMin.template get_value<int>(), metaMin.template get_value<int>(), [component, property]{return property.get_value(component).to_int();}, [component, property](int const& result){property.set_value(component, result);});
+            }
+            else
+            {
+              DragInt(property.get_name().data(), [component, property]{return property.get_value(component).to_int();}, [component, property](int const& result){property.set_value(component, result);});
+            }
+          }
+          else if (type == rttr::type::get<uint8_t>())
+          {
+            auto metaMin = property.get_metadata(META::min);
+            auto metaMax = property.get_metadata(META::max);
+            if(metaMin.is_valid() && metaMax.is_valid())
+            {
+              SliderScalar<uint8_t>(property.get_name().data(), ImGuiDataType_U8, metaMin.template get_value<uint8_t>(), metaMax.template get_value<uint8_t>(), [component, property]{return property.get_value(component).to_uint8();}, [component, property](uint8_t const& result){property.set_value(component, result);},"%zu");
+            }
+            else
+            {
+              DragScalar<uint8_t>(property.get_name().data(), ImGuiDataType_U8, [component, property]{return property.get_value(component).to_uint8();}, [component, property](uint8_t const& result){property.set_value(component, result);},0.1f,0,0,"%zu");
+            }
+          }
+          else if (type == rttr::type::get<uint16_t>())
+          {
+            auto metaMin = property.get_metadata(META::min);
+            auto metaMax = property.get_metadata(META::max);
+            if(metaMin.is_valid() && metaMax.is_valid())
+            {
+              SliderScalar<uint16_t>(property.get_name().data(), ImGuiDataType_U16, metaMin.template get_value<uint16_t>(), metaMin.template get_value<uint16_t>(), [component, property]{return property.get_value(component).to_uint16();}, [component, property](uint16_t const& result){property.set_value(component, result);},"%zu");
+            }
+            else
+            {
+              DragScalar<uint16_t>(property.get_name().data(), ImGuiDataType_U16, [component, property]{return property.get_value(component).to_uint16();}, [component, property](uint16_t const& result){property.set_value(component, result);},0.1f,0,0,"%zu");
+            }
+          }
+          else if (type == rttr::type::get<uint32_t>())
+          {
+            auto metaMin = property.get_metadata(META::min);
+            auto metaMax = property.get_metadata(META::max);
+            if (metaMin.is_valid() && metaMax.is_valid())
+            {
+              SliderScalar<uint32_t>(property.get_name().data(), ImGuiDataType_U32, metaMin.template get_value<uint32_t>(), metaMin.template get_value<uint32_t>(), [component, property]{ return property.get_value(component).to_uint32(); }, [component, property](uint32_t const& result){property.set_value(component, result); },"%zu");
+            }
+            else
+            {
+              DragScalar<uint32_t>(property.get_name().data(), ImGuiDataType_U32, [component, property]{ return property.get_value(component).to_uint32(); }, [component, property](uint32_t const& result){property.set_value(component, result); },0.1f,0,0,"%zu");
+            }
+          }
+          else if (type == rttr::type::get<uint64_t>())
+          {
+            auto metaMin = property.get_metadata(META::min);
+            auto metaMax = property.get_metadata(META::max);
+            if(metaMin.is_valid() && metaMax.is_valid())
+            {
+              SliderScalar<uint64_t>(property.get_name().data(), ImGuiDataType_U64, metaMin.template get_value<uint64_t>(), metaMin.template get_value<uint64_t>(), [component, property]{return property.get_value(component).to_uint64();}, [component, property](uint64_t const& result){property.set_value(component, result);},"%zu");
+            }
+            else
+            {
+              DragScalar<uint64_t>(property.get_name().data(), ImGuiDataType_U64, [component, property]{return property.get_value(component).to_uint64();}, [component, property](uint64_t const& result){property.set_value(component, result);},0.1f,0,0,"%zu");
+            }
+          }
+          else if (type == rttr::type::get<float>())
+          {
+            auto metaMin = property.get_metadata(META::min);
+            auto metaMax = property.get_metadata(META::max);
+            if(metaMin.is_valid() && metaMax.is_valid())
+            {
+              SliderFloat(property.get_name().data(), metaMin.template get_value<float>(), metaMin.template get_value<float>(), [component, property]{return property.get_value(component).to_float();}, [component, property](float const& result){property.set_value(component, result);});
+            }
+            else
+            {
+              DragFloat(property.get_name().data(), [component, property]{return property.get_value(component).to_float();}, [component, property](float const& result){property.set_value(component, result);});
+            }
+          }
+          else if (type == rttr::type::get<double>())
+          {
+            auto metaMin = property.get_metadata(META::min);
+            auto metaMax = property.get_metadata(META::max);
+            if(metaMin.is_valid() && metaMax.is_valid())
+            {
+              SliderScalar<double>(property.get_name().data(), ImGuiDataType_Double, metaMin.template get_value<double>(), metaMin.template get_value<double>(), [component, property]{return property.get_value(component).to_double();}, [component, property](double const& result){property.set_value(component, result);});
+            }
+            else
+            {
+              DragScalar<double>(property.get_name().data(), ImGuiDataType_Double, [component, property]{return property.get_value(component).to_double();}, [component, property](double const& result){property.set_value(component, result);}, 0.1f);
+            }
+          }
+        }
+        else if (type == rttr::type::get<SHVec4>())
         {
           DragVec4(property.get_name().data(), { "X", "Y", "Z", "W" }, [component, property]() {return property.get_value(component).template convert<SHVec4>(); }, [component, property](SHVec4 vec) {return property.set_value(component, vec); });
         }
@@ -63,6 +181,11 @@ namespace SHADE
         {
           DragVec3(property.get_name().data(), { "X", "Y", "Z" }, [component, property]() {return property.get_value(component).template convert<SHVec3>(); }, [component, property](SHVec3 vec) {return property.set_value(component, vec); });
         }
+        else if (type == rttr::type::get<SHVec2>())
+        {
+          DragVec2(property.get_name().data(), { "X", "Y"}, [component, property]() {return property.get_value(component).template convert<SHVec2>(); }, [component, property](SHVec2 vec) {return property.set_value(component, vec); });
+        }
+        
       }
     }
     else DrawContextMenu(component);

SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp

@@ -11,6 +11,7 @@
 #include "Editor/SHImGuiHelpers.hpp"
 #include "Editor/SHEditorWidgets.hpp"
 #include "SHEditorComponentView.hpp"
+#include "ECS_Base/UnitTesting/SHTestComponents.h"
 #include "Graphics/MiddleEnd/Interface/SHRenderable.h"
 
 #include "ECS_Base/Managers/SHSystemManager.h"
@@ -57,11 +58,20 @@ namespace SHADE
         {
           DrawComponent(transformComponent);
         }
+        if(auto renderableComponent = SHComponentManager::GetComponent_s<SHRenderable>(eid))
+        {
+          DrawComponent(renderableComponent);
+        }
+        if(auto testComponent = SHComponentManager::GetComponent_s<SHComponent_ENUM>(eid))
+        {
+          DrawComponent(testComponent);
+        }
         ImGui::Separator();
         if(ImGui::BeginMenu(std::format("{} Add Component", ICON_MD_LIBRARY_ADD).data()))
         {
           DrawAddComponentButton<SHTransformComponent>(eid);
           DrawAddComponentButton<SHRenderable>(eid);
+          DrawAddComponentButton<SHComponent_ENUM>(eid);
           ImGui::EndMenu();
         }
       }

SHADE_Engine/src/Editor/EditorWindow/Profiling/SHEditorProfiler.cpp

@@ -0,0 +1,48 @@
+#include "SHpch.h"
+#include "SHEditorProfiler.h"
+#include <imgui.h>
+
+#include "ECS_Base/Managers/SHSystemManager.h"
+#include "FRC/SHFramerateController.h"
+
+namespace SHADE
+{
+  SHEditorProfiler::SHEditorProfiler()
+    :SHEditorWindow("Profiler", ImGuiWindowFlags_None)
+  {
+  }
+
+  void SHEditorProfiler::Init()
+  {
+    SHEditorWindow::Init();
+  }
+
+  void SHEditorProfiler::Update()
+  {
+    SHEditorWindow::Update();
+
+    const float dt = static_cast<float>(SHFrameRateController::GetRawDeltaTime());
+    if(frames.size() > MaxFramesDisplayed)
+    {
+      for (size_t i = 1; i < frames.size(); i++)
+		  {
+			  frames[i-1] = frames[i];
+		  }
+		  frames[frames.size() - 1] = dt;
+    }
+    else
+    {
+      frames.push_back(dt);
+    }
+    if(Begin())
+    {
+      ImGui::PlotLines("DT", frames.data(), static_cast<int>(frames.size()), 0, nullptr, 0.0f, 16.0f);
+      ImGui::End();
+    }
+  }
+
+  void SHEditorProfiler::Exit()
+  {
+    SHEditorWindow::Exit();
+  }
+}

SHADE_Engine/src/Editor/EditorWindow/Profiling/SHEditorProfiler.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Editor/EditorWindow/SHEditorWindow.h"
+#include <vector>
+constexpr uint32_t MaxFramesDisplayed = 100;
+namespace SHADE
+{
+  class SHEditorProfiler final : public SHEditorWindow
+  {
+  public:
+    SHEditorProfiler();
+    void Init() override;
+    void Update() override;
+    void Exit() override;
+
+  private:
+    std::vector<float> frames;
+  };
+}

SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h

@@ -1,4 +1,5 @@
 #pragma once
 #include "MenuBar/SHEditorMenuBar.h"          //Menu Bar
 #include "HierarchyPanel/SHHierarchyPanel.h"  //Hierarchy Panel
-#include "Inspector/SHEditorInspector.h"      //Inspector
+#include "Inspector/SHEditorInspector.h"      //Inspector
+#include "Profiling/SHEditorProfiler.h"       //Profiler

SHADE_Engine/src/Editor/SHEditor.cpp

@@ -95,6 +95,7 @@ namespace SHADE
     CreateEditorWindow<SHEditorMenuBar>();
     CreateEditorWindow<SHHierarchyPanel>();
     CreateEditorWindow<SHEditorInspector>();
+    CreateEditorWindow<SHEditorProfiler>();
 
     SHLOG_INFO("Successfully initialised SHADE Engine Editor")
   }
@@ -106,7 +107,8 @@ namespace SHADE
 
     for (const auto& window : editorWindows | std::views::values)
     {
-      window->Update();
+      if(window->isOpen)
+        window->Update();
     }
 
     if(ImGui::IsKeyDown(ImGuiKey_LeftShift) && ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyReleased(ImGuiKey_Z))
@@ -292,6 +294,8 @@ namespace SHADE
     imguiCommandBuffer->EndRecording();
     gfxSystem->GetQueue()->SubmitCommandBuffer({ imguiCommandBuffer }, {}, {}, vk::PipelineStageFlagBits::eNone, {});
 
+    gfxSystem->GetDevice()->WaitIdle();
+
     ImGui_ImplVulkan_DestroyFontUploadObjects();
 
     renderGraph->GetNode("ImGui Node")->GetSubpass("ImGui Draw")->AddExteriorDrawCalls([](Handle<SHVkCommandBuffer>& cmd) {

SHADE_Engine/src/Editor/SHEditorWidgets.hpp

@@ -80,13 +80,13 @@ namespace SHADE
     return valueChanged;
   }
 
-    static bool DragVec2(const std::string& fieldLabel, std::vector<std::string>const& componentLabels, std::function<SHVec2(void)> get,
+  static bool DragVec2(const std::string& fieldLabel, std::vector<std::string>const& componentLabels, std::function<SHVec2(void)> get,
     std::function<void(SHVec2)> set, float speed = 0.1f, const char* displayFormat = "%.3f", float valueMin = 0.0f, float valueMax = 0.0f,
     ImGuiSliderFlags flags = 0)
   {
     SHVec2 values = get();
     bool changed = false;
-    if (DragN<float, 2>(fieldLabel, componentLabels, {&values.x, &values.y}, speed, displayFormat, valueMin, valueMax, flags))
+    if (DragN<float, 2>(fieldLabel, componentLabels, { &values.x, &values.y }, speed, displayFormat, valueMin, valueMax, flags))
     {
       changed = true;
     }
@@ -95,22 +95,22 @@ namespace SHADE
     {
       if (ImGui::IsMouseClicked(ImGuiMouseButton_Left) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left))
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec2>>(get(), values, set)), false);
-      else if(ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec2>>(get(), values, set)), true);
-      else if(ImGui::IsItemDeactivatedAfterEdit())
+      else if (ImGui::IsItemDeactivatedAfterEdit())
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec2>>(get(), values, set)), false);
     }
 
     return changed;
   }
 
-      static bool DragVec3(const std::string& fieldLabel, std::vector<std::string>const& componentLabels, std::function<SHVec3(void)> get,
+  static bool DragVec3(const std::string& fieldLabel, std::vector<std::string>const& componentLabels, std::function<SHVec3(void)> get,
     std::function<void(SHVec3)> set, float speed = 0.1f, const char* displayFormat = "%.3f", float valueMin = 0.0f, float valueMax = 0.0f,
     ImGuiSliderFlags flags = 0)
   {
     SHVec3 values = get();
     bool changed = false;
-    if (DragN<float, 3>(fieldLabel, componentLabels, {&values.x, &values.y, &values.z}, speed, displayFormat, valueMin, valueMax, flags))
+    if (DragN<float, 3>(fieldLabel, componentLabels, { &values.x, &values.y, &values.z }, speed, displayFormat, valueMin, valueMax, flags))
     {
       changed = true;
     }
@@ -119,22 +119,22 @@ namespace SHADE
     {
       if (ImGui::IsMouseDown(ImGuiMouseButton_Left) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left, -0.2f))
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec3>>(get(), values, set)), false);
-      else if(ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec3>>(get(), values, set)), true);
-      else if(ImGui::IsItemDeactivatedAfterEdit())
+      else if (ImGui::IsItemDeactivatedAfterEdit())
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec3>>(get(), values, set)), false);
     }
 
     return changed;
   }
 
-        static bool DragVec4(const std::string& fieldLabel, std::vector<std::string>const& componentLabels, std::function<SHVec4(void)> get,
+  static bool DragVec4(const std::string& fieldLabel, std::vector<std::string>const& componentLabels, std::function<SHVec4(void)> get,
     std::function<void(SHVec4)> set, float speed = 0.1f, const char* displayFormat = "%.3f", float valueMin = 0.0f, float valueMax = 0.0f,
     ImGuiSliderFlags flags = 0)
   {
     SHVec4 values = get();
     bool changed = false;
-    if (DragN<float, 4>(fieldLabel, componentLabels, {&values.x, &values.y, &values.z, &values.w}, speed, displayFormat, valueMin, valueMax, flags))
+    if (DragN<float, 4>(fieldLabel, componentLabels, { &values.x, &values.y, &values.z, &values.w }, speed, displayFormat, valueMin, valueMax, flags))
     {
       changed = true;
     }
@@ -143,9 +143,9 @@ namespace SHADE
     {
       if (ImGui::IsMouseDown(ImGuiMouseButton_Left) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left, -0.2f))
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec4>>(get(), values, set)), false);
-      else if(ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec4>>(get(), values, set)), true);
-      else if(ImGui::IsItemDeactivatedAfterEdit())
+      else if (ImGui::IsItemDeactivatedAfterEdit())
         SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<SHVec4>>(get(), values, set)), false);
     }
 
@@ -155,7 +155,7 @@ namespace SHADE
   //#==============================================================#
   //||                     Widget Extensions                      ||
   //#==============================================================#
-        
+
   static bool CheckBox(std::string const& label, std::function<bool(void)> get, std::function<void(bool const&)> set)
   {
     bool value = get();
@@ -182,6 +182,149 @@ namespace SHADE
     return true;
   }
 
-  
+  static bool InputText(const std::string& label, const std::function<std::string(void)> get,
+    const std::function<void(std::string)> set, ImGuiInputTextFlags flag = 0,
+    ImGuiInputTextCallback callback = (ImGuiInputTextCallback)0, void* userData = (void*)0)
+  {
+    std::string text = get();
+    if (ImGui::InputText(label.c_str(), &text, flag, callback, userData))
+    {
+      if (ImGui::IsItemDeactivatedAfterEdit())
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<std::string>>(get(), text, set)), false);
+
+      return true;
+    }
+    return false;
+  }
+
+  template <typename T>
+  static bool DragScalar(const std::string& fieldLabel, ImGuiDataType data_type, std::function<T(void)> get, std::function<void(T const&)> set,
+    float speed = 1.0f, T p_min = T(), T p_max = T(), const char* displayFormat = "%.3f", ImGuiSliderFlags flags = 0)
+  {
+    T value = get();
+    std::cout << value <<" \n";
+    //bool hasChange = ImGui::DragScalar(fieldLabel.c_str(), data_type, &value, speed, &p_min, &p_max, displayFormat, flags);
+
+    if (ImGui::DragScalar(fieldLabel.c_str(), data_type, &value, speed, &p_min, &p_max, displayFormat, flags))
+    {
+      if (ImGui::IsMouseDown(ImGuiMouseButton_Left) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<T>>(get(), value, set)), false);
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<T>>(get(), value, set)), true);
+      else if (ImGui::IsItemDeactivatedAfterEdit())
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<T>>(get(), value, set)), false);
+
+      return true;
+    }
+    return false;
+  }
+
+  static bool DragFloat(const std::string& fieldLabel, std::function<float(void)> get, std::function<void(float const&)> set,
+    float speed = 0.1f, float p_min = float(), float p_max = float(), const char* displayFormat = "%.3f", ImGuiSliderFlags flags = 0)
+  {
+    float value = get();
+    //bool hasChange = ImGui::DragFloat(fieldLabel.c_str(), &value, speed, p_min, p_max, displayFormat, flags);
+    if (ImGui::DragFloat(fieldLabel.c_str(), &value, speed, p_min, p_max, displayFormat, flags))
+    {
+      if (ImGui::IsMouseDown(ImGuiMouseButton_Left) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<float>>(get(), value, set)), false);
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<float>>(get(), value, set)), true);
+      else if (ImGui::IsItemDeactivatedAfterEdit())
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<float>>(get(), value, set)), false);
+
+      return true;
+    }
+
+    return false;
+  }
+
+  static bool DragInt(const std::string& fieldLabel, std::function<int(void)> get, std::function<void(int const&)> set,
+    float speed = 1.0f, int p_min = int(), int p_max = int(), const char* displayFormat = "%d", ImGuiSliderFlags flags = 0)
+  {
+    int value = get();
+    //bool hasChange = ImGui::DragFloat(fieldLabel.c_str(), &value, speed, p_min, p_max, displayFormat, flags);
+    if (ImGui::DragInt(fieldLabel.c_str(), &value, speed, p_min, p_max, displayFormat, flags))
+    {
+      if (ImGui::IsMouseDown(ImGuiMouseButton_Left) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<int>>(get(), value, set)), false);
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<int>>(get(), value, set)), true);
+      else if (ImGui::IsItemDeactivatedAfterEdit())
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<int>>(get(), value, set)), false);
+
+      return true;
+    }
+
+    return false;
+  }
+    template <typename T>
+    static bool SliderScalar(const std::string& fieldLabel, ImGuiDataType data_type,  T min, T max, std::function<T(void)> get, std::function<void(T const&)> set,
+    const char* displayFormat = "%.3f", ImGuiSliderFlags flags = 0)
+    {
+      T value = get();
+     if (ImGui::SliderScalar(fieldLabel.c_str(),  data_type, &value, &min, &max, displayFormat, flags))
+     {
+        if (ImGui::IsMouseClicked(ImGuiMouseButton_Left, false) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left, -0.2f))
+          SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<T>>(get(), value, set)), false);
+        else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+          SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<T>>(get(), value, set)), true);
+
+        return true;
+      }
+
+      return false;
+    }
+
+  static bool SliderFloat(const std::string& fieldLabel, float min, float max, std::function<float(void)> get, std::function<void(float const&)> set,
+    const char* displayFormat = "%.3f", ImGuiSliderFlags flags = 0)
+  {
+    float value = get();
+    if (ImGui::SliderFloat(fieldLabel.c_str(), &value, min, max, displayFormat, flags))
+    {
+      if (ImGui::IsMouseClicked(ImGuiMouseButton_Left, false) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left, -0.2f))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<float>>(get(), value, set)), false);
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<float>>(get(), value, set)), true);
+
+
+      return true;
+    }
+
+    return false;
+  }
+
+  static bool SliderInt(const std::string& fieldLabel, int min, int max, std::function<int(void)> get, std::function<void(int const&)> set,
+    const char* displayFormat = "%d", ImGuiSliderFlags flags = 0)
+  {
+    int value = get();
+    if (ImGui::SliderInt(fieldLabel.c_str(), &value, min, max, displayFormat, flags))
+    {
+      if (ImGui::IsMouseClicked(ImGuiMouseButton_Left, false) && !ImGui::IsMouseDragging(ImGuiMouseButton_Left, -0.2f))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<int>>(get(), value, set)), false);
+      else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left))
+        SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<int>>(get(), value, set)), true);
+
+      return true;
+    }
+
+    return false;
+  }
+
+  static bool ComboBox(const std::string& fieldLabel, std::vector<const char*> list, std::function<int(void)> get, std::function<void(int const&)> set)
+  {
+    bool edited = false;
+    int selected = get();
+    ImGui::PushID(fieldLabel.c_str());
+    ImGui::Text(fieldLabel.c_str()); ImGui::SameLine();
+    
+    if (edited = ImGui::Combo("##Combo", &selected, list.data(), list.size()))
+    {
+      SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<int>>(get(), selected, set)), false);
+    }
+    ImGui::PopID();
+    return edited;
+  }
+
 
 }//namespace SHADE

SHADE_Engine/src/Reflection/SHReflectionMetadata.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "string_view"
+namespace SHADE
+{
+  namespace META
+  {
+    constexpr const char* min = "MIN";
+    constexpr const char* max = "MAX";
+    constexpr const char* tooltip = "tooltip";
+  }
+}