PlanePositionGizmo.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "BaseBehaviors/BehaviorTargetInterfaces.h"
#include "BaseGizmos/GizmoComponents.h"
#include "CoreMinimal.h"
#include "InputState.h"
#include "InteractiveGizmo.h"
#include "InteractiveGizmoBuilder.h"
#include "Math/MathFwd.h"
#include "Math/Ray.h"
#include "Math/Vector.h"
#include "Math/Vector2D.h"
#include "Templates/Function.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/ScriptInterface.h"
#include "UObject/UObjectGlobals.h"
 
#include "PlanePositionGizmo.generated.h"
 
class IGizmoAxisSource;
class IGizmoClickTarget;
class IGizmoStateTarget;
class IGizmoVec2ParameterSource;
class UClickDragInputBehavior;
class UObject;
struct FToolBuilderState;
namespace UE::GizmoUtil
{
    struct FTransformSubGizmoCommonParams;
    struct FTransformSubGizmoSharedState;
}
 
UCLASS(MinimalAPI)
class UPlanePositionGizmoBuilder : public UInteractiveGizmoBuilder
{
    GENERATED_BODY()
 
public:
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* BuildGizmo(const FToolBuilderState& SceneState) const override;
};
 
 
UCLASS(MinimalAPI)
class UPlanePositionGizmo : public UInteractiveGizmo, public IClickDragBehaviorTarget, public IHoverBehaviorTarget
{
    GENERATED_BODY()
 
public:
    INTERACTIVETOOLSFRAMEWORK_API bool InitializeAsTranslateGizmo(
        const UE::GizmoUtil::FTransformSubGizmoCommonParams& InitializationParams,
        UE::GizmoUtil::FTransformSubGizmoSharedState* SharedState);
    
    INTERACTIVETOOLSFRAMEWORK_API bool InitializeAsScaleGizmo(
        const UE::GizmoUtil::FTransformSubGizmoCommonParams& InitializationParams,
        bool bDisallowNegativeScaling,
        UE::GizmoUtil::FTransformSubGizmoSharedState* SharedState);
 
    bool InitializeAsUniformScaleGizmo(
        const UE::GizmoUtil::FTransformSubGizmoCommonParams& Params,
        bool bDisallowNegativeScaling,
        UE::GizmoUtil::FTransformSubGizmoSharedState* SharedState);
    
    // UInteractiveGizmo overrides
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Setup() override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void Tick(float DeltaTime) override;
 
    // IClickDragBehaviorTarget implementation
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputRayHit CanBeginClickDragSequence(const FInputDeviceRay& PressPos) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void OnClickPress(const FInputDeviceRay& PressPos) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void OnClickDrag(const FInputDeviceRay& DragPos) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void OnClickRelease(const FInputDeviceRay& ReleasePos) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void OnTerminateDragSequence() override;
 
    // IHoverBehaviorTarget implementation
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputRayHit BeginHoverSequenceHitTest(const FInputDeviceRay& PressPos) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void OnBeginHover(const FInputDeviceRay& DevicePos) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual bool OnUpdateHover(const FInputDeviceRay& DevicePos) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void OnEndHover() override;
 
public:
    // The below properties can be manipulated for more fine-grained control, but typically it is sufficient
    // to use one of the initialization methods above.
 
    UPROPERTY()
    TScriptInterface<IGizmoAxisSource> AxisSource;
 
    UPROPERTY()
    TScriptInterface<IGizmoVec2ParameterSource> ParameterSource;
    
    UPROPERTY()
    TScriptInterface<IGizmoClickTarget> HitTarget;
 
    UPROPERTY()
    TScriptInterface<IGizmoStateTarget> StateTarget;
 
    UPROPERTY()
    TObjectPtr<UClickDragInputBehavior> MouseBehavior;
 
public:
    UPROPERTY()
    bool bEnableSignedAxis = false;
 
    UPROPERTY()
    bool bFlipX = false;
 
    UPROPERTY()
    bool bFlipY = false;
 
    TUniqueFunction<bool()> ShouldUseCustomDestinationFunc = []() {return false; };
 
    struct FCustomDestinationParams
    {
        // Right now we use the custom destination function for aligning to items in the scene, which
        // we just need the world ray for. If we want to use functions that use other inputs as the
        // basis for the destination, we would add those parameters here and would make sure that the 
        // gizmo passes them in.
        const FRay* WorldRay = nullptr;
    };
 
    TUniqueFunction<bool(const FCustomDestinationParams& WorldRay, FVector& OutputPoint)> CustomDestinationFunc =
        [](const FCustomDestinationParams& Params, FVector& OutputPoint) { return false; };
 
public:
    UPROPERTY()
    bool bInInteraction = false;
 
 
    //
    // The values below are used in the context of a single click-drag interaction, ie if bInInteraction = true
    // They otherwise should be considered uninitialized
    //
 
    UPROPERTY()
    FVector InteractionOrigin;
 
    UPROPERTY()
    FVector InteractionNormal;
 
    UPROPERTY()
    FVector InteractionAxisX;
 
    UPROPERTY()
    FVector InteractionAxisY;
 
 
    UPROPERTY()
    FVector InteractionStartPoint;
 
    UPROPERTY()
    FVector InteractionCurPoint;
 
    UPROPERTY()
    FVector2D InteractionStartParameter;
 
    UPROPERTY()
    FVector2D InteractionCurParameter;
 
    UPROPERTY()
    FVector2D ParameterSigns = FVector2D(1, 1);
 
protected:
    FVector LastHitPosition;
    FVector2D InitialTargetParameter;
 
    FVector2D InteractionStartOriginParameterOffset;
    FInputDeviceRay LastInputRay = FInputDeviceRay(FRay());
 
    // Helper that can hold some extra upkeep to do during Tick (used to
    //  update a camera axis source if needed).
    TUniqueFunction<void(float DeltaTime)> CustomTickFunction;
};