ViewBasedTransformAdjusters.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Math/BoxSphereBounds.h"
#include "Math/Transform.h"
#include "Templates/SharedPointer.h"
 
class USceneComponent;
class UViewAdjustedStaticMeshGizmoComponent;
 
namespace UE::GizmoRenderingUtil
{
    class ISceneViewInterface;
 
    class IViewBasedTransformAdjuster
    {
    public:
        virtual ~IViewBasedTransformAdjuster() {}
 
        virtual FTransform GetAdjustedComponentToWorld(
            const ISceneViewInterface& View, const FTransform& CurrentComponentToWorld) = 0;
 
        virtual FTransform GetAdjustedComponentToWorld_RenderThread(
            const ISceneViewInterface& View, const FTransform& CurrentComponentToWorld)
        {
            // By default, just route to the other implementation. This is safe to do for any adjusters
            //  that remain constant for the life of the render proxy.
            return GetAdjustedComponentToWorld(View, CurrentComponentToWorld);
        }
 
        virtual void UpdateWorldLocalState(bool bWorldIn) {}
 
        virtual FBoxSphereBounds GetViewIndependentBounds(const FTransform& LocalToWorld,
            const FBoxSphereBounds& OriginalBounds)
        {
            return OriginalBounds;
        }
    };
 
    class FSimpleConstantViewScaleAdjuster : public IViewBasedTransformAdjuster
    {
    public:
        // IGizmoViewTransformAdjuster
        INTERACTIVETOOLSFRAMEWORK_API virtual FTransform GetAdjustedComponentToWorld(
            const ISceneViewInterface& View,
            const FTransform& CurrentComponentToWorld) override;
 
        INTERACTIVETOOLSFRAMEWORK_API virtual FBoxSphereBounds GetViewIndependentBounds(const FTransform& LocalToWorld,
            const FBoxSphereBounds& OriginalBounds) override;
    private:
    };
 
    class FSubGizmoTransformAdjuster : public IViewBasedTransformAdjuster,
        // Used for getting a weak pointer to itself when enqueuing state change on the render thread (in SetGizmoOriginTransform)
        public TSharedFromThis<FSubGizmoTransformAdjuster, ESPMode::ThreadSafe>
    {
    public:
        struct FSettings
        {
            // Some compilers (clang, at least) have issues with using a nested class with default initializers
            // and a default constructor as a default argument in a function, hence this constructor.
            FSettings() {};
 
            // Keeps view size and offset relative to parent gizmo constant
            bool bKeepConstantViewSize = true;
            // Mirrors the component depending on which octant of the parent gizmo the view is located
            bool bMirrorBasedOnOctant = true;
            // Considers the parent gizmo transform to be unrotated, and applies the relative component transform on top of that.
            //  This is frequently not necessary to set because code upstream will typically update it every tick anyway
            //  via UViewAdjustedStaticMeshGizmoComponent's UpdateWorldLocalState implementation.
            bool bUseWorldAxesForGizmo = false;
            // If positive, keeps the component a given distance in front of the ortho camera, to avoid
            //  clipping it. Applied before bKeepConstantViewSize.
            double DistanceInFrontOfCameraInOrtho = 0;
        };
 
        FSubGizmoTransformAdjuster(
            const FTransform& GizmoOriginToComponent = FTransform::Identity, const FSettings& SettingsIn = FSettings())
            : GizmoOriginToComponent_GameThread(GizmoOriginToComponent)
            , GizmoOriginToComponent_RenderThread(GizmoOriginToComponent)
            , Settings(SettingsIn)
        {}
 
        INTERACTIVETOOLSFRAMEWORK_API void SetGizmoOriginTransform(const FTransform& GizmoOriginToComponent);
 
        void SetMirrorBasedOnOctant(bool bOn) 
        {
            Settings.bMirrorBasedOnOctant = bOn;
        }
        void SetSettings(const FSettings& SettingsIn)
        {
            Settings = SettingsIn;
        }
 
        INTERACTIVETOOLSFRAMEWORK_API static TSharedPtr<FSubGizmoTransformAdjuster> AddTransformAdjuster(
            UViewAdjustedStaticMeshGizmoComponent* ComponentIn, USceneComponent* GizmoRootComponent, 
            bool bMirrorBasedOnOctant);
 
        INTERACTIVETOOLSFRAMEWORK_API static TSharedPtr<FSubGizmoTransformAdjuster> AddTransformAdjuster(
            UViewAdjustedStaticMeshGizmoComponent* ComponentIn, USceneComponent* GizmoRootComponent,
            TFunction<bool()> ShouldMirrorBasedOnOctant);
 
 
        // IGizmoViewTransformAdjuster
        INTERACTIVETOOLSFRAMEWORK_API virtual FTransform GetAdjustedComponentToWorld(
            const UE::GizmoRenderingUtil::ISceneViewInterface& View,
            const FTransform& CurrentComponentToWorld) override;
 
        INTERACTIVETOOLSFRAMEWORK_API virtual FTransform GetAdjustedComponentToWorld_RenderThread(
            const ISceneViewInterface& View, const FTransform& CurrentComponentToWorld) override;
        
        virtual void UpdateWorldLocalState(bool bWorldIn) override
        {
            Settings.bUseWorldAxesForGizmo = bWorldIn;
        }
 
        INTERACTIVETOOLSFRAMEWORK_API virtual FBoxSphereBounds GetViewIndependentBounds(const FTransform& LocalToWorld,
            const FBoxSphereBounds& OriginalBounds) override;
    private:
        FTransform GizmoOriginToComponent_GameThread = FTransform::Identity;
        FTransform GizmoOriginToComponent_RenderThread = FTransform::Identity;
        // We might decide to have a render thread version of the settings as well, but it's unclear whether it's
        //  worth it, since it seems like a brief inconsistency during the update is unlikely to cause much of a
        //  problem: a user is unlikely to be changing multiple bools at once, and reading an outdated bool seems
        //  fine.
        FSettings Settings;
    };
 
    //~ TODO: May someday want a non-const version of this where the relative transform is editable, for sliders.
    class FConstantViewRelativeTransformAdjuster : public IViewBasedTransformAdjuster
    {
    public:
        FConstantViewRelativeTransformAdjuster(const FTransform& ViewRelativeTransformIn, bool bConstantSize = true)
            : ViewRelativeTransform(ViewRelativeTransformIn)
            , bKeepConstantViewSize(bConstantSize)
        {
        }
 
        // IGizmoViewTransformAdjuster
        INTERACTIVETOOLSFRAMEWORK_API virtual FTransform GetAdjustedComponentToWorld(
            const UE::GizmoRenderingUtil::ISceneViewInterface& View,
            const FTransform& CurrentComponentToWorld) override;
 
        INTERACTIVETOOLSFRAMEWORK_API virtual FBoxSphereBounds GetViewIndependentBounds(const FTransform& LocalToWorld,
            const FBoxSphereBounds& OriginalBounds) override;
    private:
        FTransform ViewRelativeTransform = FTransform::Identity;
        bool bKeepConstantViewSize = true;
    };
}