CombinedTransformGizmo.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 "CombinedTransformGizmo.generated.h"
 
class UInteractiveGizmoManager;
class IGizmoAxisSource;
class IGizmoTransformSource;
class IGizmoStateTarget;
class UGizmoConstantFrameAxisSource;
class UGizmoComponentAxisSource;
class UGizmoTransformChangeStateTarget;
class UGizmoViewContext;
class FTransformGizmoTransformChange;
namespace UE::GizmoUtil
{
    struct FTransformSubGizmoCommonParams;
    struct FTransformSubGizmoSharedState;
}
namespace UE::GizmoRenderingUtil
{
    class FSubGizmoTransformAdjuster;
}
 
UCLASS(Transient, NotPlaceable, Hidden, NotBlueprintable, NotBlueprintType, MinimalAPI)
class ACombinedTransformGizmoActor : public AGizmoActor
{
    GENERATED_BODY()
public:
 
    INTERACTIVETOOLSFRAMEWORK_API ACombinedTransformGizmoActor();
 
public:
    //
    // Translation Components
    //
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> TranslateX;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> TranslateY;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> TranslateZ;
 
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> TranslateYZ;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> TranslateXZ;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> TranslateXY;
 
    //
    // Rotation Components
    //
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> RotateX;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> RotateY;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> RotateZ;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> RotationSphere;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> FreeRotateHandle;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> FreeTranslateHandle;
 
    //
    // Scaling Components
    //
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> UniformScale;
 
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> AxisScaleX;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> AxisScaleY;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> AxisScaleZ;
 
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> PlaneScaleYZ;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> PlaneScaleXZ;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> PlaneScaleXY;
 
 
 
public:
    bool ReplaceSubGizmoComponent(ETransformGizmoSubElements Element, UPrimitiveComponent* NewComponent, 
        const FTransform& SubGizmoToGizmo, UPrimitiveComponent** ReplacedComponentOut = nullptr);
 
    static INTERACTIVETOOLSFRAMEWORK_API ACombinedTransformGizmoActor* ConstructDefault3AxisGizmo(
        UWorld* World, UGizmoViewContext* GizmoViewContext
    );
 
    static INTERACTIVETOOLSFRAMEWORK_API ACombinedTransformGizmoActor* ConstructCustom3AxisGizmo(
        UWorld* World, UGizmoViewContext* GizmoViewContext,
        ETransformGizmoSubElements Elements
    );
 
private:
    TArray<TWeakPtr<UE::GizmoRenderingUtil::FSubGizmoTransformAdjuster>> AdjustersThatMirrorOnlyInCombinedMode;
    friend class UCombinedTransformGizmo;
    
    // These store versions of the axis scale components that can be used when not using a combined gizmo,
    //  if they differ.
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> FullAxisScaleX;
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> FullAxisScaleY;
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> FullAxisScaleZ;
};
 
 
 
 
 
class FCombinedTransformGizmoActorFactory
{
public:
    FCombinedTransformGizmoActorFactory(UGizmoViewContext* GizmoViewContextIn)
        : GizmoViewContext(GizmoViewContextIn)
    {
    }
 
    ETransformGizmoSubElements EnableElements =
        ETransformGizmoSubElements::TranslateAllAxes |
        ETransformGizmoSubElements::TranslateAllPlanes |
        ETransformGizmoSubElements::RotateAllAxes |
        ETransformGizmoSubElements::ScaleAllAxes |
        ETransformGizmoSubElements::ScaleAllPlanes | 
        ETransformGizmoSubElements::ScaleUniform;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual ACombinedTransformGizmoActor* CreateNewGizmoActor(UWorld* World) const;
 
protected:
    UGizmoViewContext* GizmoViewContext = nullptr;
};
 
 
 
 
 
 
UCLASS(MinimalAPI)
class UCombinedTransformGizmoBuilder : public UInteractiveGizmoBuilder
{
    GENERATED_BODY()
 
public:
 
    FString AxisPositionBuilderIdentifier;
    FString PlanePositionBuilderIdentifier;
    FString AxisAngleBuilderIdentifier;
 
    TSharedPtr<FCombinedTransformGizmoActorFactory> GizmoActorBuilder;
 
    TFunction<void(UPrimitiveComponent*, bool)> UpdateHoverFunction;
 
    TFunction<void(UPrimitiveComponent*, EToolContextCoordinateSystem)> UpdateCoordSystemFunction;
 
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* BuildGizmo(const FToolBuilderState& SceneState) const override;
};
 
 
struct FToolContextOptionalToggle
{
    bool bEnabledDirectly = false;
    bool bEnabledInContext = false;
    bool bInheritFromContext = false;
 
    FToolContextOptionalToggle() {}
    FToolContextOptionalToggle(bool bEnabled, bool bSetInheritFromContext)
    {
        bEnabledDirectly = bEnabled;
        bInheritFromContext = bSetInheritFromContext;
    }
 
    void UpdateContextValue(bool bNewValue) { bEnabledInContext = bNewValue; }
    bool InheritFromContext() const { return bInheritFromContext; }
 
    bool IsEnabled() const { return (bInheritFromContext) ? bEnabledInContext : bEnabledDirectly; }
};
 
 
UCLASS(MinimalAPI)
class UCombinedTransformGizmo : public UInteractiveGizmo
{
    GENERATED_BODY()
 
public:
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetWorld(UWorld* World);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetGizmoActorBuilder(TSharedPtr<FCombinedTransformGizmoActorFactory> Builder);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetSubGizmoBuilderIdentifiers(FString AxisPositionBuilderIdentifier, FString PlanePositionBuilderIdentifier, FString AxisAngleBuilderIdentifier);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetUpdateHoverFunction(TFunction<void(UPrimitiveComponent*, bool)> HoverFunction);
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetUpdateCoordSystemFunction(TFunction<void(UPrimitiveComponent*, EToolContextCoordinateSystem)> CoordSysFunction);
    
    INTERACTIVETOOLSFRAMEWORK_API bool SetSubGizmoComponent(ETransformGizmoSubElements Element, UPrimitiveComponent* Component, 
        const FTransform& SubGizmoToGizmo);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetWorldAlignmentFunctions(
        TUniqueFunction<bool()>&& ShouldAlignDestination,
        TUniqueFunction<bool(const FRay&, FVector&)>&& DestinationAlignmentRayCaster
        );
 
    INTERACTIVETOOLSFRAMEWORK_API void SetCustomTranslationDeltaFunctions(
        TFunction<bool(double AxisDelta, double& SnappedDelta)> XAxis,
        TFunction<bool(double AxisDelta, double& SnappedDelta)> YAxis,
        TFunction<bool(double AxisDelta, double& SnappedDelta)> ZAxis);
    INTERACTIVETOOLSFRAMEWORK_API void SetCustomRotationDeltaFunctions(
        TFunction<bool(double AxisDelta, double& SnappedDelta)> XAxis,
        TFunction<bool(double AxisDelta, double& SnappedDelta)> YAxis,
        TFunction<bool(double AxisDelta, double& SnappedDelta)> ZAxis);
    INTERACTIVETOOLSFRAMEWORK_API void SetCustomScaleDeltaFunctions(
        TFunction<bool(double AxisDelta, double& SnappedDelta)> XAxis,
        TFunction<bool(double AxisDelta, double& SnappedDelta)> YAxis,
        TFunction<bool(double AxisDelta, double& SnappedDelta)> ZAxis);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetIsNonUniformScaleAllowedFunction(
        TUniqueFunction<bool()>&& IsNonUniformScaleAllowed
    );
 
    virtual bool IsNonUniformScaleAllowed() const { return IsNonUniformScaleAllowedFunc(); }
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetDisallowNegativeScaling(bool bDisallow);
    //~ TODO: Should the above affect uniform scaling too?
 
    // UInteractiveGizmo overrides
    INTERACTIVETOOLSFRAMEWORK_API virtual void Setup() override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void Shutdown() override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void Tick(float DeltaTime) override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetActiveTarget(UTransformProxy* Target, IToolContextTransactionProvider* TransactionProvider = nullptr);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void ClearActiveTarget();
 
    UPROPERTY()
    TObjectPtr<UTransformProxy> ActiveTarget;
 
    ACombinedTransformGizmoActor* GetGizmoActor() const { return GizmoActor.Get(); }
 
    INTERACTIVETOOLSFRAMEWORK_API FTransform GetGizmoTransform() const;
 
    INTERACTIVETOOLSFRAMEWORK_API void ReinitializeGizmoTransform(const FTransform& NewTransform, bool bKeepGizmoUnscaled = true);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetNewGizmoTransform(const FTransform& NewTransform, bool bKeepGizmoUnscaled = true);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void BeginTransformEditSequence();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void EndTransformEditSequence();
 
    INTERACTIVETOOLSFRAMEWORK_API void UpdateTransformDuringEditSequence(const FTransform& NewTransform, bool bKeepGizmoUnscaled = true);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetNewChildScale(const FVector& NewChildScale);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetVisibility(bool bVisible);
 
    virtual bool IsVisible()
    {
        return IsValid(GizmoActor) && !GizmoActor->IsHidden();
    }
 
    UPROPERTY()
    bool bSnapToWorldGrid = true;
 
    FToolContextOptionalToggle RelativeTranslationSnapping = FToolContextOptionalToggle(true, true);
 
    UPROPERTY()
    bool bGridSizeIsExplicit = false;
    UPROPERTY()
    FVector ExplicitGridSize;
 
    UPROPERTY()
    bool bRotationGridSizeIsExplicit = false;
    UPROPERTY()
    FRotator ExplicitRotationGridSize;
 
    UPROPERTY()
    bool bSnapToWorldRotGrid = true;
 
    UPROPERTY()
    bool bSnapToScaleGrid = true;
 
 
    UPROPERTY()
    bool bUseContextCoordinateSystem = true;
 
    UPROPERTY()
    EToolContextCoordinateSystem CurrentCoordinateSystem = EToolContextCoordinateSystem::Local;
 
 
 
 
    UPROPERTY()
    bool bUseContextGizmoMode = true;
 
    UPROPERTY()
    EToolContextTransformGizmoMode ActiveGizmoMode = EToolContextTransformGizmoMode::Combined;
 
    INTERACTIVETOOLSFRAMEWORK_API ETransformGizmoSubElements GetGizmoElements();
 
 
    INTERACTIVETOOLSFRAMEWORK_API void SetDisplaySpaceTransform(TOptional<FTransform> TransformIn);
    const TOptional<FTransform>& GetDisplaySpaceTransform() { return DisplaySpaceTransform; }
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnDisplaySpaceTransformChanged, UCombinedTransformGizmo*, TOptional<FTransform>);
    FOnDisplaySpaceTransformChanged OnDisplaySpaceTransformChanged;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnSetActiveTarget, UCombinedTransformGizmo*, UTransformProxy*);
    FOnSetActiveTarget OnSetActiveTarget;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnClearActiveTarget, UCombinedTransformGizmo*, UTransformProxy*);
    FOnClearActiveTarget OnAboutToClearActiveTarget;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnVisibilityChanged, UCombinedTransformGizmo*, bool);
    FOnVisibilityChanged OnVisibilityChanged;
 
protected:
    TSharedPtr<FCombinedTransformGizmoActorFactory> GizmoActorBuilder;
 
    FString AxisPositionBuilderIdentifier;
    FString PlanePositionBuilderIdentifier;
    FString AxisAngleBuilderIdentifier;
 
    // 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;
 
    UPROPERTY()
    TArray<TObjectPtr<UPrimitiveComponent>> ActiveComponents;
 
    UPROPERTY()
    TArray<TObjectPtr<UInteractiveGizmo>> ActiveGizmos;
 
    struct FSubGizmoInfo
    {
        // note: either of these may be invalid
        TWeakObjectPtr<UPrimitiveComponent> Component;
        TWeakObjectPtr<UInteractiveGizmo> Gizmo;
    };
    TArray<FSubGizmoInfo> TranslationSubGizmos;
    TArray<FSubGizmoInfo> RotationSubGizmos;
    TArray<FSubGizmoInfo> UniformScaleSubGizmos;
    TArray<FSubGizmoInfo> NonUniformScaleSubGizmos;
private:
    TWeakObjectPtr<UInteractiveGizmo> AxisScaleXGizmo;
    TWeakObjectPtr<UInteractiveGizmo> AxisScaleYGizmo;
    TWeakObjectPtr<UInteractiveGizmo> AxisScaleZGizmo;
 
    TFunction<bool(double AxisDelta, double& SnappedDelta)> CustomTranslationDeltaConstraintFunctions[3];
    TFunction<bool(double AxisDelta, double& SnappedDelta)> CustomRotationDeltaConstraintFunctions[3];
    TFunction<bool(double AxisDelta, double& SnappedDelta)> CustomScaleDeltaConstraintFunctions[3];
 
protected:
    UWorld* World;
 
    UPROPERTY()
    TObjectPtr<ACombinedTransformGizmoActor> GizmoActor;
 
    //
    // Axis Sources
    //
 
 
    UPROPERTY()
    TObjectPtr<UGizmoConstantFrameAxisSource> CameraAxisSource;
 
    // internal function that updates CameraAxisSource by getting current view state from GizmoManager
    INTERACTIVETOOLSFRAMEWORK_API void UpdateCameraAxisSource();
 
 
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> AxisXSource;
 
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> AxisYSource;
 
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> AxisZSource;
 
    //
    // Scaling support. 
    // UE Components only support scaling in local coordinates, so we have to create separate sources for that.
    //
 
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> UnitAxisXSource;
 
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> UnitAxisYSource;
 
    UPROPERTY()
    TObjectPtr<UGizmoComponentAxisSource> UnitAxisZSource;
 
 
    //
    // Other Gizmo Components
    //
 
 
    UPROPERTY()
    TObjectPtr<UGizmoTransformChangeStateTarget> StateTarget;
 
    TUniqueFunction<bool()> ShouldAlignDestination = []() { return false; };
    TUniqueFunction<bool(const FRay&, FVector&)> DestinationAlignmentRayCaster = [](const FRay&, FVector&) {return false; };
 
    TUniqueFunction<bool()> IsNonUniformScaleAllowedFunc = [this]() { return CurrentCoordinateSystem == EToolContextCoordinateSystem::Local; };
 
    bool bDisallowNegativeScaling = false;
 
    // See comment for SetDisplaySpaceTransform;
    TOptional<FTransform> DisplaySpaceTransform;
 
protected:
 
    using FTransformSubGizmoCommonParams = UE::GizmoUtil::FTransformSubGizmoCommonParams;
    using FTransformSubGizmoSharedState = UE::GizmoUtil::FTransformSubGizmoSharedState;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddAxisTranslationGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddPlaneTranslationGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddAxisRotationGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddAxisScaleGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddPlaneScaleGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddUniformScaleGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddFreeTranslationGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddFreeRotationGizmo(
        FTransformSubGizmoCommonParams& Params, FTransformSubGizmoSharedState& SharedState);
 
    // Axis and Plane TransformSources use these function to execute snapping queries
    INTERACTIVETOOLSFRAMEWORK_API bool PositionSnapFunction(const FVector& WorldPosition, FVector& SnappedPositionOut) const;
    INTERACTIVETOOLSFRAMEWORK_API bool PositionAxisDeltaSnapFunction(double AxisDelta, double& SnappedDeltaOut, int AxisIndex) const;
    INTERACTIVETOOLSFRAMEWORK_API FQuat RotationSnapFunction(const FQuat& DeltaRotation) const;
    INTERACTIVETOOLSFRAMEWORK_API bool RotationAxisAngleSnapFunction(double AxisAngleDelta, double& SnappedAxisAngleDeltaOut, int AxisIndex) const;
    
private:
    // Used for scale delta snapping. Calls out to the non-axis endpoint by default
    bool ScaleAxisDeltaSnapFunction(double ScaleAxisDelta, double& SnappedAxisScaleDeltaOut, int AxisIndex) const;
protected:
    // currently not implemented because WorldGridSnapping currently has no affect on scale/scale-snapping
    INTERACTIVETOOLSFRAMEWORK_API bool ScaleSnapFunction(double DeltaScale) const;
    // Used for uniform scale delta snapping
    INTERACTIVETOOLSFRAMEWORK_API bool ScaleAxisDeltaSnapFunction(double ScaleAxisDelta, double & SnappedAxisScaleDeltaOut) const;
 
    UE_DEPRECATED(5.5, "Use FTransformSubGizmoCommonParams overload instead.")
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddAxisTranslationGizmo(
        UPrimitiveComponent* AxisComponent, USceneComponent* RootComponent,
        IGizmoAxisSource* AxisSource,
        IGizmoTransformSource* TransformSource,
        IGizmoStateTarget* StateTarget,
        int AxisIndex);
    UE_DEPRECATED(5.5, "Use FTransformSubGizmoCommonParams overload instead.")
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddPlaneTranslationGizmo(
        UPrimitiveComponent* AxisComponent, USceneComponent* RootComponent,
        IGizmoAxisSource* AxisSource,
        IGizmoTransformSource* TransformSource,
        IGizmoStateTarget* StateTarget,
        int XAxisIndex, int YAxisIndex);
    UE_DEPRECATED(5.5, "Use FTransformSubGizmoCommonParams overload instead.")
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddAxisRotationGizmo(
        UPrimitiveComponent* AxisComponent, USceneComponent* RootComponent,
        IGizmoAxisSource* AxisSource,
        IGizmoTransformSource* TransformSource,
        IGizmoStateTarget* StateTarget);
    UE_DEPRECATED(5.5, "Use FTransformSubGizmoCommonParams overload instead.")
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddAxisScaleGizmo(
        UPrimitiveComponent* AxisComponent, USceneComponent* RootComponent,
        IGizmoAxisSource* GizmoAxisSource, IGizmoAxisSource* ParameterAxisSource,
        IGizmoTransformSource* TransformSource,
        IGizmoStateTarget* StateTarget);
    UE_DEPRECATED(5.5, "Use FTransformSubGizmoCommonParams overload instead.")
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddPlaneScaleGizmo(
        UPrimitiveComponent* AxisComponent, USceneComponent* RootComponent,
        IGizmoAxisSource* GizmoAxisSource, IGizmoAxisSource* ParameterAxisSource,
        IGizmoTransformSource* TransformSource,
        IGizmoStateTarget* StateTarget);
    UE_DEPRECATED(5.5, "Use FTransformSubGizmoCommonParams overload instead.")
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveGizmo* AddUniformScaleGizmo(
        UPrimitiveComponent* ScaleComponent, USceneComponent* RootComponent,
        IGizmoAxisSource* GizmoAxisSource, IGizmoAxisSource* ParameterAxisSource,
        IGizmoTransformSource* TransformSource,
        IGizmoStateTarget* StateTarget);
 
    // Useful for reinitializing components after SetActiveTarget, or for use by derived classes.
    TUniquePtr<FTransformSubGizmoSharedState> SubGizmoSharedState;
private:
    // Here to support subgizmo reinitialization after SetActiveTarget has been called. Private
    // instead of protected for now in case we change the approach here.
    IToolContextTransactionProvider* TransactionProviderAtLastSetActiveTarget = nullptr;
 
    EToolContextTransformGizmoMode PreviousActiveGizmoMode = EToolContextTransformGizmoMode::Combined;
    void ApplyGizmoActiveMode();
};