HUD.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Templates/SubclassOf.h"
#include "GameFramework/Actor.h"
#include "GameFramework/HUDHitBox.h"
#include "GameFramework/DebugTextInfo.h"
#include "HUD.generated.h"
 
class AHUD;
class APawn;
class APlayerController;
class FCanvas;
class FDebugDisplayInfo;
class UCanvas;
class UFont;
class UMaterialInterface;
class UTexture;
 
DECLARE_TS_MULTICAST_DELEGATE_FiveParams(FOnShowDebugInfo, AHUD* /* HUD */, UCanvas* /* Canvas */, const FDebugDisplayInfo& /* DisplayInfo */, float& /* YL */, float& /* YPos */);
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnHUDPostRender, AHUD* /* HUD */, UCanvas* /* Canvas */);
 
UCLASS(config=Game, hidecategories=(Rendering,Actor,Input,Replication), showcategories=("Input|MouseInput", "Input|TouchInput"), notplaceable, transient, BlueprintType, Blueprintable, MinimalAPI)
class AHUD : public AActor
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(BlueprintReadOnly, Category=HUD)
    TObjectPtr<APlayerController> PlayerOwner;    
 
    UPROPERTY(BlueprintReadOnly, Category=HUD)
    uint8 bLostFocusPaused:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=HUD)
    uint8 bShowHUD:1;    
 
    UPROPERTY(BlueprintReadWrite, Category=HUD)
    uint8 bShowDebugInfo:1;    
 
    UPROPERTY(Transient)
    int32 CurrentTargetIndex;
 
    UPROPERTY(BlueprintReadWrite, Category=HUD)
    uint8 bShowHitBoxDebugInfo:1;    
 
    UPROPERTY(BlueprintReadWrite, Category=HUD)
    uint8 bShowOverlays:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=HUD)
    uint8 bEnableDebugTextShadow:1; 
 
private:
    uint8 bShowDebugForReticleTarget:1;
    
public:
    UPROPERTY()
    TArray<TObjectPtr<AActor>> PostRenderedActors;
 
    float LastHUDRenderTime;
 
    float RenderDelta;
 
    UPROPERTY(globalconfig)
    TArray<FName> DebugDisplay;
 
    UPROPERTY(globalconfig)
    TArray<FName> ToggledDebugCategories;
 
protected:
    UPROPERTY()
    TObjectPtr<UCanvas> Canvas;
 
    UPROPERTY()
    TObjectPtr<UCanvas> DebugCanvas;
 
    UPROPERTY()
    TArray<struct FDebugTextInfo> DebugTextList;
 
public:
    //=============================================================================
    // Utils
 
    UFUNCTION(exec)
    ENGINE_API virtual void ShowHUD();
 
    UFUNCTION(exec)
    ENGINE_API virtual void ShowDebug(FName DebugType = NAME_None);
 
    UFUNCTION(exec)
    ENGINE_API void ShowDebugToggleSubCategory(FName Category);
 
    UFUNCTION(exec)
    ENGINE_API void ShowDebugForReticleTargetToggle(TSubclassOf<AActor> DesiredClass);
 
protected:
    UPROPERTY()
    TSubclassOf<AActor> ShowDebugTargetDesiredClass;
 
    UPROPERTY()
    TObjectPtr<AActor> ShowDebugTargetActor;
 
public:
    UFUNCTION(reliable, client, SealedEvent)
    ENGINE_API void AddDebugText(const FString& DebugText, AActor* SrcActor = NULL, float Duration = 0, FVector Offset = FVector(ForceInit), FVector DesiredOffset = FVector(ForceInit), FColor TextColor = FColor(ForceInit), bool bSkipOverwriteCheck = false, bool bAbsoluteLocation = false, bool bKeepAttachedToActor = false, UFont* InFont = NULL, float FontScale = 1.0, bool bDrawShadow = false);
 
    UFUNCTION(reliable, client, SealedEvent)
    ENGINE_API void RemoveAllDebugStrings();
 
    UFUNCTION(reliable, client, SealedEvent)
    ENGINE_API void RemoveDebugText(AActor* SrcActor, bool bLeaveDurationText = false);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic)
    ENGINE_API void ReceiveDrawHUD(int32 SizeX, int32 SizeY);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, meta=(DisplayName = "HitBoxClicked"))
    ENGINE_API void ReceiveHitBoxClick(const FName BoxName);
    ENGINE_API virtual void NotifyHitBoxClick(FName BoxName);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, meta=(DisplayName = "HitBoxReleased"))
    ENGINE_API void ReceiveHitBoxRelease(const FName BoxName);
    ENGINE_API virtual void NotifyHitBoxRelease(FName BoxName);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, meta=(DisplayName = "HitBoxBeginCursorOver"))
    ENGINE_API void ReceiveHitBoxBeginCursorOver(const FName BoxName);
    ENGINE_API virtual void NotifyHitBoxBeginCursorOver(FName BoxName);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, meta=(DisplayName = "HitBoxEndCursorOver"))
    ENGINE_API void ReceiveHitBoxEndCursorOver(const FName BoxName);
    ENGINE_API virtual void NotifyHitBoxEndCursorOver(FName BoxName);
 
    //=============================================================================
    // Kismet API for simple HUD drawing.
 
    UFUNCTION(BlueprintCallable, Category=HUD)
    ENGINE_API void GetTextSize(const FString& Text, float& OutWidth, float& OutHeight, UFont* Font=NULL, float Scale=1.f) const;
 
    UFUNCTION(BlueprintCallable, Category=HUD, meta=(TextColor="(R=0,G=0,B=0,A=1)"))
    ENGINE_API void DrawText(const FString& Text, FLinearColor TextColor, float ScreenX, float ScreenY, UFont* Font=NULL, float Scale=1.f, bool bScalePosition=false);
 
    UFUNCTION(BlueprintCallable, Category=HUD, meta=(LineColor="(R=0,G=0,B=0,A=1)"))
    ENGINE_API void DrawLine(float StartScreenX, float StartScreenY, float EndScreenX, float EndScreenY, FLinearColor LineColor, float LineThickness=0.f);
 
    UFUNCTION(BlueprintCallable, Category=HUD, meta=(RectColor="(R=0,G=0,B=0,A=1)"))
    ENGINE_API void DrawRect(FLinearColor RectColor, float ScreenX, float ScreenY, float ScreenW, float ScreenH);
 
    UFUNCTION(BlueprintCallable, Category=HUD, meta=(AdvancedDisplay = "9"))
    ENGINE_API void DrawTexture(UTexture* Texture, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float TextureU, float TextureV, float TextureUWidth, float TextureVHeight, FLinearColor TintColor=FLinearColor::White, EBlendMode BlendMode=BLEND_Translucent, float Scale=1.f, bool bScalePosition=false, float Rotation=0.f, FVector2D RotPivot=FVector2D::ZeroVector);
 
    UFUNCTION(BlueprintCallable, Category=HUD)
    ENGINE_API void DrawTextureSimple(UTexture* Texture, float ScreenX, float ScreenY, float Scale=1.f, bool bScalePosition=false);
 
    UFUNCTION(BlueprintCallable, Category=HUD, meta=(AdvancedDisplay = "9"))
    ENGINE_API void DrawMaterial(UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float MaterialU, float MaterialV, float MaterialUWidth, float MaterialVHeight, float Scale=1.f, bool bScalePosition=false, float Rotation=0.f, FVector2D RotPivot=FVector2D::ZeroVector);
 
    UFUNCTION(BlueprintCallable, Category=HUD)
    ENGINE_API void DrawMaterialSimple(UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float Scale=1.f, bool bScalePosition=false);
 
    UFUNCTION(BlueprintCallable, Category = HUD)
    ENGINE_API void DrawMaterialTriangle(UMaterialInterface* Material, FVector2D V0_Pos, FVector2D V1_Pos, FVector2D V2_Pos, FVector2D V0_UV, FVector2D V1_UV, FVector2D V2_UV, FLinearColor V0_Color = FLinearColor::White, FLinearColor V1_Color = FLinearColor::White, FLinearColor V2_Color = FLinearColor::White);
    
    UFUNCTION(BlueprintCallable, Category = HUD)
    ENGINE_API FVector Project(FVector Location, bool bClampToZeroPlane = true) const;
    
    UFUNCTION(BlueprintCallable, Category = HUD)
    ENGINE_API void Deproject(float ScreenX, float ScreenY, FVector& WorldPosition, FVector& WorldDirection) const;
 
    template <typename ClassFilter>
    bool GetActorsInSelectionRectangle(const FVector2D& FirstPoint, const FVector2D& SecondPoint, TArray<ClassFilter*>& OutActors, bool bIncludeNonCollidingComponents = true, bool bActorMustBeFullyEnclosed = false)
    {
        //Is Actor subclass?
        if (!ClassFilter::StaticClass()->IsChildOf(AActor::StaticClass()))
        {
            return false;
        }
 
        //Run Inner Function, output to Base AActor Array
        TArray<AActor*> OutActorsBaseArray;
        GetActorsInSelectionRectangle(ClassFilter::StaticClass(), FirstPoint, SecondPoint, OutActorsBaseArray, bIncludeNonCollidingComponents, bActorMustBeFullyEnclosed);
 
        //Construct casted template type array
        for (AActor* EachActor : OutActorsBaseArray)
        {
            OutActors.Add(CastChecked<ClassFilter>(EachActor));
        }
 
        return true;
    };
 
    UFUNCTION(BlueprintPure, Category=HUD)
    ENGINE_API void GetActorsInSelectionRectangle(TSubclassOf<AActor> ClassFilter, const FVector2D& FirstPoint, const FVector2D& SecondPoint, TArray<AActor*>& OutActors, bool bIncludeNonCollidingComponents = true, bool bActorMustBeFullyEnclosed = false);
 
    UFUNCTION(BlueprintCallable, Category=HUD)
    ENGINE_API void AddHitBox(FVector2D Position, FVector2D Size, FName InName, bool bConsumesInput, int32 Priority = 0);
 
    UFUNCTION(BlueprintCallable, Category=HUD)
    ENGINE_API APlayerController* GetOwningPlayerController() const;
 
    UFUNCTION(BlueprintCallable, Category=HUD)
    ENGINE_API APawn* GetOwningPawn() const;
 
    ENGINE_API void Draw3DLine(FVector Start, FVector End, FColor LineColor);
 
    ENGINE_API void Draw2DLine(int32 X1, int32 Y1, int32 X2, int32 Y2, FColor LineColor);
 
    ENGINE_API void SetCanvas(UCanvas* InCanvas, UCanvas* InDebugCanvas);
 
    ENGINE_API virtual void PostInitializeComponents() override;
 
    ENGINE_API virtual void DrawActorOverlays(FVector Viewpoint, FRotator ViewRotation);
 
    ENGINE_API virtual void DrawSafeZoneOverlay();
 
    ENGINE_API virtual void NotifyBindPostProcessEffects();
 
    /************************************************************************************************************
     Actor Render - These functions allow for actors in the world to gain access to the hud and render
     information on it.
    ************************************************************************************************************/
 
    ENGINE_API virtual void RemovePostRenderedActor(AActor* A);
 
    ENGINE_API virtual void AddPostRenderedActor(AActor* A);
 
    ENGINE_API virtual bool ShouldDisplayDebug(const FName& DebugType) const;
 
    ENGINE_API virtual void ShowDebugInfo(float& YL, float& YPos);
 
    ENGINE_API virtual AActor* GetCurrentDebugTargetActor();
    
    static ENGINE_API void AddActorToDebugList(AActor* InActor, TArray<AActor*>& InOutList, UWorld* InWorld);
 
    static ENGINE_API void AddComponentOwnerToDebugList(UActorComponent* InComponent, TArray<AActor*>& InOutList, UWorld* InWorld);
 
    ENGINE_API virtual void GetDebugActorList(TArray<AActor*>& InOutList);
 
    UFUNCTION(exec)
    ENGINE_API virtual void NextDebugTarget();
 
    UFUNCTION(exec)
    ENGINE_API virtual void PreviousDebugTarget();
 
    // Callback allowing external systems to register to show debug info
    static ENGINE_API FOnShowDebugInfo OnShowDebugInfo;
 
    // Called from ::PostRender. For less player/actor centered debugging
    static ENGINE_API FOnHUDPostRender OnHUDPostRender;
 
    ENGINE_API virtual void PostRender();
 
    ENGINE_API virtual void DrawHUD();
 
    //=============================================================================
    // Messaging.
    //=============================================================================
 
    ENGINE_API virtual  UFont* GetFontFromSizeIndex(int32 FontSizeIndex) const;
 
    ENGINE_API virtual void OnLostFocusPause(bool bEnable);
 
    ENGINE_API void DrawDebugTextList();
 
    virtual void HandleBugScreenShot() { }
 
    TArray< FHUDHitBox >    HitBoxMap;
    
    TArray< FHUDHitBox* >   HitBoxHits;
 
    TSet< FName > HitBoxesOver;
 
    ENGINE_API void RenderHitBoxes( FCanvas* InCanvas );
    
    ENGINE_API bool UpdateAndDispatchHitBoxClickEvents(const FVector2D ClickLocation, const EInputEvent InEventType);
    
    ENGINE_API void UpdateHitBoxCandidates( TArray<FVector2D> InContactPoints );
    
    ENGINE_API bool AnyCurrentHitBoxHits() const;   
 
    ENGINE_API const FHUDHitBox* GetHitBoxAtCoordinates( FVector2D InHitLocation, bool bConsumingInput = false ) const;
 
    ENGINE_API void GetHitBoxesAtCoordinates(FVector2D InHitLocation, TArray<const FHUDHitBox*>& OutHitBoxes) const;
    
    ENGINE_API const FHUDHitBox* GetHitBoxWithName( const FName InName ) const;
 
protected:
    ENGINE_API bool IsCanvasValid_WarnIfNot() const;
 
private:
    // Helper function to deal with screen offset and splitscreen mapping of coordinates to HUD
    ENGINE_API FVector2D GetCoordinateOffset() const;
 
    ENGINE_API int32 FindDebugTextListIntervalForActor(AActor* InSrcActor, int32& OutFirstIdx, int32& OutLastIdx) const;
};