AHUDBase Class Reference

#include <HUDBase.h>

Inheritance diagram for AHUDBase:

Public Member Functions
	AHUDBase ()
virtual bool	RegisterLayer (const FGameplayTag &LayerName, UUserWidget *LayerWidget) override
virtual UUserWidget *	PushContentToLayer (const FGameplayTag &LayerName, const TSoftClassPtr< UUserWidget > &WidgetClass) override
virtual UUserWidget *	GetContentFromLayer (const FGameplayTag &LayerName, const TSoftClassPtr< UUserWidget > &WidgetClass) override
virtual bool	PopContentFromLayer (const FGameplayTag &LayerName) override
virtual bool	ClearLayer (const FGameplayTag &LayerName) override
virtual bool	ToggleWidget (const FGameplayTag &LayerName, UUserWidget *Widget) override
virtual UUserWidget *	AddWidgetToLayer (const FGameplayTag &LayerName, const TSoftClassPtr< UUserWidget > &WidgetClass) override
virtual UUserWidget *	AddWidgetToLayerWithSlot (const FGameplayTag &LayerName, const FGameplayTag &SlotTag, const TSoftClassPtr< UUserWidget > &WidgetClass) override
virtual void	HUDSelectionVertical (const bool bMoveUp=true) override
virtual void	HUDSelectionHorizontal (const bool bMoveRight=true) override
virtual void	HUDConfirm () override
virtual void	HUDCancel () override
virtual bool	RegisterNotificationManager (const FGameplayTag Type, UUserWidget *ManagerWidget) override
virtual bool	AddNotificationToQueue (const FGameplayTag Type, const FNotificationData &Data) override
virtual void	OpenRadialMenu (const FRadialMenuData &Data) override
virtual int32	CloseRadialMenu () override
virtual bool	GetIsRadialMenuOpen () const override
virtual void	ToggleGameLog () override

Public Attributes
UUserWidget *	RadialMenuWidget = nullptr

Protected Member Functions
virtual void	BeginPlay () override
void	OnOpenRadialMenu (const FRadialMenuData &Data)
void	OnCloseRadialMenu ()

Protected Attributes
class UPrimaryLayoutWidget *	PrimaryLayoutWidget = nullptr
TMap< FGameplayTag, TSoftClassPtr< UUserWidget > >	InitialScreens
TMap< FGameplayTag, TSoftClassPtr< UUserWidget > >	InitialNotificationManagers
bool	bDebuggingMode = false

Private Member Functions
virtual bool	CreateLayoutWidget ()
void	PushInitialScreens ()
void	PushInitialNotificationManagers ()
bool	CreateRadialMenu ()

Private Attributes
TMap< FGameplayTag, IWidgetLayout * >	LayersMap
TMap< FGameplayTag, INotificationManagerInterface * >	NotificationManagersMap
TSubclassOf< UUserWidget >	RadialMenuClass = nullptr
TSubclassOf< UUserWidget >	PrimaryLayoutClass = nullptr
FTimerHandle	NotificationTimerHandle
FTimerHandle	InitialNotificationTimerHandle

Constructor & Destructor Documentation

AHUDBase()

AHUDBase::AHUDBase

(

)

{
    if(PrimaryLayoutClass == nullptr)
    {
        PrimaryLayoutClass = UBaseHelpersBPLib::GetDefaultWidgetBPClass("/BaseHelpers/Widgets/WBP_PrimaryLayout");
    }
    RadialMenuClass = UBaseHelpersBPLib::GetDefaultWidgetBPClass("/BaseHelpers/Widgets/WBP_WheelMenu");
}

Member Function Documentation

AddNotificationToQueue()

bool AHUDBase::AddNotificationToQueue ( const FGameplayTag Type, const FNotificationData & Data )

overridevirtual

Implements IHUDInterface.

{
    if(bDebuggingMode){UE_LOG(LogHUDBase, Warning, TEXT("HUD: Add Notification: %s to %s"), *Data.Title, *Type.GetTagName().ToString());}
    INotificationManagerInterface** NotificationWidgetPtr = NotificationManagersMap.Find(Type);
    if(NotificationWidgetPtr == nullptr){UE_LOG(LogHUDBase, Error, TEXT("NotificationWidgetPtr Null: Add Notification: %s to %s"), *Data.Title, *Type.GetTagName().ToString());return false;}
    INotificationManagerInterface* NotificationWidget = *NotificationWidgetPtr;
    if(NotificationWidget == nullptr){UE_LOG(LogHUDBase, Error, TEXT("NotificationWidget Null: Add Notification: %s to %s"), *Data.Title, *Type.GetTagName().ToString());return false;;}
    NotificationWidget->AddNotificationToQueue(Data);
    return true;
}

AddWidgetToLayer()

UUserWidget * AHUDBase::AddWidgetToLayer ( const FGameplayTag & LayerName, const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("AddWidgetToLayer: %s"), *LayerName.GetTagName().ToString());
    }
    IWidgetLayout** LayerWidgetPtr = LayersMap.Find(LayerName);
    if(LayerWidgetPtr == nullptr){UE_LOG(LogHUDBase, Error, TEXT("LayersMap doesn't contain: %s"), *LayerName.GetTagName().ToString());return nullptr;}
    IWidgetLayout* LayerWidget = *LayerWidgetPtr;
    if(LayerWidget == nullptr){return nullptr;}
    return LayerWidget->AddWidgetToLayer(WidgetClass);
}

AddWidgetToLayerWithSlot()

UUserWidget * AHUDBase::AddWidgetToLayerWithSlot ( const FGameplayTag & LayerName, const FGameplayTag & SlotTag, const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("AddWidgetToLayerWithSlot: %s"), *LayerName.GetTagName().ToString());
    }
    IWidgetLayout** LayerWidgetPtr = LayersMap.Find(LayerName);
    if(LayerWidgetPtr == nullptr){UE_LOG(LogHUDBase, Error, TEXT("LayersMap doesn't contain: %s"), *LayerName.GetTagName().ToString());return nullptr;}
    IWidgetLayout* LayerWidget = *LayerWidgetPtr;
    if(LayerWidget == nullptr){return nullptr;}
    return LayerWidget->AddWidgetToLayerWithSlot(SlotTag, WidgetClass);
}

BeginPlay()

void AHUDBase::BeginPlay ( )

overrideprotectedvirtual

{
    Super::BeginPlay();
    const bool bSuccess = CreateLayoutWidget();
    if(bSuccess == false){UE_LOG(LogHUDBase, Error, TEXT(" AHUDBase::BeginPlay FAILED"));return;}
    PushInitialScreens();
    PushInitialNotificationManagers();
}

ClearLayer()

bool AHUDBase::ClearLayer ( const FGameplayTag & LayerName )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("PushContentToLayer: %s"), *LayerName.GetTagName().ToString());
    }
    IWidgetLayout** LayerWidgetPtr = LayersMap.Find(LayerName);
    if(LayerWidgetPtr == nullptr){return false;}
    IWidgetLayout* LayerWidget = *LayerWidgetPtr;
    if(LayerWidget == nullptr){return false;}
    LayerWidget->ClearStack();
    return true;
}

CloseRadialMenu()

int32 AHUDBase::CloseRadialMenu ( )

overridevirtual

Returns

the selected Menu Item

Implements IHUDInterface.

{
    int32 Index = -1;
    if(RadialMenuWidget == nullptr){return Index;}
    IRadialMenu* RadialMenu = Cast<IRadialMenu>(RadialMenuWidget);
    if(RadialMenu != nullptr)
    {
        //- Set Mouse back to center so it's not already highlighted next time  //
        RadialMenu->CenterMousePosition();
    }
    RadialMenu->GetCurrentIndex(Index);
    RadialMenuWidget->SetVisibility(ESlateVisibility::Collapsed);
    const FInputModeGameOnly GameOnly;
    GetOwningPlayerController()->SetInputMode(GameOnly);
    OnCloseRadialMenu();
    return Index;
}

CreateLayoutWidget()

bool AHUDBase::CreateLayoutWidget ( )

privatevirtual

{
    if(PrimaryLayoutClass == nullptr){UE_LOG(LogHUDBase, Error, TEXT("PrimaryLayoutClass in AHUDBASE"));return false;}
    PrimaryLayoutWidget = CreateWidget<UPrimaryLayoutWidget>(GetOwningPlayerController(), PrimaryLayoutClass);
    if(PrimaryLayoutWidget == nullptr){UE_LOG(LogHUDBase, Error, TEXT("Primary Layout Failed in AHUDBASE"));return false;}
    PrimaryLayoutWidget->AddToViewport();
    const bool bRegistered = PrimaryLayoutWidget->RegisterLayers();
    if(bRegistered == false){UE_LOG(LogHUDBase, Error, TEXT("bRegistered Failed in CreateLayoutWidget::AHUDBASE"));return false;}
    UE_LOG(LogHUDBase, Log, TEXT("bRegistered Passed in CreateLayoutWidget::AHUDBASE"));
    return true;
}

CreateRadialMenu()

bool AHUDBase::CreateRadialMenu ( )

private

{
    if(RadialMenuClass == nullptr){return false;}
    RadialMenuWidget = CreateWidget(GetOwningPlayerController(), RadialMenuClass);
    if(RadialMenuWidget == nullptr){return false;}
    return true;
}

GetContentFromLayer()

UUserWidget * AHUDBase::GetContentFromLayer ( const FGameplayTag & LayerName, const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("Get Content From Layer: %s"), *LayerName.GetTagName().ToString());
    }
    IWidgetLayout** LayerWidgetPtr = LayersMap.Find(LayerName);
    if(LayerWidgetPtr == nullptr){UE_LOG(LogHUDBase, Error, TEXT("LayersMap doesn't contain: %s"), *LayerName.GetTagName().ToString());return nullptr;}
    IWidgetLayout* LayerWidget = *LayerWidgetPtr;
    if(LayerWidget == nullptr){return nullptr;}
    return LayerWidget->GetContentFromLayer(WidgetClass);
}

GetIsRadialMenuOpen()

bool AHUDBase::GetIsRadialMenuOpen ( ) const

overridevirtual

Implements IHUDInterface.

{
    if(RadialMenuWidget == nullptr){return false;}
    return RadialMenuWidget->IsVisible();
}

HUDCancel()

void AHUDBase::HUDCancel ( )

overridevirtual

Implements IHUDInterface.

{
    if(bDebuggingMode){UE_LOG(LogHUDBase, Warning, TEXT("Hud Cancel"));}
}

HUDConfirm()

void AHUDBase::HUDConfirm ( )

overridevirtual

Implements IHUDInterface.

{
    if(bDebuggingMode){UE_LOG(LogHUDBase, Warning, TEXT("Hud Confirm"));}
}

HUDSelectionHorizontal()

void AHUDBase::HUDSelectionHorizontal ( const bool bMoveRight = true )

overridevirtual

Implements IHUDInterface.

{
    if(bDebuggingMode){UE_LOG(LogHUDBase, Warning, TEXT("Hud Selection Vertical %s"), bMoveRight ? *FString("Right"): *FString("Left"));}
}

HUDSelectionVertical()

void AHUDBase::HUDSelectionVertical ( const bool bMoveUp = true )

overridevirtual

Implements IHUDInterface.

{
    if(bDebuggingMode){UE_LOG(LogHUDBase, Warning, TEXT("Hud Selection Vertical %s"), bMoveUp ? *FString("Up"): *FString("Down"));}
}

OnCloseRadialMenu()

void AHUDBase::OnCloseRadialMenu ( )

protected

OnOpenRadialMenu()

void AHUDBase::OnOpenRadialMenu ( const FRadialMenuData & Data )

protected

OpenRadialMenu()

void AHUDBase::OpenRadialMenu ( const FRadialMenuData & Data )

overridevirtual

Implements IHUDInterface.

{
    if(RadialMenuWidget == nullptr)
    {
        const bool bCreated = CreateRadialMenu();
        if(bCreated == false){return;}
    }
    RadialMenuWidget->SetVisibility(ESlateVisibility::Hidden);
    if(GetOwningPlayerController() != nullptr)
    {
        FInputModeGameAndUI GameAndUI;
        GameAndUI.SetLockMouseToViewportBehavior(EMouseLockMode::LockAlways);
        GameAndUI.SetWidgetToFocus(RadialMenuWidget->TakeWidget());
        GetOwningPlayerController()->SetInputMode(GameAndUI);
    }
    IRadialMenu* RadialMenu = Cast<IRadialMenu>(RadialMenuWidget);
    if(RadialMenu == nullptr){CloseRadialMenu();return;}
    RadialMenu->StartUpdateInput();
    RadialMenu->SetWheelData(Data);
    RadialMenu->CenterMousePosition();
    RadialMenuWidget->SetVisibility(ESlateVisibility::Visible);
    if(RadialMenuWidget->IsInViewport() == false)
    {
        RadialMenuWidget->AddToPlayerScreen();
    }
    OnOpenRadialMenu(Data);
}

PopContentFromLayer()

bool AHUDBase::PopContentFromLayer ( const FGameplayTag & LayerName )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("PushContentToLayer: %s"), *LayerName.GetTagName().ToString());
    }
    IWidgetLayout** LayerWidgetPtr = LayersMap.Find(LayerName);
    if(LayerWidgetPtr == nullptr){return false;}
    IWidgetLayout* LayerWidget = *LayerWidgetPtr;
    if(LayerWidget == nullptr){return false;}
    LayerWidget->PopWidget();
    return true;
}

PushContentToLayer()

UUserWidget * AHUDBase::PushContentToLayer ( const FGameplayTag & LayerName, const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("PushContentToLayer: %s"), *LayerName.GetTagName().ToString());
    }
    IWidgetLayout** LayerWidgetPtr = LayersMap.Find(LayerName);
    if(LayerWidgetPtr == nullptr){UE_LOG(LogHUDBase, Error, TEXT("LayersMap doesn't contain: %s"), *LayerName.GetTagName().ToString());return nullptr;}
    IWidgetLayout* LayerWidget = *LayerWidgetPtr;
    if(LayerWidget == nullptr){return nullptr;}
    return LayerWidget->PushWidget(WidgetClass);
}

PushInitialNotificationManagers()

void AHUDBase::PushInitialNotificationManagers ( )

private

{
    // @TEST this seems like it would also always fail, when pushing content?
     TArray<FGameplayTag> GameplayTags;
     InitialNotificationManagers.GetKeys(GameplayTags);
     for(auto GameplayTag : GameplayTags)
     {
        if (bDebuggingMode)
        {
            UE_LOG(LogHUDBase, Log, TEXT("PushInitialNotificationManagers: %s"), *GameplayTag.GetTagName().ToString());
            
        }
        const TSoftClassPtr<UUserWidget>* WidgetPtr = InitialNotificationManagers.Find(GameplayTag);
        if(WidgetPtr == nullptr){continue;}
        TSoftClassPtr<UUserWidget> Widget = *WidgetPtr;
        if(Widget == nullptr){continue;}
        PushContentToLayer(HUDLayerTags::Notifications, Widget); 
     }
}

PushInitialScreens()

void AHUDBase::PushInitialScreens ( )

private

{
    TArray<FGameplayTag> GameplayTags;
    InitialScreens.GetKeys(GameplayTags);
    for(auto GameplayTag : GameplayTags)
    {
        UE_LOG(LogHUDBase, Warning, TEXT("PushInitialScreens: %s"), *GameplayTag.GetTagName().ToString());
        const TSoftClassPtr<UUserWidget>* WidgetPtr = InitialScreens.Find(GameplayTag);
        if(WidgetPtr->Get() == nullptr){continue;}
        TSoftClassPtr<UUserWidget> Widget = *WidgetPtr;
        if(Widget == nullptr){continue;}
        PushContentToLayer(GameplayTag, Widget);
    }
}

RegisterLayer()

bool AHUDBase::RegisterLayer ( const FGameplayTag & LayerName, UUserWidget * LayerWidget )

overridevirtual

Implements IHUDInterface.

{
    if(LayerWidget == nullptr){UE_LOG(LogHUDBase, Error, TEXT("LayerWidget NULL: %s"), *LayerName.GetTagName().ToString());return false;}
    if(LayersMap.Contains(LayerName)){UE_LOG(LogHUDBase, Error, TEXT("LayersMap.Contains: %s"), *LayerName.GetTagName().ToString());return false;}
    IWidgetLayout* WidgetLayout = Cast<IWidgetLayout>(LayerWidget);
    if(WidgetLayout == nullptr){UE_LOG(LogHUDBase, Error, TEXT("%s doesn't implement IWidgetLayout"), *LayerWidget->GetName());return false;}
    LayersMap.Add(LayerName, WidgetLayout);
    UE_LOG(LogHUDBase, Warning, TEXT("Layer Registered: %s"), *LayerName.GetTagName().ToString());
    return true;
}

RegisterNotificationManager()

bool AHUDBase::RegisterNotificationManager ( const FGameplayTag Type, UUserWidget * ManagerWidget )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("RegisterNotificationManager: %s"), *Type.GetTagName().ToString());
    }
    if(ManagerWidget == nullptr){return false;}
    if(NotificationManagersMap.Contains(Type)){return false;}
    INotificationManagerInterface* NotificationManager = Cast<INotificationManagerInterface>(ManagerWidget);
    if(NotificationManager == nullptr){UE_LOG(LogHUDBase,Error, TEXT("%s doesn't implement INotificationInterface"), *ManagerWidget->GetName());return false;}
    NotificationManagersMap.Add(Type, NotificationManager);
    return true;
}

ToggleGameLog()

void AHUDBase::ToggleGameLog ( )

overridevirtual

Implements IHUDInterface.

Reimplemented in ACustomHUD.

{
    
}

ToggleWidget()

bool AHUDBase::ToggleWidget ( const FGameplayTag & LayerName, UUserWidget * Widget )

overridevirtual

Implements IHUDInterface.

{
    if (bDebuggingMode)
    {
        UE_LOG(LogHUDBase, Log, TEXT("%s ToggleWidget: %s"), *LayerName.GetTagName().ToString(), *Widget->GetName());
    }
    IWidgetLayout** LayerWidgetPtr = LayersMap.Find(LayerName);
    if(LayerWidgetPtr == nullptr){UE_LOG(LogHUDBase, Warning, TEXT("AHUDBase::ToggleWidget LayerWidgetPtr Failed: %s"), *LayerName.GetTagName().ToString());return false;}
    IWidgetLayout* LayerWidget = *LayerWidgetPtr;
    if(LayerWidget == nullptr){return false;}
    return LayerWidget->ToggleWidget(Widget);
}

Member Data Documentation

bDebuggingMode

bool AHUDBase::bDebuggingMode = false

protected

InitialNotificationManagers

TMap<FGameplayTag, TSoftClassPtr<UUserWidget> > AHUDBase::InitialNotificationManagers

protected

InitialNotificationTimerHandle

FTimerHandle AHUDBase::InitialNotificationTimerHandle

private

InitialScreens

TMap<FGameplayTag, TSoftClassPtr<UUserWidget> > AHUDBase::InitialScreens

protected

LayersMap

TMap<FGameplayTag, IWidgetLayout*> AHUDBase::LayersMap

private

NotificationManagersMap

TMap<FGameplayTag, INotificationManagerInterface*> AHUDBase::NotificationManagersMap

private

NotificationTimerHandle

FTimerHandle AHUDBase::NotificationTimerHandle

private

PrimaryLayoutClass

TSubclassOf<UUserWidget> AHUDBase::PrimaryLayoutClass = nullptr

private

PrimaryLayoutWidget

class UPrimaryLayoutWidget* AHUDBase::PrimaryLayoutWidget = nullptr

protected

RadialMenuClass

TSubclassOf<UUserWidget> AHUDBase::RadialMenuClass = nullptr

private

RadialMenuWidget

UUserWidget* AHUDBase::RadialMenuWidget = nullptr

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Public/HUD/HUDBase.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Private/HUD/HUDBase.cpp