WidgetComponent.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 "Layout/ArrangedWidget.h"
#include "WorldCollision.h"
#include "Components/MeshComponent.h"
#include "Blueprint/UserWidget.h"
#include "WidgetComponent.generated.h"
 
class FHittestGrid;
class FPrimitiveSceneProxy;
class FWidgetRenderer;
class SVirtualWindow;
class SWindow;
class UBodySetup;
class UMaterialInstanceDynamic;
class UTextureRenderTarget2D;
 
UENUM(BlueprintType)
enum class EWidgetSpace : uint8
{
    World,
    Screen
};
 
UENUM(BlueprintType)
enum class EWidgetTimingPolicy : uint8
{
    RealTime,
    GameTime
};
 
UENUM(BlueprintType)
enum class EWidgetBlendMode : uint8
{
    Opaque,
    Masked,
    Transparent
};
 
UENUM(BlueprintType)
enum class EWidgetGeometryMode : uint8
{
    Plane,
 
    Cylinder
};
 
UENUM(BlueprintType)
enum class EWindowVisibility : uint8
{
    Visible,
 
    SelfHitTestInvisible
};
 
UENUM(BlueprintType)
enum class ETickMode : uint8
{
    Disabled,
 
    Enabled,
 
    Automatic
};
 
 
UCLASS(Blueprintable, ClassGroup="UserInterface", hidecategories=(Object,Activation,"Components|Activation",Sockets,Base,Lighting,LOD,Mesh), editinlinenew, meta=(BlueprintSpawnableComponent) , MinimalAPI)
class UWidgetComponent : public UMeshComponent
{
    GENERATED_UCLASS_BODY()
 
public:
    //UObject interface
    UMG_API virtual void Serialize(FArchive& Ar) override;
    UMG_API virtual bool CanBeInCluster() const override;
    UMG_API virtual void PostLoad() override;
    //~ End UObject Interface
 
    UMG_API virtual void BeginPlay() override;
    UMG_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    /* UPrimitiveComponent Interface */
    UMG_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
    UMG_API virtual FBoxSphereBounds CalcBounds(const FTransform & LocalToWorld) const override;
    UMG_API virtual UBodySetup* GetBodySetup() override;
    UMG_API virtual FCollisionShape GetCollisionShape(float Inflation) const override;
    UMG_API virtual void OnRegister() override;
    UMG_API virtual void OnUnregister() override;
    UMG_API virtual void DestroyComponent(bool bPromoteChildren = false) override;
    UMG_API UMaterialInterface* GetMaterial(int32 MaterialIndex) const override;
    UMG_API virtual void SetMaterial(int32 ElementIndex, UMaterialInterface* Material) override;
    UMG_API int32 GetNumMaterials() const override;
    UMG_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
    UMG_API virtual void CollectPSOPrecacheData(const FPSOPrecacheParams& BasePrecachePSOParams, FMaterialInterfacePSOPrecacheParamsList& OutParams) override;
 
 
    UMG_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    UMG_API void ApplyComponentInstanceData(struct FWidgetComponentInstanceData* ComponentInstanceData);
    UMG_API virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const override;
 
#if WITH_EDITOR
    UMG_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    UMG_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
    UMG_API virtual void InitWidget();
 
    UMG_API virtual void ReleaseResources();
 
    UMG_API virtual void UpdateWidget();
 
    UMG_API virtual void UpdateRenderTarget(FIntPoint DesiredRenderTargetSize);
 
    UMG_API void UpdateBodySetup( bool bDrawSizeChanged = false );
    
    UMG_API void OnWorldUserEntered(int32 SlateUserIndex);
 
    UMG_API virtual void GetLocalHitLocation(FVector WorldHitLocation, FVector2D& OutLocalHitLocation) const;
 
    UMG_API TTuple<FVector, FVector2D> GetCylinderHitLocation(FVector WorldHitLocation, FVector WorldHitDirection) const;
 
    FVector2D GetLastLocalHitLocation() const
    {
        return LastLocalHitLocation;
    }
    
    TSubclassOf<UUserWidget> GetWidgetClass() const { return WidgetClass; }
 
    UFUNCTION(BlueprintCallable, Category=UserInterface, meta=(UnsafeDuringActorConstruction=true))
    UMG_API UUserWidget* GetUserWidgetObject() const;
 
    UMG_API const TSharedPtr<SWidget>& GetSlateWidget() const;
 
    UMG_API TArray<FWidgetAndPointer> GetHitWidgetPath(FVector WorldHitLocation, bool bIgnoreEnabledStatus, float CursorRadius = 0.0f);
 
    UMG_API TArray<FWidgetAndPointer> GetHitWidgetPath(FVector2D WidgetSpaceHitCoordinate, bool bIgnoreEnabledStatus, float CursorRadius = 0.0f);
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API UTextureRenderTarget2D* GetRenderTarget() const;
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API UMaterialInstanceDynamic* GetMaterialInstance() const;
 
    UMG_API TSharedPtr<SWindow> GetSlateWindow() const;
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API virtual UUserWidget* GetWidget() const;
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API virtual void SetWidget(UUserWidget* Widget);
 
    UMG_API virtual void SetSlateWidget( const TSharedPtr<SWidget>& InSlateWidget);
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API void SetOwnerPlayer(ULocalPlayer* LocalPlayer);
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    bool GetManuallyRedraw() const
    {
        return bManuallyRedraw;
    };
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API void SetManuallyRedraw(bool bUseManualRedraw);
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API ULocalPlayer* GetOwnerPlayer() const;
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API FVector2D GetDrawSize() const;
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    UMG_API FVector2D GetCurrentDrawSize() const;
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API void SetDrawSize(FVector2D Size);
 
    UFUNCTION(BlueprintCallable, Category=UserInterface, meta = (DeprecatedFunction, DeprecationMessage = "Use RequestRenderUpdate instead"))
    UMG_API virtual void RequestRedraw();
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    UMG_API virtual void RequestRenderUpdate();
 
    EWidgetBlendMode GetBlendMode() const { return BlendMode; }
 
    UMG_API void SetBlendMode( const EWidgetBlendMode NewBlendMode );
 
    UFUNCTION(BlueprintCallable, Category = Rendering)
    bool GetTwoSided() const
    {
        return bIsTwoSided;
    };
 
    UFUNCTION(BlueprintCallable, Category = Rendering)
    UMG_API void SetTwoSided( const bool bWantTwoSided );
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    bool GetTickWhenOffscreen() const
    {
        return TickWhenOffscreen;
    };
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    void SetTickWhenOffscreen(const bool bWantTickWhenOffscreen)
    {
        TickWhenOffscreen = bWantTickWhenOffscreen;
    };
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API void SetBackgroundColor( const FLinearColor NewBackgroundColor );
 
    UFUNCTION(BlueprintCallable, Category=UserInterface)
    UMG_API void SetTintColorAndOpacity( const FLinearColor NewTintColorAndOpacity );
 
    UMG_API void SetOpacityFromTexture( const float NewOpacityFromTexture );
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    FVector2D GetPivot() const { return Pivot; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    void SetPivot( const FVector2D& InPivot ) { Pivot = InPivot; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    bool GetDrawAtDesiredSize() const { return bDrawAtDesiredSize; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    void SetDrawAtDesiredSize(bool bInDrawAtDesiredSize) { bDrawAtDesiredSize = bInDrawAtDesiredSize; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    float GetRedrawTime() const { return RedrawTime; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    void SetRedrawTime(float InRedrawTime) { RedrawTime = InRedrawTime; }
 
    UMG_API TSharedPtr< SWindow > GetVirtualWindow() const;
    
    UMG_API void UpdateMaterialInstanceParameters();
 
    UMG_API void SetWidgetClass(TSubclassOf<UUserWidget> InWidgetClass);
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    EWidgetSpace GetWidgetSpace() const { return Space; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    void SetWidgetSpace( EWidgetSpace NewSpace ) { Space = NewSpace; }
 
    bool GetEditTimeUsable() const { return bEditTimeUsable; }
 
    void SetEditTimeUsable(bool Value) { bEditTimeUsable = Value; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    EWidgetGeometryMode GetGeometryMode() const 
    {
        return GeometryMode; 
    }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    void SetGeometryMode(EWidgetGeometryMode InGeometryMode) 
    { 
        GeometryMode = InGeometryMode; 
    }
 
    bool GetReceiveHardwareInput() const { return bReceiveHardwareInput; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    double GetCylinderArcAngle() const { return CylinderArcAngle; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    void SetCylinderArcAngle(const double InCylinderArcAngle) 
    { 
        CylinderArcAngle = InCylinderArcAngle; 
    }
 
    
    void SetInitialSharedLayerName(FName NewSharedLayerName) { SharedLayerName = NewSharedLayerName; }
    
    void SetInitialLayerZOrder(int32 NewLayerZOrder) { LayerZOrder = NewLayerZOrder; }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    bool GetWindowFocusable() const
    {
        return bWindowFocusable;
    };
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    UMG_API void SetWindowFocusable(bool bInWindowFocusable);
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    EWindowVisibility GetWindowVisiblility() const
    {
        return WindowVisibility;
    }
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    UMG_API void SetWindowVisibility(EWindowVisibility InVisibility);
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    UMG_API void SetTickMode(ETickMode InTickMode);
 
    UFUNCTION(BlueprintCallable, Category = UserInterface)
    UMG_API bool IsWidgetVisible() const;
 
    virtual FVector2D ModifyProjectedLocalPosition(const FGeometry& ViewportGeometry, const FVector2D& LocalPosition) { return LocalPosition; }
 
    DECLARE_MULTICAST_DELEGATE(FOnMaterialInstanceUpdated);
    FOnMaterialInstanceUpdated OnMaterialInstanceUpdated;
 
protected:
    UMG_API void OnLevelRemovedFromWorld(ULevel* InLevel, UWorld* InWorld);
 
    UMG_API bool CanReceiveHardwareInput() const;
 
    UMG_API void RegisterHitTesterWithViewport(TSharedPtr<SViewport> ViewportWidget);
    UMG_API void UnregisterHitTesterWithViewport(TSharedPtr<SViewport> ViewportWidget);
 
    UMG_API void RegisterWindow();
    UMG_API void UnregisterWindow();
    UMG_API void RemoveWidgetFromScreen();
 
    UMG_API virtual bool ShouldDrawWidget() const;
 
    UMG_API virtual void DrawWidgetToRenderTarget(float DeltaTime);
 
    UMG_API double ComputeComponentWidth() const;
 
    UMG_API void UpdateMaterialInstance();
 
    UMG_API virtual void OnHiddenInGameChanged() override;
 
protected:
    UPROPERTY(EditAnywhere, Category=UserInterface)
    EWidgetSpace Space;
 
    UPROPERTY(EditAnywhere, Category=UserInterface)
    EWidgetTimingPolicy TimingPolicy;
 
    UPROPERTY(EditAnywhere, Category=UserInterface)
    TSubclassOf<UUserWidget> WidgetClass;
    
    UPROPERTY(EditAnywhere, Category=UserInterface)
    FIntPoint DrawSize;
 
    UPROPERTY(EditAnywhere, Category=UserInterface)
    bool bManuallyRedraw;
 
    UPROPERTY(Transient, DuplicateTransient)
    bool bRedrawRequested;
 
    UPROPERTY(EditAnywhere, Category=UserInterface)
    float RedrawTime;
 
    double LastWidgetRenderTime;
 
    UMG_API double GetCurrentTime() const;
 
    UPROPERTY(Transient, DuplicateTransient)
    FIntPoint CurrentDrawSize;
 
    UPROPERTY(EditAnywhere, Category = UserInterface, meta=(EditCondition="Space==EWidgetSpace::World", DisplayName="Use Invalidation"))
    bool bUseInvalidationInWorldSpace;
 
    UPROPERTY(EditAnywhere, Category=UserInterface)
    bool bDrawAtDesiredSize;
 
    UPROPERTY(EditAnywhere, Category=UserInterface)
    FVector2D Pivot;
 
    UPROPERTY(EditAnywhere, Category=Interaction)
    bool bReceiveHardwareInput;
 
    UPROPERTY(EditAnywhere, Category=Interaction)
    bool bWindowFocusable;
 
    UPROPERTY(EditAnywhere, Category = Interaction)
    EWindowVisibility WindowVisibility;
 
    UPROPERTY(EditAnywhere, Category = UserInterface, AdvancedDisplay)
    bool bApplyGammaCorrection;
 
    UPROPERTY()
    TObjectPtr<ULocalPlayer> OwnerPlayer;
 
    UPROPERTY(EditAnywhere, Category=Rendering)
    FLinearColor BackgroundColor;
 
    UPROPERTY(EditAnywhere, Category=Rendering)
    FLinearColor TintColorAndOpacity;
 
    UPROPERTY(EditAnywhere, Category=Rendering, meta=(ClampMin=0.0f, ClampMax=1.0f))
    float OpacityFromTexture;
 
    UPROPERTY(EditAnywhere, Category=Rendering)
    EWidgetBlendMode BlendMode;
 
    UPROPERTY(EditAnywhere, Category=Rendering)
    bool bIsTwoSided;
 
    UPROPERTY(EditAnywhere, Category=Animation)
    bool TickWhenOffscreen;
 
    UPROPERTY(Transient, DuplicateTransient)
    TObjectPtr<class UBodySetup> BodySetup;
 
    UPROPERTY()
    TObjectPtr<UMaterialInterface> TranslucentMaterial;
 
    UPROPERTY()
    TObjectPtr<UMaterialInterface> TranslucentMaterial_OneSided;
 
    UPROPERTY()
    TObjectPtr<UMaterialInterface> OpaqueMaterial;
 
    UPROPERTY()
    TObjectPtr<UMaterialInterface> OpaqueMaterial_OneSided;
 
    UPROPERTY()
    TObjectPtr<UMaterialInterface> MaskedMaterial;
 
    UPROPERTY()
    TObjectPtr<UMaterialInterface> MaskedMaterial_OneSided;
 
    UPROPERTY(Transient, DuplicateTransient)
    TObjectPtr<UTextureRenderTarget2D> RenderTarget;
 
    UPROPERTY(Transient, DuplicateTransient)
    TObjectPtr<UMaterialInstanceDynamic> MaterialInstance;
 
    UPROPERTY(Transient, DuplicateTransient)
    bool bAddedToScreen;
 
    UPROPERTY()
    bool bEditTimeUsable;
 
protected:
 
    UPROPERTY(EditDefaultsOnly, Category = Layers)
    FName SharedLayerName;
 
    UPROPERTY(EditDefaultsOnly, Category = Layers)
    int32 LayerZOrder;
 
    UPROPERTY(EditAnywhere, Category=UserInterface)
    EWidgetGeometryMode GeometryMode;
 
    UPROPERTY(EditAnywhere, Category=UserInterface, meta=(ClampMin=1.0f, ClampMax=180.0f))
    double CylinderArcAngle;
 
    UPROPERTY(EditAnywhere, Category = UserInterface)
    ETickMode TickMode;
 
    TSharedPtr<class SVirtualWindow> SlateWindow;
 
    FVector2D LastLocalHitLocation;
 
    static UMG_API TSharedPtr<class FWidget3DHitTester> WidgetHitTester;
 
    class FWidgetRenderer* WidgetRenderer;
 
private: 
    UMG_API bool ShouldReenableComponentTickWhenWidgetBecomesVisible() const;
 
    UPROPERTY(Transient, DuplicateTransient)
    TObjectPtr<UUserWidget> Widget;
 
    TSharedPtr<SWidget> SlateWidget;
    
    TSet<int32> UsersEnteredWorldWidget;
 
    TWeakPtr<SWidget> CurrentSlateWidget;
 
    static UMG_API EVisibility ConvertWindowVisibilityToVisibility(EWindowVisibility visibility);
 
    UMG_API void OnWidgetVisibilityChanged(ESlateVisibility InVisibility);
 
    UMG_API void UpdateWidgetOnScreen();
 
    UMG_API void AddWidgetToScreen(ULocalPlayer* TargetPlayer);
    
    UMG_API void ResetWorldUserFocusOnWidget();
 
    bool bRenderCleared;
    bool bOnWidgetVisibilityChangedRegistered;
};
 
USTRUCT()
struct FWidgetComponentInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
public:
    FWidgetComponentInstanceData()
        : RenderTarget(nullptr)
    {}
 
    FWidgetComponentInstanceData(const UWidgetComponent* SourceComponent)
        : FSceneComponentInstanceData(SourceComponent)
        , WidgetClass(SourceComponent->GetWidgetClass())
        , RenderTarget(SourceComponent->GetRenderTarget())
    {}
    virtual ~FWidgetComponentInstanceData() = default;
 
    virtual bool ContainsData() const override
    {
        return true;
    }
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override
    {
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<UWidgetComponent>(Component)->ApplyComponentInstanceData(this);
    }
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override
    {
        Super::AddReferencedObjects(Collector);
 
        Collector.AddReferencedObject(WidgetClass.GetGCPtr());
        Collector.AddReferencedObject(RenderTarget);
    }
 
public:
    TSubclassOf<UUserWidget> WidgetClass;
    TObjectPtr<UTextureRenderTarget2D> RenderTarget;
};