Make the ability window more easily overridable in case a project wants to add more ability debug

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Abilities.cpp

@@ -45,9 +45,9 @@ void FCogAbilityWindow_Abilities::ResetConfig()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void FCogAbilityWindow_Abilities::RenderTick(float DetlaTime)
+void FCogAbilityWindow_Abilities::RenderTick(float DeltaTime)
 {
-    Super::RenderTick(DetlaTime);
+    Super::RenderTick(DeltaTime);
 
     RenderOpenAbilities();
 }
@@ -116,13 +116,13 @@ void FCogAbilityWindow_Abilities::RenderContent()
         return;
     }
 
-    RenderAbiltiesMenu(Selection);
+    RenderAbilitiesMenu(Selection);
 
     RenderAbilitiesTable(*AbilitySystemComponent);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void FCogAbilityWindow_Abilities::RenderAbiltiesMenu(AActor* Selection)
+void FCogAbilityWindow_Abilities::RenderAbilitiesMenu(AActor* Selection)
 {
     if (ImGui::BeginMenuBar())
     {
@@ -155,18 +155,11 @@ void FCogAbilityWindow_Abilities::RenderAbiltiesMenu(AActor* Selection)
 
             ImGui::Separator();
 
-            ImGui::Checkbox("Sort by Name", &Config->SortByName);
+            RenderAbilitiesMenuFilters();
-            ImGui::Checkbox("Show Active", &Config->ShowActive);
-            ImGui::Checkbox("Show Inactive", &Config->ShowInactive);
-            ImGui::Checkbox("Show Blocked", &Config->ShowBlocked);
 
             ImGui::Separator();
 
-            ImGui::ColorEdit4("Active Color", (float*)&Config->ActiveAbilityColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+            RenderAbilitiesMenuColorSettings();
-            ImGui::ColorEdit4("Inactive Color", (float*)&Config->InactiveAbilityColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
-            ImGui::ColorEdit4("Blocked Color", (float*)&Config->BlockedAbilityColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
-            ImGui::ColorEdit4("Default Tag Color", (float*)&Config->DefaultTagsColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
-            ImGui::ColorEdit4("Blocked Tag Color", (float*)&Config->BlockedTagsColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
 
             ImGui::Separator();
 
@@ -184,6 +177,83 @@ void FCogAbilityWindow_Abilities::RenderAbiltiesMenu(AActor* Selection)
     }
 }
 
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilitiesMenuFilters()
+{
+    ImGui::Checkbox("Sort by Name", &Config->SortByName);
+    ImGui::Checkbox("Show Active", &Config->ShowActive);
+    ImGui::Checkbox("Show Inactive", &Config->ShowInactive);
+    ImGui::Checkbox("Show Pressed", &Config->ShowPressed);
+    ImGui::Checkbox("Show Blocked", &Config->ShowBlocked);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilitiesMenuColorSettings()
+{
+    ImGui::ColorEdit4("Active Color", (float*)&Config->ActiveAbilityColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+    ImGui::ColorEdit4("Inactive Color", (float*)&Config->InactiveAbilityColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+    ImGui::ColorEdit4("Blocked Color", (float*)&Config->BlockedAbilityColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+    ImGui::ColorEdit4("Default Tag Color", (float*)&Config->DefaultTagsColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+    ImGui::ColorEdit4("Blocked Tag Color", (float*)&Config->BlockedTagsColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+    ImGui::ColorEdit4("Input Pressed Color", (float*)&Config->InputPressedColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilityActivation(FGameplayAbilitySpec& Spec)
+{
+	FCogWindowWidgets::PushStyleCompact();
+	bool IsActive = Spec.IsActive();
+	if (ImGui::Checkbox("##Activation", &IsActive))
+	{
+		AbilityHandleToActivate = Spec.Handle;
+	}
+	FCogWindowWidgets::PopStyleCompact();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilitiesTableAbilityName(UAbilitySystemComponent& AbilitySystemComponent, int& SelectedIndex, int Index, FGameplayAbilitySpec& Spec, UGameplayAbility* Ability)
+{
+    const ImVec4 Color = GetAbilityColor(AbilitySystemComponent, Spec);
+    ImGui::PushStyleColor(ImGuiCol_Text, Color);
+
+	if (ImGui::Selectable(TCHAR_TO_ANSI(*GetAbilityName(Ability)), SelectedIndex == Index, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowOverlap | ImGuiSelectableFlags_AllowDoubleClick))
+	{
+		SelectedIndex = Index;
+                
+		if (ImGui::IsMouseDoubleClicked(0))
+		{
+			OpenAbility(Spec.Handle);
+		}
+	}
+
+    ImGui::PopStyleColor(1);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilitiesTableAbilityBlocking(UAbilitySystemComponent& AbilitySystemComponent, UGameplayAbility* Ability)
+{
+	if (Ability->DoesAbilitySatisfyTagRequirements(AbilitySystemComponent) == false)
+	{
+		FGameplayTagContainer OwnedGameplayTags;
+		AbilitySystemComponent.GetOwnedGameplayTags(OwnedGameplayTags);
+
+		if (const FGameplayTagContainer* ActivationBlockedTags = &PRIVATE_ACCESS_PTR(Ability, GameplayAbility_ActivationBlockedTags))
+		{
+			FGameplayTagContainer AllBlockingTags;
+			AbilitySystemComponent.GetBlockedAbilityTags(AllBlockingTags);
+			AllBlockingTags.AppendTags(OwnedGameplayTags);
+
+			FCogAbilityHelper::RenderTagContainer(*ActivationBlockedTags, AllBlockingTags, false, true, true, ImVec4(0, 0, 0, 0), FCogImguiHelper::ToImVec4(Config->BlockedTagsColor));
+		}
+
+		ImGui::SameLine();
+		if (const FGameplayTagContainer* ActivationRequiredTags = &PRIVATE_ACCESS_PTR(Ability, GameplayAbility_ActivationRequiredTags))
+		{
+			FCogAbilityHelper::RenderTagContainer(*ActivationRequiredTags, OwnedGameplayTags, true, true, true, ImVec4(0, 0, 0, 0), FCogImguiHelper::ToImVec4(Config->BlockedTagsColor));
+		}
+	}
+}
+
 //--------------------------------------------------------------------------------------------------------------------------
 void FCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent& AbilitySystemComponent)
 {
@@ -191,7 +261,7 @@ void FCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent&
 
     TArray<FGameplayAbilitySpec> FitleredAbilities;
 
-    for (FGameplayAbilitySpec& Spec: Abilities)
+    for (FGameplayAbilitySpec& Spec : Abilities)
     {
         const UGameplayAbility* Ability = Spec.GetPrimaryInstance();
         if (Ability == nullptr)
@@ -199,24 +269,10 @@ void FCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent&
             Ability = Spec.Ability;
         }
 
-        const bool IsJustBlocked = Ability->DoesAbilitySatisfyTagRequirements(AbilitySystemComponent) == false;
+        if (ShouldShowAbility(AbilitySystemComponent, Spec, Ability) == false)
-        const bool IsJustActive = Spec.IsActive() && IsJustBlocked == false;
-        const bool IsJustInactive = Spec.IsActive() == false && IsJustBlocked == false;
-
-        if (Config->ShowBlocked == false && IsJustBlocked)
         {
-            continue;
+			continue;
-        }
+		}
-
-        if (Config->ShowActive == false && IsJustActive)
-        {
-            continue;
-        }
-
-        if (Config->ShowInactive == false && IsJustInactive)
-        {
-            continue;
-        }
 
         const auto AbilityName = StringCast<ANSICHAR>(*GetAbilityName(Ability));
         if (Filter.PassFilter(AbilityName.Get()) == false)
@@ -235,24 +291,8 @@ void FCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent&
         });
     }
     
-    if (ImGui::BeginTable("Abilities", 6, ImGuiTableFlags_SizingFixedFit
+    if (RenderAbilitiesTableHeader(AbilitySystemComponent))
-                                        | ImGuiTableFlags_Resizable
-                                        | ImGuiTableFlags_NoBordersInBodyUntilResize
-                                        | ImGuiTableFlags_ScrollY
-                                        | ImGuiTableFlags_RowBg
-                                        | ImGuiTableFlags_BordersV
-                                        | ImGuiTableFlags_Reorderable
-                                        | ImGuiTableFlags_Hideable))
     {
-        ImGui::TableSetupColumn("##Activation", ImGuiTableColumnFlags_WidthFixed);
-        ImGui::TableSetupScrollFreeze(0, 1);
-        ImGui::TableSetupColumn("Ability");
-        ImGui::TableSetupColumn("Level");
-        ImGui::TableSetupColumn("Input");
-        ImGui::TableSetupColumn("Cooldown");
-        ImGui::TableSetupColumn("Blocking");
-        ImGui::TableHeadersRow();
-
         static int SelectedIndex = -1;
         int Index = 0;
 
@@ -268,98 +308,7 @@ void FCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent&
 
             ImGui::PushID(Index);
 
-            const ImVec4 Color = GetAbilityColor(AbilitySystemComponent, Spec);
+            RenderAbilitiesTableRow(AbilitySystemComponent, SelectedIndex, Index, Spec, Ability);
-            ImGui::PushStyleColor(ImGuiCol_Text, Color);
-
-            //------------------------
-            // Activation
-            //------------------------
-            ImGui::TableNextColumn();
-            FCogWindowWidgets::PushStyleCompact();
-            bool IsActive = Spec.IsActive();
-            if (ImGui::Checkbox("##Activation", &IsActive))
-            {
-                AbilityHandleToActivate = Spec.Handle;
-            }
-            FCogWindowWidgets::PopStyleCompact();
-
-            //------------------------
-            // Name
-            //------------------------
-            ImGui::TableNextColumn();
-
-            if (ImGui::Selectable(TCHAR_TO_ANSI(*GetAbilityName(Ability)), SelectedIndex == Index, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowOverlap | ImGuiSelectableFlags_AllowDoubleClick))
-            {
-                SelectedIndex = Index;
-                
-                if (ImGui::IsMouseDoubleClicked(0))
-                {
-                    OpenAbility(Spec.Handle);
-                }
-            }
-
-            ImGui::PopStyleColor(1);
-
-            //------------------------
-            // Popup
-            //------------------------
-            if (ImGui::IsItemHovered())
-            {
-                FCogWindowWidgets::BeginTableTooltip();
-                RenderAbilityInfo(AbilitySystemComponent, Spec);
-                FCogWindowWidgets::EndTableTooltip();
-            }
-
-            //------------------------
-            // ContextMenu
-            //------------------------
-            RenderAbilityContextMenu(AbilitySystemComponent, Spec, Index);
-
-            //------------------------
-            // Level
-            //------------------------
-            ImGui::TableNextColumn();
-            ImGui::Text("%d", Spec.Level);
-
-            //------------------------
-            // InputPressed
-            //------------------------
-            ImGui::TableNextColumn();
-            if (Spec.InputPressed > 0)
-            {
-                ImGui::Text("%d", Spec.InputPressed);
-            }
-
-            //------------------------
-            // Cooldown
-            //------------------------
-            ImGui::TableNextColumn();
-            RenderAbilityCooldown(AbilitySystemComponent, *Ability);
-
-            //------------------------
-            // Blocking
-            //------------------------
-            ImGui::TableNextColumn();
-            if (Ability->DoesAbilitySatisfyTagRequirements(AbilitySystemComponent) == false)
-            {
-                FGameplayTagContainer OwnedGameplayTags;
-                AbilitySystemComponent.GetOwnedGameplayTags(OwnedGameplayTags);
-
-                if (const FGameplayTagContainer* ActivationBlockedTags = &PRIVATE_ACCESS_PTR(Ability, GameplayAbility_ActivationBlockedTags))
-                {
-                    FGameplayTagContainer AllBlockingTags;
-                    AbilitySystemComponent.GetBlockedAbilityTags(AllBlockingTags);
-                    AllBlockingTags.AppendTags(OwnedGameplayTags);
-
-                    FCogAbilityHelper::RenderTagContainer(*ActivationBlockedTags, AllBlockingTags, false, true, true, ImVec4(0, 0, 0, 0), FCogImguiHelper::ToImVec4(Config->BlockedTagsColor));
-                }
-
-                ImGui::SameLine();
-                if (const FGameplayTagContainer* ActivationRequiredTags = &PRIVATE_ACCESS_PTR(Ability, GameplayAbility_ActivationRequiredTags))
-                {
-                    FCogAbilityHelper::RenderTagContainer(*ActivationRequiredTags, OwnedGameplayTags, true, true, true, ImVec4(0, 0, 0, 0), FCogImguiHelper::ToImVec4(Config->BlockedTagsColor));
-                }
-            }
 
             ImGui::PopID();
             Index++;
@@ -369,6 +318,116 @@ void FCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent&
     }
 }
 
+//--------------------------------------------------------------------------------------------------------------------------
+bool FCogAbilityWindow_Abilities::ShouldShowAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, const UGameplayAbility* Ability)
+{
+    const bool IsBlocked = Ability->DoesAbilitySatisfyTagRequirements(AbilitySystemComponent) == false;
+    if (Config->ShowBlocked && IsBlocked)
+    {
+        return true;
+    }
+
+    if (Config->ShowActive && Spec.IsActive())
+    {
+        return true;
+    }
+
+    if (Config->ShowInactive && Spec.IsActive() == false)
+    {
+        return true;
+    }
+
+    if (Config->ShowPressed && Spec.InputPressed)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool FCogAbilityWindow_Abilities::RenderAbilitiesTableHeader(UAbilitySystemComponent& AbilitySystemComponent)
+{
+    if (ImGui::BeginTable("Abilities", 6, ImGuiTableFlags_SizingFixedFit
+        | ImGuiTableFlags_Resizable
+        | ImGuiTableFlags_NoBordersInBodyUntilResize
+        | ImGuiTableFlags_ScrollY
+        | ImGuiTableFlags_RowBg
+        | ImGuiTableFlags_BordersV
+        | ImGuiTableFlags_Reorderable
+        | ImGuiTableFlags_Hideable))
+    {
+        ImGui::TableSetupColumn("##Activation", ImGuiTableColumnFlags_WidthFixed);
+        ImGui::TableSetupScrollFreeze(0, 1);
+        ImGui::TableSetupColumn("Ability");
+        ImGui::TableSetupColumn("Level");
+        ImGui::TableSetupColumn("Input");
+        ImGui::TableSetupColumn("Cooldown");
+        ImGui::TableSetupColumn("Blocking");
+        ImGui::TableHeadersRow();
+
+        return true;
+    }
+
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilitiesTableRow(UAbilitySystemComponent& AbilitySystemComponent, int& SelectedIndex, int Index, FGameplayAbilitySpec& Spec, UGameplayAbility* Ability)
+{
+    //------------------------
+    // Activation
+    //------------------------
+    ImGui::TableNextColumn();
+    RenderAbilityActivation(Spec);
+
+    //------------------------
+    // Name
+    //------------------------
+    ImGui::TableNextColumn();
+    RenderAbilitiesTableAbilityName(AbilitySystemComponent, SelectedIndex, Index, Spec, Ability);
+
+    //------------------------
+    // Popup
+    //------------------------
+    if (ImGui::IsItemHovered())
+    {
+        FCogWindowWidgets::BeginTableTooltip();
+        RenderAbilityInfo(AbilitySystemComponent, Spec);
+        FCogWindowWidgets::EndTableTooltip();
+    }
+
+    //------------------------
+    // ContextMenu
+    //------------------------
+    RenderAbilityContextMenu(AbilitySystemComponent, Spec, Index);
+
+    //------------------------
+    // Level
+    //------------------------
+    ImGui::TableNextColumn();
+    RenderAbilityLevel(Spec);
+
+    //------------------------
+    // InputPressed
+    //------------------------
+    ImGui::TableNextColumn();
+    RenderAbilityInputPressed(Spec);
+
+    //------------------------
+    // Cooldown
+    //------------------------
+    ImGui::TableNextColumn();
+    RenderAbilityCooldown(AbilitySystemComponent, *Ability);
+
+    //------------------------
+    // Blocking
+    //------------------------
+    ImGui::TableNextColumn();
+    RenderAbilitiesTableAbilityBlocking(AbilitySystemComponent, Ability);
+}
+
+
 //--------------------------------------------------------------------------------------------------------------------------
 void FCogAbilityWindow_Abilities::RenderAbilityCooldown(const UAbilitySystemComponent& AbilitySystemComponent, UGameplayAbility& Ability)
 {
@@ -377,8 +436,7 @@ void FCogAbilityWindow_Abilities::RenderAbilityCooldown(const UAbilitySystemComp
         return;
     }
 
-    FGameplayAbilitySpec* Spec = Ability.GetCurrentAbilitySpec();
+    const FGameplayAbilitySpec* Spec = Ability.GetCurrentAbilitySpec();
-
     if (Spec == nullptr)
     {
         return;
@@ -396,6 +454,21 @@ void FCogAbilityWindow_Abilities::RenderAbilityCooldown(const UAbilitySystemComp
     }
 }
 
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilityLevel(FGameplayAbilitySpec& Spec)
+{
+    ImGui::Text("%d", Spec.Level);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilityInputPressed(FGameplayAbilitySpec& Spec)
+{
+    if (Spec.InputPressed)
+    {
+        FCogWindowWidgets::SmallButton("Pressed", FCogImguiHelper::ToImVec4(Config->ActiveAbilityColor));
+    }
+}
+
 //--------------------------------------------------------------------------------------------------------------------------
 void FCogAbilityWindow_Abilities::RenderAbilityContextMenu(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, int Index)
 {
@@ -464,7 +537,7 @@ void FCogAbilityWindow_Abilities::RenderAbilityInfo(const UAbilitySystemComponen
 
     if (ImGui::BeginTable("Ability", 2, ImGuiTableFlags_Borders))
     {
-        const ImVec4 TextColor(1.0f, 1.0f, 1.0f, 0.5f);
+	    constexpr ImVec4 TextColor(1.0f, 1.0f, 1.0f, 0.5f);
 
         ImGui::TableSetupColumn("Property");
         ImGui::TableSetupColumn("Value");
@@ -531,7 +604,7 @@ void FCogAbilityWindow_Abilities::RenderAbilityInfo(const UAbilitySystemComponen
         ImGui::TableNextColumn();
         ImGui::TextColored(TextColor, "Level");
         ImGui::TableNextColumn();
-        ImGui::Text("%d", Spec.Level);
+        RenderAbilityLevel(Spec);
 
         //------------------------
         // InputID
@@ -549,7 +622,7 @@ void FCogAbilityWindow_Abilities::RenderAbilityInfo(const UAbilitySystemComponen
         ImGui::TableNextColumn();
         ImGui::TextColored(TextColor, "Input Pressed");
         ImGui::TableNextColumn();
-        ImGui::Text("%d", Spec.InputPressed);
+        RenderAbilityInputPressed(Spec);
 
         //------------------------
         // AbilityTags
@@ -591,10 +664,21 @@ void FCogAbilityWindow_Abilities::RenderAbilityInfo(const UAbilitySystemComponen
             FCogAbilityHelper::RenderTagContainer(*ActivationBlockedTags, AllBlockingTags, false, false, false, FCogImguiHelper::ToImVec4(Config->DefaultTagsColor), FCogImguiHelper::ToImVec4(Config->BlockedTagsColor));
         }
 
+        //------------------------
+		// Additional info
+		//------------------------
+        RenderAbilityAdditionalInfo(AbilitySystemComponent, Spec, *Ability, TextColor);
+
         ImGui::EndTable();
     }
 }
 
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderAbilityAdditionalInfo(const UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, UGameplayAbility& Ability, const ImVec4& TextColor)
+{
+
+}
+
 //--------------------------------------------------------------------------------------------------------------------------
 void FCogAbilityWindow_Abilities::GameTick(float DeltaTime)
 {

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Abilities.h

@@ -4,6 +4,7 @@
 #include "CogWindow.h"
 #include "CogWindowConfig.h"
 #include "GameplayAbilitySpecHandle.h"
+#include "GameplayTagContainer.h"
 #include "CogAbilityWindow_Abilities.generated.h"
 
 class UAbilitySystemComponent;
@@ -26,18 +27,37 @@ protected:
     
     virtual void RenderHelp() override;
 
-    virtual void RenderTick(float DetlaTime) override;
+    virtual void RenderTick(float DeltaTime) override;
 
     virtual void RenderContent() override;
 
     virtual void GameTick(float DeltaTime) override;
 
-    virtual void RenderAbiltiesMenu(AActor* Selection);
+    virtual void RenderAbilitiesMenu(AActor* Selection);
+
+    virtual void RenderAbilitiesMenuFilters();
+
+    virtual void RenderAbilitiesMenuColorSettings();
 
     virtual FString GetAbilityName(const UGameplayAbility* Ability);
-
+    
     virtual void RenderAbilitiesTable(UAbilitySystemComponent& AbilitySystemComponent);
 
+    virtual bool RenderAbilitiesTableHeader(UAbilitySystemComponent& AbilitySystemComponent);
+
+    virtual void RenderAbilitiesTableRow(UAbilitySystemComponent& AbilitySystemComponent, int& SelectedIndex, int Index,
+        FGameplayAbilitySpec& Spec, UGameplayAbility* Ability);
+
+    virtual void RenderAbilityActivation(FGameplayAbilitySpec& Spec);
+
+    virtual void RenderAbilitiesTableAbilityName(UAbilitySystemComponent& AbilitySystemComponent, int& SelectedIndex, int Index, FGameplayAbilitySpec& Spec, UGameplayAbility* Ability);
+
+    virtual void RenderAbilitiesTableAbilityBlocking(UAbilitySystemComponent& AbilitySystemComponent, UGameplayAbility* Ability);
+
+    virtual void RenderAbilityLevel(FGameplayAbilitySpec& Spec);
+
+    virtual void RenderAbilityInputPressed(FGameplayAbilitySpec& Spec);
+
     virtual void RenderAbilityCooldown(const UAbilitySystemComponent& AbilitySystemComponent, UGameplayAbility& Ability);
 
     virtual void RenderAbilityContextMenu(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, int Index);
@@ -46,6 +66,8 @@ protected:
 
     virtual void RenderAbilityInfo(const UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec);
 
+    virtual void RenderAbilityAdditionalInfo(const UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, UGameplayAbility& Ability, const ImVec4& TextColor);
+
     virtual void ProcessAbilityActivation(const FGameplayAbilitySpecHandle& Handle);
 
     virtual void ActivateAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec);
@@ -58,6 +80,9 @@ protected:
 
     virtual ImVec4 GetAbilityColor(const UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec);
 
+    virtual bool ShouldShowAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec,
+        const UGameplayAbility* Ability);
+
     FGameplayAbilitySpecHandle AbilityHandleToActivate;
 
     FGameplayAbilitySpecHandle AbilityHandleToRemove;
@@ -88,6 +113,9 @@ public:
     UPROPERTY(Config)
     bool ShowInactive = true;
 
+    UPROPERTY(Config)
+    bool ShowPressed = true;
+
     UPROPERTY(Config)
     bool ShowBlocked = true;
 
@@ -106,6 +134,9 @@ public:
     UPROPERTY(Config)
     FVector4f BlockedTagsColor = FVector4f(1.0f, 0.5f, 0.5f, 1.0f);
 
+    UPROPERTY(Config)
+    FVector4f InputPressedColor = FVector4f(0.0f, 1.0f, 0.5f, 1.0f);
+
     virtual void Reset() override
     {
         Super::Reset();
@@ -113,11 +144,13 @@ public:
         SortByName = false;
         ShowActive = true;
         ShowInactive = true;
+        ShowPressed = true;
         ShowBlocked = true;
         ActiveAbilityColor = FVector4f(0.0f, 1.0f, 0.5f, 1.0f);
         InactiveAbilityColor = FVector4f(1.0f, 1.0f, 1.0f, 1.0f);
         BlockedAbilityColor = FVector4f(1.0f, 0.5f, 0.5f, 1.0f);
         DefaultTagsColor = FVector4f(0.6f, 0.6f, 0.6f, 1.0f);
         BlockedTagsColor = FVector4f(1.0f, 0.5f, 0.5f, 1.0f);
+        InputPressedColor = FVector4f(0.0f, 1.0f, 0.5f, 1.0f);
     }
 };