Viewport.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 "ShowFlags.h"
#include "Widgets/SWidget.h"
#include "UnrealClient.h"
#include "SceneTypes.h"
#include "Camera/CameraTypes.h"
#include "SceneManagement.h"
#include "Components/ContentWidget.h"
#include "ViewportClient.h"
 
#include "Viewport.generated.h"
 
class FCanvas;
class FPreviewScene;
class SAutoRefreshViewport;
 
struct FUMGViewportCameraTransform
{
public:
    UMG_API FUMGViewportCameraTransform();
 
    UMG_API void SetLocation(const FVector& Position);
 
    void SetRotation(const FRotator& Rotation)
    {
        ViewRotation = Rotation;
    }
 
    void SetLookAt(const FVector& InLookAt)
    {
        LookAt = InLookAt;
    }
 
    void SetOrthoZoom(float InOrthoZoom)
    {
        OrthoZoom = InOrthoZoom;
    }
 
 
    inline const FVector& GetLocation() const { return ViewLocation; }
 
    inline const FRotator& GetRotation() const { return ViewRotation; }
 
    inline const FVector& GetLookAt() const { return LookAt; }
 
    inline float GetOrthoZoom() const { return OrthoZoom; }
 
    UMG_API void TransitionToLocation(const FVector& InDesiredLocation, bool bInstant);
 
    UMG_API bool UpdateTransition();
 
    UMG_API FMatrix ComputeOrbitMatrix() const;
private:
    double TransitionStartTime;
    FVector ViewLocation;
    FRotator ViewRotation;
    FVector DesiredLocation;
    FVector LookAt;
    FVector StartLocation;
    float OrthoZoom;
};
 
 
class FUMGViewportClient : public FCommonViewportClient, public FViewElementDrawer
{
public:
    UMG_API FUMGViewportClient(FPreviewScene* InPreviewScene = nullptr);
    UMG_API virtual ~FUMGViewportClient();
 
    using FViewElementDrawer::Draw;
 
    // FViewportClient interface
    UMG_API virtual UWorld* GetWorld() const override;
    UMG_API virtual void Draw(FViewport* InViewport, FCanvas* Canvas) override;
 
    // FUMGViewportClient
 
    UMG_API virtual void Tick(float InDeltaTime);
 
    UMG_API virtual FSceneView* CalcSceneView(FSceneViewFamily* ViewFamily);
 
 
    UMG_API virtual FSceneInterface* GetScene() const;
 
 
    UMG_API bool IsAspectRatioConstrained() const;
 
    UMG_API void SetBackgroundColor(FLinearColor InBackgroundColor);
    UMG_API FLinearColor GetBackgroundColor() const;
 
    void SetViewLocation(const FVector& NewLocation)
    {
        ViewTransform.SetLocation(NewLocation);
    }
 
    void SetViewRotation(const FRotator& NewRotation)
    {
        ViewTransform.SetRotation(NewRotation);
    }
 
    void SetLookAtLocation(const FVector& LookAt, bool bRecalculateView = false)
    {
        ViewTransform.SetLookAt(LookAt);
 
        if ( bRecalculateView )
        {
            FMatrix OrbitMatrix = ViewTransform.ComputeOrbitMatrix();
            OrbitMatrix = OrbitMatrix.InverseFast();
 
            ViewTransform.SetRotation(OrbitMatrix.Rotator());
            ViewTransform.SetLocation(OrbitMatrix.GetOrigin());
        }
    }
 
    void SetOrthoZoom(float InOrthoZoom)
    {
        // A zero ortho zoom is not supported and causes NaN/div0 errors
        check(InOrthoZoom != 0);
        ViewTransform.SetOrthoZoom(InOrthoZoom);
    }
 
    const FVector& GetViewLocation() const
    {
        return ViewTransform.GetLocation();
    }
 
    const FRotator& GetViewRotation() const
    {
        return ViewTransform.GetRotation();
    }
 
    const FVector& GetLookAtLocation() const
    {
        return ViewTransform.GetLookAt();
    }
 
    float GetOrthoZoom() const
    {
        return ViewTransform.GetOrthoZoom();
    }
 
    UMG_API float GetOrthoUnitsPerPixel(const FViewport* Viewport) const;
 
    void SetEngineShowFlags(FEngineShowFlags InEngineShowFlags)
    {
        EngineShowFlags = InEngineShowFlags;
    }
 
    FMatrix GetViewProjectionMatrix() const;
 
protected:
 
    FPreviewScene* PreviewScene;
    
    FMinimalViewInfo ViewInfo;
 
    FLinearColor BackgroundColor;
 
    FUMGViewportCameraTransform ViewTransform;
 
    FViewport* Viewport;
 
    FSceneViewStateReference ViewState;
 
    FEngineShowFlags EngineShowFlags;
 
    FMatrix CachedViewProjectionMatrix;
};
 
UCLASS(Experimental, MinimalAPI)
class UViewport : public UContentWidget
{
    GENERATED_UCLASS_BODY()
 
    UE_DEPRECATED(5.2, "Direct access to BackgroundColor is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, Category = Appearance)
    FLinearColor BackgroundColor;
 
    UFUNCTION(BlueprintCallable, Category="Viewport")
    UMG_API UWorld* GetViewportWorld() const;
 
    UFUNCTION(BlueprintCallable, Category="Camera")
    UMG_API FVector GetViewLocation() const;
 
    UFUNCTION(BlueprintCallable, Category="Camera")
    UMG_API void SetViewLocation(FVector Location);
 
    UFUNCTION(BlueprintCallable, Category="Camera")
    UMG_API FRotator GetViewRotation() const;
 
    UFUNCTION(BlueprintCallable, Category="Camera")
    UMG_API void SetViewRotation(FRotator Rotation);
 
    UFUNCTION(BlueprintCallable, Category="Viewport")
    UMG_API AActor* Spawn(TSubclassOf<AActor> ActorClass);
 
    UMG_API void SetBackgroundColor(const FLinearColor& InColor);
 
    UMG_API const FLinearColor& GetBackgroundColor() const;
 
    UFUNCTION(BlueprintCallable, Category = "Viewport")
    UMG_API void SetEnableAdvancedFeatures(bool InEnableAdvancedFeatures);
 
    UFUNCTION(BlueprintCallable, Category = "Viewport")
    UMG_API void SetLightIntensity(float LightIntensity);
 
    UFUNCTION(BlueprintCallable, Category = "Viewport")
    UMG_API void SetSkyIntensity(float LightIntensity);
 
    UFUNCTION(BlueprintCallable, Category = "Viewport")
    UMG_API void SetShowFlag(FString InShowFlagName, bool InValue);
 
    UFUNCTION(BlueprintCallable, Category = "Viewport")
    UMG_API FMatrix GetViewProjectionMatrix() const;
    
 
    // UWidget interface
    UMG_API virtual void SynchronizeProperties() override;
    // End of UWidget interface
 
    UMG_API virtual void ReleaseSlateResources(bool bReleaseChildren) override;
 
#if WITH_EDITOR
    UMG_API virtual const FText GetPaletteCategory() override;
#endif
 
protected:
 
    // UPanelWidget
    UMG_API virtual void OnSlotAdded(UPanelSlot* Slot) override;
    UMG_API virtual void OnSlotRemoved(UPanelSlot* Slot) override;
    // End UPanelWidget
 
protected:
    TSharedPtr<class SAutoRefreshViewport> ViewportWidget;
 
protected:
    // UWidget interface
    UMG_API virtual TSharedRef<SWidget> RebuildWidget() override;
    // End of UWidget interface
 
    FEngineShowFlags ShowFlags;
};