Assets/Editor/Editor.SHConfig

@@ -0,0 +1,4 @@
+Start Maximized: true
+Working Scene ID: 97161771
+Window Size: {x: 1920, y: 1080}
+Style: 0

Assets/Scenes/UI_Test.shade

@@ -1,7 +1,7 @@
 - EID: 0
   Name: Canvas
   IsActive: true
-  NumberOfChildren: 1
+  NumberOfChildren: 2
   Components:
     Canvas Component:
       Canvas Width: 10
@@ -14,7 +14,7 @@
   NumberOfChildren: 0
   Components:
     Transform Component:
-      Translate: {x: 0, y: 0, z: 0}
+      Translate: {x: -3.5999999, y: 3.0999999, z: 0}
       Rotate: {x: 0, y: 0, z: 0}
       Scale: {x: 1, y: 1, z: 1}
       IsActive: true
@@ -28,6 +28,26 @@
       Clicked Texture: 0
       IsActive: true
   Scripts: ~
+- EID: 5
+  Name: Default
+  IsActive: true
+  NumberOfChildren: 0
+  Components:
+    Transform Component:
+      Translate: {x: 0, y: -3.9000001, z: 0}
+      Rotate: {x: 0, y: 0, z: 0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
+    Renderable Component:
+      Mesh: 141771688
+      Material: 129340704
+      IsActive: true
+    Toggle Button Component:
+      Non Toggled Texture: 0
+      Toggled Texture: 0
+      Value: true
+      IsActive: true
+  Scripts: ~
 - EID: 1
   Name: Camera
   IsActive: true

Assets/Scenes/UI_Test.shade.shmeta

@@ -1,3 +1,3 @@
 Name: UI_Test
-ID: 87707373
+ID: 87244611
 Type: 5

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

@@ -21,6 +21,7 @@
 #include "UI/SHUIComponent.h"
 #include "UI/SHCanvasComponent.h"
 #include "UI/SHButtonComponent.h"
+#include "UI/SHToggleButtonComponent.h"
 #include "SHEditorComponentView.h"
 #include "AudioSystem/SHAudioListenerComponent.h"
 #include "Graphics/MiddleEnd/TextRendering/SHTextRenderableComponent.h"
@@ -154,6 +155,10 @@ namespace SHADE
         {
           DrawComponent(buttonComponent);
         }
+        if (auto toggleButton = SHComponentManager::GetComponent_s<SHToggleButtonComponent>(eid))
+        {
+          DrawComponent(toggleButton);
+        }
         ImGui::Separator();
         // Render Scripts
         SHScriptEngine* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
@@ -167,6 +172,7 @@ namespace SHADE
           DrawAddComponentButton<SHLightComponent>(eid);
           DrawAddComponentButton<SHCanvasComponent>(eid);
           DrawAddComponentButton<SHButtonComponent>(eid);
+          DrawAddComponentButton<SHToggleButtonComponent>(eid);
 
           // Components that require Transforms
 

SHADE_Engine/src/Events/SHEventDefines.h

@@ -23,4 +23,5 @@ constexpr SHEventIdentifier SH_SCENE_INIT_POST                    { 14 };
 constexpr SHEventIdentifier SH_SCENE_EXIT_PRE                     { 15 }; 
 constexpr SHEventIdentifier SH_SCENE_EXIT_POST                    { 16 }; 
 constexpr SHEventIdentifier SH_GRAPHICS_LIGHT_ENABLE_SHADOW_EVENT { 17 };
+constexpr SHEventIdentifier SH_BUTTON_CLICK_EVENT                 { 18 };
 

SHADE_Engine/src/Serialization/SHSerialization.cpp

@@ -18,6 +18,7 @@
 #include "Physics/Interface/SHRigidBodyComponent.h"
 #include "UI/SHCanvasComponent.h"
 #include "UI/SHButtonComponent.h"
+#include "UI/SHToggleButtonComponent.h"
 #include "ECS_Base/Managers/SHSystemManager.h"
 #include "Graphics/MiddleEnd/Lights/SHLightComponent.h"
 #include "Scripting/SHScriptEngine.h"
@@ -208,6 +209,7 @@ namespace SHADE
 
     AddComponentToComponentNode<SHCanvasComponent>(components, eid);
     AddComponentToComponentNode<SHButtonComponent>(components, eid);
+    AddComponentToComponentNode<SHToggleButtonComponent>(components, eid);
 
     AddComponentToComponentNode<SHTextRenderableComponent>(components, eid);
 
@@ -265,6 +267,7 @@ namespace SHADE
     
     AddComponentID<SHCanvasComponent>(componentIDList, componentsNode);
     AddComponentID<SHButtonComponent>(componentIDList, componentsNode);
+    AddComponentID<SHToggleButtonComponent>(componentIDList, componentsNode);
     AddComponentID<SHTextRenderableComponent>(componentIDList, componentsNode);
 
     return componentIDList;
@@ -346,6 +349,7 @@ namespace SHADE
     
     SHSerializationHelper::InitializeComponentFromNode<SHCanvasComponent>(componentsNode, eid);
     SHSerializationHelper::InitializeComponentFromNode<SHButtonComponent>(componentsNode, eid);
+    SHSerializationHelper::InitializeComponentFromNode<SHToggleButtonComponent>(componentsNode, eid);
     SHSerializationHelper::InitializeComponentFromNode<SHTextRenderableComponent>(componentsNode, eid);
     SHSerializationHelper::InitializeComponentFromNode<SHLightComponent>(componentsNode, eid);
   }

SHADE_Engine/src/UI/Events/SHButtonClickEvent.h

@@ -0,0 +1,16 @@
+#pragma once
+
+
+#include "ECS_Base/SHECSMacros.h"
+
+namespace SHADE
+{
+  struct SHButtonClickEvent
+  {
+    EntityID EID;
+    // value of the toggle button, default to false if its a button and not a toggle button
+    bool value{false};
+  };
+
+
+}

SHADE_Engine/src/UI/SHButtonComponent.cpp

@@ -5,7 +5,7 @@
 namespace SHADE
 {
   SHButtonComponent::SHButtonComponent()
-    :size(1.0f), offset(0.0f), isHovered(false), isClicked(false),
+    :size(1.0f),  isHovered(false), isClicked(false),
     defaultTexture(0), hoveredTexture(0), clickedTexture(0)
   {
   }

SHADE_Engine/src/UI/SHButtonComponent.h

@@ -18,7 +18,6 @@ namespace SHADE
     virtual ~SHButtonComponent() = default;
 
     SHVec2 size;
-    SHVec2 offset;
 
     AssetID GetClickedTexture() const noexcept;
     AssetID GetDefaultTexture() const noexcept;

SHADE_Engine/src/UI/SHSliderComponent.cpp

@@ -0,0 +1,39 @@
+#include "SHpch.h"
+#include "SHSliderComponent.h"
+
+namespace SHADE
+{
+  SHSliderComponent::SHSliderComponent()
+    :size(1.0f), isHovered(false), isClicked(false), value(0.0f)
+  {
+
+  }
+
+
+  float SHSliderComponent::GetValue() const noexcept
+  {
+    return value;
+  }
+
+  void SHSliderComponent::SetValue(float value) noexcept
+  {
+    this->value = value;
+  }
+
+
+
+}
+
+
+RTTR_REGISTRATION
+{
+  using namespace SHADE;
+  using namespace rttr;
+
+  registration::class_<SHSliderComponent>("Slider Component")
+    .property("Slider Value", &SHSliderComponent::GetValue, &SHSliderComponent::SetValue)
+
+    ;
+
+
+}

SHADE_Engine/src/UI/SHSliderComponent.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <rttr/registration>
+
+#include "SH_API.h"
+#include "ECS_Base/Components/SHComponent.h"
+#include "Math/Vector/SHVec3.h"
+#include "Math/Vector/SHVec2.h"
+#include "Assets/SHAssetMacros.h"
+
+namespace SHADE
+{
+
+  class SH_API SHSliderComponent final: public SHComponent
+  {
+  public:
+    SHSliderComponent();
+    virtual ~SHSliderComponent() = default;
+
+    SHVec2 size;
+
+
+    float GetValue() const noexcept;
+
+
+    void SetValue(float value) noexcept;
+
+
+    friend class SHUISystem;
+  private:
+
+    bool isHovered;
+    bool isClicked;
+
+    float value;
+
+    RTTR_ENABLE()
+  };
+
+
+}

SHADE_Engine/src/UI/SHToggleButtonComponent.cpp

@@ -0,0 +1,59 @@
+#include "SHpch.h"
+#include "SHToggleButtonComponent.h"
+
+
+namespace SHADE
+{
+  SHToggleButtonComponent::SHToggleButtonComponent()
+    :size(1.0f), isHovered(false), isClicked(false), value(false),
+    defaultTexture(0), toggledTexture(0)
+  {
+  }
+
+  AssetID SHToggleButtonComponent::GetDefaultTexture() const noexcept
+  {
+    return defaultTexture;
+  }
+
+  AssetID SHToggleButtonComponent::GetToggledTexture() const noexcept
+  {
+    return toggledTexture;
+  }
+
+  bool SHToggleButtonComponent::GetValue() const noexcept
+  {
+    return value;
+  }
+
+
+  void SHToggleButtonComponent::SetDefaultTexture(AssetID texture) noexcept
+  {
+    defaultTexture = texture;
+  }
+
+  void SHToggleButtonComponent::SetToggledTexture(AssetID texture) noexcept
+  {
+    toggledTexture = texture;
+  }
+
+  void SHToggleButtonComponent::SetValue(bool value) noexcept
+  {
+    this->value = value;
+  }
+
+}
+
+
+RTTR_REGISTRATION
+{
+  using namespace SHADE;
+  using namespace rttr;
+
+  registration::class_<SHToggleButtonComponent>("Toggle Button Component")
+    .property("Non Toggled Texture", &SHToggleButtonComponent::GetDefaultTexture, &SHToggleButtonComponent::SetDefaultTexture)
+    .property("Toggled Texture", &SHToggleButtonComponent::GetToggledTexture, &SHToggleButtonComponent::SetToggledTexture)
+    .property("Value", &SHToggleButtonComponent::GetValue, &SHToggleButtonComponent::SetValue)
+    ;
+
+
+}

SHADE_Engine/src/UI/SHToggleButtonComponent.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <rttr/registration>
+
+#include "SH_API.h"
+#include "ECS_Base/Components/SHComponent.h"
+#include "Math/Vector/SHVec3.h"
+#include "Math/Vector/SHVec2.h"
+#include "Assets/SHAssetMacros.h"
+
+namespace SHADE
+{
+
+  class SH_API SHToggleButtonComponent final: public SHComponent
+  {
+  public:
+    SHToggleButtonComponent();
+    virtual ~SHToggleButtonComponent() = default;
+
+    SHVec2 size;
+
+    AssetID GetToggledTexture() const noexcept;
+    AssetID GetDefaultTexture() const noexcept;
+    bool GetValue() const noexcept;
+
+
+    void SetDefaultTexture(AssetID texture) noexcept;
+    void SetToggledTexture(AssetID texture) noexcept;
+    void SetValue(bool value) noexcept;
+
+
+
+    friend class SHUISystem;
+  private:
+
+    bool isHovered;
+    bool isClicked;
+    bool value;
+    AssetID defaultTexture;
+    AssetID toggledTexture;
+    
+
+
+    RTTR_ENABLE()
+  };
+
+
+}

SHADE_Engine/src/UI/SHUISystem.cpp

@@ -10,6 +10,13 @@
 #include "Editor/SHEditor.h"
 #include "Resource/SHResourceManager.h"
 #include "Input/SHInputManager.h"
+#include "SHUIComponent.h"
+#include "SHButtonComponent.h"
+#include "SHToggleButtonComponent.h"
+#include "SHSliderComponent.h"
+#include "SHCanvasComponent.h"
+#include "Events/SHEventManager.hpp"
+#include "Events/SHButtonClickEvent.h"
 
 namespace SHADE
 {
@@ -103,7 +110,7 @@ namespace SHADE
     {
       auto transform = SHComponentManager::GetComponent<SHTransformComponent>(comp.GetEID());
       if (canvasComp != nullptr)
-        comp.localToCanvasMatrix =  canvasComp->GetMatrix()* transform->GetTRS();
+        comp.localToCanvasMatrix = transform->GetTRS() * canvasComp->GetMatrix();
       else
         comp.localToCanvasMatrix = transform->GetTRS();
     }
@@ -139,77 +146,195 @@ namespace SHADE
 
   void SHUISystem::UpdateButtonComponent(SHButtonComponent& comp) noexcept
   {
-    if (!SHComponentManager::HasComponent<SHTransformComponent>(comp.GetEID()) || !SHComponentManager::HasComponent<SHUIComponent>(comp.GetEID()))
+    if (!SHComponentManager::HasComponent<SHUIComponent>(comp.GetEID()))
+    {
+      return;
+    }
+    auto cameraSystem = SHSystemManager::GetSystem<SHCameraSystem>();
+    auto uiComp = SHComponentManager::GetComponent<SHUIComponent>(comp.GetEID());
+    //auto canvasComp = SHComponentManager::GetComponent_s<SHCanvasComponent>(uiComp->canvasID);
+
+    SHVec4 topExtent4 =  SHMatrix::Translate(-comp.size.x * 0.5f, comp.size.y * 0.5f, 0.0f)  * uiComp->GetMatrix()  * SHVec4(0.0f, 0.0f, 0.0f, 1.0f);
+    SHVec4 btmExtent4 =  SHMatrix::Translate(comp.size.x * 0.5f, -comp.size.y * 0.5f, 0.0f)  * uiComp->GetMatrix()  * SHVec4(0.0f,0.0f, 0.0f,1.0f);
+    
+
+    SHVec2 topExtent{ topExtent4.x,topExtent4.y };
+    SHVec2 btmExtent{ btmExtent4.x,btmExtent4.y };
+    
+    
+    SHVec2 mousePos;
+    SHVec2 windowSize;
+#ifdef SHEDITOR
+    windowSize = SHEditorWindowManager::GetEditorWindow<SHEditorViewport>()->beginContentRegionAvailable;
+    mousePos = SHEditorWindowManager::GetEditorWindow<SHEditorViewport>()->viewportMousePos;
+    //mousePos.y = windowSize.y - mousePos.y;
+    SHLOG_INFO("mouse pos: {}, {}", mousePos.x, mousePos.y)
+    mousePos /= windowSize;
+    SHLOG_INFO("mouse pos normalized: {}, {}", mousePos.x, mousePos.y)
+
+    
+
+#else
+
+    int x, y;
+    SHInputManager::GetMouseScreenPosition(&x, &y);
+    mousePos.x = x;
+    mousePos.y = y;
+    auto ws = SHSystemManager::GetSystem<SHGraphicsSystem>()->GetWindow()->GetWindowSize();
+    windowSize = { ws.first,ws.second };
+    mousePos /= windowSize;
+#endif 
+    
+    SHVec2 camSize{ cameraSystem->GetCameraWidthHeight(0)};
+    //SHLOG_INFO("TopExtent: {}, {}", topExtent.x, topExtent.y)
+
+    topExtent = CanvasToScreenPoint(topExtent,true);
+    btmExtent = CanvasToScreenPoint(btmExtent,true);
+    //SHLOG_INFO("TopExtent: {}, {}      Btm Extent: {}, {}", topExtent.x, topExtent.y, btmExtent.x, btmExtent.y)
+
+
+    comp.isClicked = false;
+    if (mousePos.x >= topExtent.x && mousePos.x <= btmExtent.x
+      && mousePos.y >= topExtent.y && mousePos.y <= btmExtent.y)
+    {
+      comp.isHovered = true;
+#ifdef SHEDITOR
+      if (SHSystemManager::GetSystem<SHEditor>()->editorState == SHEditor::State::PLAY)
+      {
+        if (SHInputManager::GetKeyUp(SHInputManager::SH_KEYCODE::LMB))
+        {
+          comp.isClicked = true;
+          SHButtonClickEvent clickEvent;
+          clickEvent.EID = comp.GetEID();
+          SHEventManager::BroadcastEvent(clickEvent, SH_BUTTON_CLICK_EVENT);
+        }
+      }
+#else
+      if (SHInputManager::GetKeyUp(SHInputManager::SH_KEYCODE::LMB))
+      {
+        comp.isClicked = true;
+        SHButtonClickEvent clickEvent;
+        clickEvent.EID = comp.GetEID();
+        SHEventManager::BroadcastEvent(clickEvent, SH_BUTTON_CLICK_EVENT);
+      }
+#endif
+
+      //SHLOG_INFO("HOVERED")
+    }
+    else
+    {
+      comp.isHovered = false;
+      //SHLOG_INFO("NOT HOVERED")
+    }
+    
+    
+    if (SHComponentManager::HasComponent<SHRenderable>(comp.GetEID()))
+    {
+      /*auto renderable = SHComponentManager::GetComponent_s<SHRenderable>(comp.GetEID());
+      auto texture = SHResourceManager::Get<SHTexture>(comp.GetDefaultTexture());
+
+      auto material = renderable->GetModifiableMaterial();
+      material->SetProperty("texture", comp.GetDefaultTexture());*/
+    }
+  }
+
+
+  void SHUISystem::UpdateToggleButtonComponent(SHToggleButtonComponent& comp) noexcept
+  {
+    if (!SHComponentManager::HasComponent<SHUIComponent>(comp.GetEID()))
     {
       return;
     }
     auto cameraSystem = SHSystemManager::GetSystem<SHCameraSystem>();
     auto uiComp = SHComponentManager::GetComponent<SHUIComponent>(comp.GetEID());
 
-    SHVec4 topExtent4 = uiComp->GetMatrix() * SHVec4(-comp.size.x * 0.5f, comp.size.y * 0.5f , 0.0f,1.0f);
-    SHVec4 btmExtent4 = uiComp->GetMatrix() * SHVec4(comp.size.x * 0.5f , -comp.size.y * 0.5f , 0.0f, 1.0f);
+    SHVec4 topExtent4 = SHMatrix::Translate(-comp.size.x * 0.5f, comp.size.y * 0.5f, 0.0f) * uiComp->GetMatrix() * SHVec4(0.0f, 0.0f, 0.0f, 1.0f);
+    SHVec4 btmExtent4 = SHMatrix::Translate(comp.size.x * 0.5f, -comp.size.y * 0.5f, 0.0f) * uiComp->GetMatrix() * SHVec4(0.0f, 0.0f, 0.0f, 1.0f);
 
-    SHVec2 topExtent{ topExtent4.x,-topExtent4.y };
-    SHVec2 btmExtent{ btmExtent4.x,-btmExtent4.y };
 
-    
+    SHVec2 topExtent{ topExtent4.x,topExtent4.y };
+    SHVec2 btmExtent{ btmExtent4.x,btmExtent4.y };
 
-    SHVec2 windowSize;
     SHVec2 mousePos;
+    SHVec2 windowSize;
+
 #ifdef SHEDITOR
-
-    windowSize = SHEditorWindowManager::GetEditorWindow<SHEditorViewport>()->windowSize;
+    windowSize = SHEditorWindowManager::GetEditorWindow<SHEditorViewport>()->beginContentRegionAvailable;
     mousePos = SHEditorWindowManager::GetEditorWindow<SHEditorViewport>()->viewportMousePos;
+    //mousePos.y = windowSize.y - mousePos.y;
+    SHLOG_INFO("mouse pos: {}, {}", mousePos.x, mousePos.y)
+      mousePos /= windowSize;
+    SHLOG_INFO("mouse pos normalized: {}, {}", mousePos.x, mousePos.y)
 
 
 
-#endif 
-    
-    
-
-    SHVec2 camSize{ cameraSystem->GetCameraWidthHeight(0).x ,  cameraSystem->GetCameraWidthHeight(0).y };
-
-    topExtent += camSize * 0.5f;
-    btmExtent += camSize * 0.5f;
-    
-    //Convert everything to using ratios
-    topExtent /= camSize;
-    btmExtent /= camSize;
+#else
 
+    int x, y;
+    SHInputManager::GetMouseScreenPosition(&x, &y);
+    mousePos.x = x;
+    mousePos.y = y;
+    auto ws = SHSystemManager::GetSystem<SHGraphicsSystem>()->GetWindow()->GetWindowSize();
+    windowSize = { ws.first,ws.second };
     mousePos /= windowSize;
+#endif 
+
+    SHVec2 camSize{ cameraSystem->GetCameraWidthHeight(0) };
+
+    
+
+    topExtent = CanvasToScreenPoint(topExtent,true);
+    btmExtent = CanvasToScreenPoint(btmExtent, true);
+
+
 
-    //SHLOG_INFO("mousePos: {} , {}", mousePos.x, mousePos.y);
     comp.isClicked = false;
     if (mousePos.x >= topExtent.x && mousePos.x <= btmExtent.x
       && mousePos.y >= topExtent.y && mousePos.y <= btmExtent.y)
     {
       comp.isHovered = true;
+#ifdef SHEDITOR
+      if (SHSystemManager::GetSystem<SHEditor>()->editorState == SHEditor::State::PLAY)
+      {
+        if (SHInputManager::GetKeyUp(SHInputManager::SH_KEYCODE::LMB))
+        {
+          comp.isClicked = true;
+          comp.value = !comp.value;
+          SHButtonClickEvent clickEvent;
+          clickEvent.EID = comp.GetEID();
+          clickEvent.value = comp.value;
+          SHEventManager::BroadcastEvent(clickEvent, SH_BUTTON_CLICK_EVENT);
+        }
+      }
+#else
       if (SHInputManager::GetKeyUp(SHInputManager::SH_KEYCODE::LMB))
       {
         comp.isClicked = true;
+        comp.value = !comp.value;
+        SHButtonClickEvent clickEvent;
+        clickEvent.EID = comp.GetEID();
+        clickEvent.value = comp.value;
+        SHEventManager::BroadcastEvent(clickEvent, SH_BUTTON_CLICK_EVENT);
       }
-        //SHLOG_INFO("BUTTON HOVERED");
-        
-      
+#endif
     }
     else
     {
       comp.isHovered = false;
-      
-      //SHLOG_INFO("BUTTON NOT HOVERED")
     }
-    
-    
+
+
     if (SHComponentManager::HasComponent<SHRenderable>(comp.GetEID()))
     {
-      //auto renderable = SHComponentManager::GetComponent_s<SHRenderable>(comp.GetEID());
-      //auto texture = SHResourceManager::Get<SHTexture>(comp.GetDefaultTexture());
+      /*auto renderable = SHComponentManager::GetComponent_s<SHRenderable>(comp.GetEID());
+      auto texture = SHResourceManager::Get<SHTexture>(comp.GetDefaultTexture());
 
-      //auto material = renderable->GetModifiableMaterial();
-      //material->SetProperty("texture", comp.GetDefaultTexture());
+      auto material = renderable->GetModifiableMaterial();
+      material->SetProperty("texture", comp.GetDefaultTexture());*/
     }
   }
 
+
   void SHUISystem::UpdateButtonsRoutine::Execute(double dt) noexcept
   {
     SHUISystem* system = (SHUISystem*)GetSystem();
@@ -219,6 +344,34 @@ namespace SHADE
       if (SHSceneManager::CheckNodeAndComponentsActive<SHButtonComponent>(comp.GetEID()))
         system->UpdateButtonComponent(comp);
     }
+
+    auto& toggleButtonDense = SHComponentManager::GetDense<SHToggleButtonComponent>();
+    for (auto& comp : toggleButtonDense)
+    {
+      if (SHSceneManager::CheckNodeAndComponentsActive<SHToggleButtonComponent>(comp.GetEID()))
+        system->UpdateToggleButtonComponent(comp);
+    }
   }
 
+  SHVec2 SHUISystem::CanvasToScreenPoint(SHVec2& const canvasPoint, bool normalized) noexcept
+  {
+    SHVec2 result{canvasPoint};
+
+    auto cameraSystem = SHSystemManager::GetSystem<SHCameraSystem>();
+
+    SHVec2 camSize{ cameraSystem->GetCameraWidthHeight(0) };
+    //camSize.y *= -1.0f;
+    
+    result.y *= -1.0f;
+    result += camSize * 0.5f;
+
+    if (normalized)
+      return result / camSize;
+    else
+      return result;
+  }
+
+
+
+
 }//end namespace

SHADE_Engine/src/UI/SHUISystem.h

@@ -3,14 +3,20 @@
 #include "SH_API.h"
 #include "ECS_Base/System/SHSystem.h"
 #include "ECS_Base/System/SHSystemRoutine.h"
-#include "SHUIComponent.h"
-#include "SHButtonComponent.h"
-#include "SHCanvasComponent.h"
+
 #include "Scene/SHSceneGraph.h"
 #include "Scene/SHSceneManager.h"
+#include "Math/Vector/SHVec2.h"
 
 namespace SHADE
 {
+
+  class SHButtonComponent;
+  class SHUIComponent;
+  class SHToggleButtonComponent;
+  class SHSliderComponent;
+  class SHCanvasComponent;
+
   class SH_API SHUISystem final: public SHSystem
   {
   public:
@@ -64,7 +70,11 @@ namespace SHADE
   private:
     void UpdateUIComponent(SHUIComponent& comp) noexcept;
     void UpdateButtonComponent(SHButtonComponent& comp) noexcept;
+    void UpdateToggleButtonComponent(SHToggleButtonComponent& comp) noexcept;
     void UpdateCanvasComponent(SHCanvasComponent& comp) noexcept;
+    
+    SHVec2 CanvasToScreenPoint(SHVec2& const canvasPoint, bool normalized) noexcept;
+    
 
 
   };