IntervalGizmo.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "InteractiveGizmo.h"
#include "InteractiveGizmoBuilder.h"
#include "InteractiveToolObjects.h"
#include "InteractiveToolChange.h"
#include "BaseGizmos/GizmoActor.h"
#include "BaseGizmos/TransformProxy.h"
#include "ParameterSourcesFloat.h"
#include "BoxTypes.h"
#include "IntervalGizmo.generated.h"
 
class UInteractiveGizmoManager;
class IGizmoAxisSource;
class IGizmoTransformSource;
class IGizmoStateTarget;
class UGizmoComponentAxisSource;
class IGizmoFloatParameterSource;
class UGizmoLocalFloatParameterSource;
class UGizmoViewContext;
 
 
UCLASS(Transient, NotPlaceable, Hidden, NotBlueprintable, NotBlueprintType, MinimalAPI)
class AIntervalGizmoActor : public AGizmoActor
{
    GENERATED_BODY()
public:
 
    INTERACTIVETOOLSFRAMEWORK_API AIntervalGizmoActor();
    
public:
 
    UPROPERTY()
    TObjectPtr<UGizmoLineHandleComponent> UpIntervalComponent = nullptr;
 
    UPROPERTY()
    TObjectPtr<UGizmoLineHandleComponent> DownIntervalComponent = nullptr;
 
    UPROPERTY()
    TObjectPtr<UGizmoLineHandleComponent> ForwardIntervalComponent = nullptr;
 
    UPROPERTY()
    TObjectPtr<UGizmoLineHandleComponent> BackwardIntervalComponent = nullptr;
 
    UPROPERTY()
    TObjectPtr<UGizmoLineHandleComponent> RightIntervalComponent = nullptr;
 
    UPROPERTY()
    TObjectPtr<UGizmoLineHandleComponent> LeftIntervalComponent = nullptr;
 
public:
    static INTERACTIVETOOLSFRAMEWORK_API AIntervalGizmoActor* ConstructDefaultIntervalGizmo(UWorld* World, 
        UGizmoViewContext* GizmoViewContext);
 
};
 
 
class FIntervalGizmoActorFactory
{
public:
    FIntervalGizmoActorFactory(UGizmoViewContext* GizmoViewContextIn)
        : GizmoViewContext(GizmoViewContextIn)
    {
    }
 
    virtual AIntervalGizmoActor* CreateNewGizmoActor(UWorld* World) const
    {
        return AIntervalGizmoActor::ConstructDefaultIntervalGizmo(World, GizmoViewContext);
    }
 
protected:
    UGizmoViewContext* GizmoViewContext = nullptr;
};
 
 
 
UCLASS(MinimalAPI)
class UIntervalGizmoBuilder : public UInteractiveGizmoBuilder
{
    GENERATED_BODY()
 
public:
    TSharedPtr<FIntervalGizmoActorFactory> GizmoActorBuilder;
 
    TFunction<void(UPrimitiveComponent*, bool)> UpdateHoverFunction;
 
    TFunction<void(UPrimitiveComponent*, EToolContextCoordinateSystem)> UpdateCoordSystemFunction;
 
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* BuildGizmo(const FToolBuilderState& SceneState) const override;
};
 
 
UCLASS(MinimalAPI)
class UIntervalGizmo : public UInteractiveGizmo
{
    GENERATED_BODY()
 
public:
 
    static INTERACTIVETOOLSFRAMEWORK_API FString GizmoName;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetWorld(UWorld* WorldIn);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetGizmoActorBuilder(TSharedPtr<FIntervalGizmoActorFactory> Builder);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetUpdateHoverFunction(TFunction<void(UPrimitiveComponent*, bool)> HoverFunction);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetUpdateCoordSystemFunction(TFunction<void(UPrimitiveComponent*, EToolContextCoordinateSystem)> CoordSysFunction);
 
    // UInteractiveGizmo overrides
    INTERACTIVETOOLSFRAMEWORK_API virtual void Setup() override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void Shutdown() override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void Tick(float DeltaTime) override;
 
    enum class EDefaultParameterRanges
    {
        // Init all interval ranges to [0, +/- FLT_MAX] in the axis direction
        HalfRange,
        // Init all interval ranges to [-FLT_MAX, FLT_MAX]
        FullRange,
        // Init interval ranges to 'half range' if 'matched' by the opposite interval on the same axis, or 'full range' otherwise
        HalfIfMatched
    };
 
    // Input parameter sources and related configuration
    struct FParameterSources
    {
        // +/- X axis parameter sources
        UGizmoLocalFloatParameterSource* RightInterval = nullptr;
        UGizmoLocalFloatParameterSource* LeftInterval = nullptr;
        // +/- Y axis parameter sources
        UGizmoLocalFloatParameterSource* ForwardInterval = nullptr;
        UGizmoLocalFloatParameterSource* BackwardInterval = nullptr;
        // +/- Z axis parameter sources
        UGizmoLocalFloatParameterSource* UpInterval = nullptr;
        UGizmoLocalFloatParameterSource* DownInterval = nullptr;
 
        EDefaultParameterRanges InitParameterRanges = EDefaultParameterRanges::HalfIfMatched;
        
    };
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetActiveTarget(UTransformProxy* TransformTargetIn, UGizmoLocalFloatParameterSource* UpInterval, UGizmoLocalFloatParameterSource* DownInterval, UGizmoLocalFloatParameterSource* ForwardInterval,
                                 IToolContextTransactionProvider* TransactionProvider = nullptr);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetActiveTarget(UTransformProxy* TransformTargetIn, const FParameterSources& ParameterSources,
        IToolContextTransactionProvider* TransactionProvider = nullptr);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetWorldAlignmentFunctions(
        TUniqueFunction<bool()>&& ShouldAlignDestination,
        TUniqueFunction<bool(const FRay&, FVector&)>&& DestinationAlignmentRayCaster
    );
 
    virtual void BeginEditSequence() { OnBeginIntervalGizmoEdit.Broadcast(this); }
    virtual void EndEditSequence() { OnEndIntervalGizmoEdit.Broadcast(this); }
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void ClearSources();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void ClearActiveTarget();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FTransform GetGizmoTransform() const;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetVisibility(bool bVisible);
 
    UPROPERTY()
    TObjectPtr<UGizmoTransformChangeStateTarget> StateTarget = nullptr;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnIntervalChanged, UIntervalGizmo*, const FVector&, float);
    FOnIntervalChanged OnIntervalChanged;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnBeginIntervalEdit, UIntervalGizmo*);
    FOnBeginIntervalEdit OnBeginIntervalGizmoEdit;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnEndIntervalEdit, UIntervalGizmo*);
    FOnEndIntervalEdit OnEndIntervalGizmoEdit;
protected:
 
    UPROPERTY()
    TObjectPtr<UWorld> World;
 
    UPROPERTY()
    TObjectPtr<AIntervalGizmoActor> GizmoActor = nullptr;
 
    UPROPERTY()
    TObjectPtr<UTransformProxy> TransformProxy = nullptr;
 
    UPROPERTY()
    TArray<TObjectPtr<UPrimitiveComponent>> ActiveComponents;
 
    UPROPERTY()
    TArray<TObjectPtr<UInteractiveGizmo>> ActiveGizmos;
 
    // +/- Z axis parameter sources
    UPROPERTY()
    TObjectPtr<UGizmoLocalFloatParameterSource> UpIntervalSource = nullptr;
    UPROPERTY()
    TObjectPtr<UGizmoLocalFloatParameterSource> DownIntervalSource = nullptr;
    // +/- Y axis parameter sources
    UPROPERTY()
    TObjectPtr<UGizmoLocalFloatParameterSource> ForwardIntervalSource = nullptr;
    UPROPERTY()
    TObjectPtr<UGizmoLocalFloatParameterSource> BackwardIntervalSource = nullptr;
    // +/- X axis parameter sources
    UPROPERTY()
    TObjectPtr<UGizmoLocalFloatParameterSource> RightIntervalSource = nullptr;
    UPROPERTY()
    TObjectPtr<UGizmoLocalFloatParameterSource> LeftIntervalSource = nullptr;
    
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> AxisXSource = nullptr;
    
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> AxisYSource = nullptr;
 
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> AxisZSource = nullptr;
 
protected:
    TSharedPtr<FIntervalGizmoActorFactory> GizmoActorBuilder;
 
    // This function is called on each active GizmoActor Component to update it's hover state.
    // If the Component is not a UGizmoBaseCmponent, the client needs to provide a different implementation
    // of this function via the ToolBuilder
    TFunction<void(UPrimitiveComponent*, bool)> UpdateHoverFunction;
 
    // This function is called on each active GizmoActor Component to update it's coordinate system (eg world/local).
    // If the Component is not a UGizmoBaseCmponent, the client needs to provide a different implementation
    // of this function via the ToolBuilder
    TFunction<void(UPrimitiveComponent*, EToolContextCoordinateSystem)> UpdateCoordSystemFunction;
 
    TUniqueFunction<bool()> ShouldAlignDestination = []() { return false; };
    TUniqueFunction<bool(const FRay&, FVector&)> DestinationAlignmentRayCaster = [](const FRay&, FVector&) {return false; };
protected:
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddIntervalHandleGizmo(
        USceneComponent* RootComponent,
        UPrimitiveComponent* HandleComponent, 
        IGizmoAxisSource* AxisSource,
        IGizmoFloatParameterSource* FloatParameterSource,
        float MinParameter,
        float MaxParameter,
        IGizmoStateTarget* StateTargetIn);
 
private:
 
    // Valid ranges for intervals
    UE::Geometry::FInterval1f UpIntervalRange, DownIntervalRange, ForwardIntervalRange, BackwardIntervalRange, RightIntervalRange, LeftIntervalRange;
 
    // Call IterFn on each Source/Component combination where the Source is not null. Note IterFn will still be called if the component and/or axis are null.
    void EnumerateValidIntervals(TFunctionRef<void(UGizmoLocalFloatParameterSource* Source, UGizmoLineHandleComponent* Component, UGizmoComponentAxisSource* Axis, UE::Geometry::FInterval1f& IntervalRange, FVector3d Direction, float DirectionAxisSign)> IterFn);
 
    // Call IterFn on each interval Component (including those without a Source)
    void EnumerateAllIntervals(TFunctionRef<void(UGizmoLocalFloatParameterSource* Source, UGizmoLocalFloatParameterSource* OppositeSource, UGizmoLineHandleComponent* Component, UE::Geometry::FInterval1f& IntervalRange, float DirectionAxisSign)> IterFn);
};
 
UCLASS(MinimalAPI)
class UGizmoAxisIntervalParameterSource : public UGizmoBaseFloatParameterSource
{
    GENERATED_BODY()
public:
    INTERACTIVETOOLSFRAMEWORK_API virtual float GetParameter() const override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetParameter(float NewValue) override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void BeginModify();
    
    INTERACTIVETOOLSFRAMEWORK_API virtual void EndModify();
 
 
public:
    
    UPROPERTY()
    TScriptInterface<IGizmoFloatParameterSource> FloatParameterSource;
 
public:
 
    UPROPERTY()
    float MinParameter;
 
    UPROPERTY()
    float MaxParameter;
 
public:
 
    static INTERACTIVETOOLSFRAMEWORK_API UGizmoAxisIntervalParameterSource* Construct(
        IGizmoFloatParameterSource* FloatSourceIn,
        float ParameterMin = -FLT_MAX,
        float ParameterMax = FLT_MAX,
        UObject* Outer = (UObject*)GetTransientPackage());
};