GizmoViewContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "GizmoRenderingUtil.h"
#include "SceneView.h"
 
#include "GizmoViewContext.generated.h"
 
UCLASS(MinimalAPI)
class UGizmoViewContext : public UObject, public UE::GizmoRenderingUtil::ISceneViewInterface
{
    GENERATED_BODY()
public:
    
    // Wrapping class for the matrices so that they can be accessed in the same way
    // that they are accessed in FSceneView.
    class FMatrices
    {
    public:
        void ResetFromSceneView(const FSceneView& SceneView)
        {
            ProjectionMatrix = SceneView.ViewMatrices.GetProjectionMatrix();
            ViewMatrix = SceneView.ViewMatrices.GetViewMatrix();
            InvViewMatrix = SceneView.ViewMatrices.GetInvViewMatrix();
            ViewProjectionMatrix = SceneView.ViewMatrices.GetViewProjectionMatrix();
            InvViewProjectionMatrix = SceneView.ViewMatrices.GetInvViewProjectionMatrix();
        }
 
        const FMatrix& GetProjectionMatrix() const { return ProjectionMatrix; }
        const FMatrix& GetViewMatrix() const { return ViewMatrix; }
        const FMatrix& GetInvViewMatrix() const { return InvViewMatrix; }
        const FMatrix& GetViewProjectionMatrix() const { return ViewProjectionMatrix; }
        const FMatrix& GetInvViewProjectionMatrix() const { return InvViewProjectionMatrix; }
 
    protected:
        FMatrix ProjectionMatrix = FMatrix::Identity;
        FMatrix ViewMatrix = FMatrix::Identity;
        FMatrix InvViewMatrix = FMatrix::Identity;
        FMatrix ViewProjectionMatrix = FMatrix::Identity;
        FMatrix InvViewProjectionMatrix = FMatrix::Identity;
    };
 
    // Use this to reinitialize the object each frame for the hovered viewport.
    void ResetFromSceneView(const FSceneView& SceneView)
    {
        UnscaledViewRect = SceneView.UnscaledViewRect;
        ViewMatrices.ResetFromSceneView(SceneView);
        bIsPerspectiveProjection = SceneView.IsPerspectiveProjection();
        ViewLocation = SceneView.ViewLocation;
    }
 
    // ISceneViewInterface
    const FIntRect& GetUnscaledViewRect() const override { return UnscaledViewRect; }
    FVector GetViewLocation() const override { return ViewLocation; }
    FVector GetViewRight() const override { return ViewMatrices.GetViewMatrix().GetColumn(0); }
    FVector GetViewUp() const override { return ViewMatrices.GetViewMatrix().GetColumn(1); }
    FVector GetViewDirection() const override { return ViewMatrices.GetViewMatrix().GetColumn(2); }
    const FMatrix& GetProjectionMatrix() const override { return ViewMatrices.GetProjectionMatrix(); }
    const FMatrix& GetViewMatrix() const override { return ViewMatrices.GetViewMatrix(); }
    bool IsPerspectiveProjection() const override { return bIsPerspectiveProjection; }
    virtual double GetDPIScale() const override { return DPIScale; }
    void SetDPIScale(const double InDPIScale) { DPIScale = InDPIScale; }
 
    FVector4 WorldToScreen(const FVector& WorldPoint) const override
    {
        return ViewMatrices.GetViewProjectionMatrix().TransformFVector4(FVector4(WorldPoint, 1));
    }
 
    // WorldToScreen -> ScreenToPixel. A result of (-1, -1) indicates invalid W.
    FVector2D WorldToPixel(const FVector& WorldPoint) const
    {
        FVector2D ScreenPos;
        if (ScreenToPixel(WorldToScreen(WorldPoint), ScreenPos))
        {
            return ScreenPos;
        }
 
        return -FVector2D::One();
    }
 
    bool ScreenToPixel(const FVector4& ScreenPoint, FVector2D& OutPixelLocation) const
    {
        // implementation copied from FSceneView::ScreenToPixel() 
 
        if (ScreenPoint.W != 0.0f)
        {
            //Reverse the W in the case it is negative, this allow to manipulate a manipulator in the same direction when the camera is really close to the manipulator.
            double InvW = (ScreenPoint.W > 0.0 ? 1.0 : -1.0) / ScreenPoint.W;
            double Y = (GProjectionSignY > 0.0) ? ScreenPoint.Y : 1.0 - ScreenPoint.Y;
            OutPixelLocation = FVector2D(
                UnscaledViewRect.Min.X + (0.5 + ScreenPoint.X * 0.5 * InvW) * UnscaledViewRect.Width(),
                UnscaledViewRect.Min.Y + (0.5 - Y * 0.5 * InvW) * UnscaledViewRect.Height()
            );
            return true;
        }
        else
        {
            return false;
        }
    }
 
    FMatrices ViewMatrices;
    FIntRect UnscaledViewRect;
    FVector ViewLocation;
 
protected:
    bool bIsPerspectiveProjection;
    double DPIScale = 1.0; // Usually set from ViewportClient
};