AxisPositionGizmo.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 "Templates/Function.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/ScriptInterface.h"
#include "UObject/UObjectGlobals.h"
 
#include "AxisPositionGizmo.generated.h"
 
class IGizmoAxisSource;
class IGizmoClickTarget;
class IGizmoFloatParameterSource;
class IGizmoStateTarget;
class UClickDragInputBehavior;
class UGizmoViewContext;
class UObject;
struct FToolBuilderState;
namespace UE::GizmoUtil
{
    struct FTransformSubGizmoCommonParams;
    struct FTransformSubGizmoSharedState;
}
 
UCLASS(MinimalAPI)
class UAxisPositionGizmoBuilder : public UInteractiveGizmoBuilder
{
    GENERATED_BODY()
 
public:
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* BuildGizmo(const FToolBuilderState& SceneState) const override;
};
 
 
UCLASS(MinimalAPI)
class UAxisPositionGizmo : 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);
 
    // UInteractiveGizmo overrides
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Setup() 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<IGizmoFloatParameterSource> ParameterSource;
 
    UE_DEPRECATED(5.5, "UAxisPositionGizmo does not use GizmoViewContext itself (it is used in gizmo components for hit testing).")
    UPROPERTY()
    TObjectPtr<UGizmoViewContext> GizmoViewContext;
 
    UPROPERTY()
    TScriptInterface<IGizmoClickTarget> HitTarget;
 
    UPROPERTY()
    TScriptInterface<IGizmoStateTarget> StateTarget;
 
    UPROPERTY()
    TObjectPtr<UClickDragInputBehavior> MouseBehavior;
 
 
public:
    UPROPERTY()
    bool bEnableSignedAxis = 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 (for instance, just the line parameter), 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; };
 
    bool bCustomDestinationAlignsAxisOrigin = true;
 
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 InteractionAxis;
 
    UPROPERTY()
    FVector InteractionStartPoint;
 
    UPROPERTY()
    FVector InteractionCurPoint;
 
    UPROPERTY()
    float InteractionStartParameter;
 
    UPROPERTY()
    float InteractionCurParameter;
 
    UPROPERTY()
    float ParameterSign = 1.0f;
 
protected:
    FVector LastHitPosition;
    float InitialTargetParameter;
 
    float InteractionStartAxisOriginParameterOffset = 0;
};