TransformSubGizmoUtil.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "InteractiveGizmo.h"
#include "Math/Axis.h"
#include "Math/MathFwd.h" // FTransform
#include "Misc/Optional.h"
 
struct FLinearColor;
class FText;
class IToolContextTransactionProvider;
class UCombinedTransformGizmo;
class UGizmoScaledAndUnscaledTransformSources;
class UGizmoTransformChangeStateTarget;
class UGizmoConstantFrameAxisSource;
class UGizmoComponentAxisSource;
class UObject;
class UPrimitiveComponent;
class UStaticMesh;
class UTransformProxy;
class UViewAdjustedStaticMeshGizmoComponent;
 
namespace UE::GizmoUtil
{
    struct FTransformSubGizmoCommonParams
    {
        UPrimitiveComponent* Component = nullptr;
        UTransformProxy* TransformProxy = nullptr;
        EAxis::Type Axis = EAxis::None;
 
        // If true, we use the axis of the root gizmo component. If false, we use an axis of the
        //  component itself, which is determined by its transform. Does not attempt to use shared
        //  state for axis if false.
        bool bAxisIsBasedOnRootComponent = true;
 
        // Optional parameters:
 
        // Default transaction name and provider are used if not provided. Not used if one is gotten from
        //  shared state.
        TOptional<FText> TransactionName;
        IToolContextTransactionProvider* TransactionProvider = nullptr;
 
        // Transient package is used if custom outer is not provided
        UObject* OuterForSubobjects = nullptr;
        
        // If true, the gizmo moves the parent root component rather than just its own component, like
        //  the standard TRS sub gizmos do. If false, the gizmo moves just its component, leaving the
        //  parent in place. Does not attempt to use shared state for transform source or state target
        //  if false.
        bool bManipulatesRootComponent = true;
        
        //~ The default hover behavior is to forward the hover information to the component via the
        //~  IGizmoBaseComponentInterface. We could give the user a way to place a custom hover function
        //~  like we have in deprecated initialization methods, but that is unclear to be worth it, as 
        //~  it is likely to be cleaner to implement the interface on any custom components.
        //~TFunction<void(bool)> CustomUpdateHoverFunction;
 
        // Returns the Axis parameter as an index in the range [0,2] where 0 
        // corresponds to X (or None), 1 corresponds to Y, and 2 corresponds to Z.
        int GetClampedAxisIndex() const
        {
            return (Axis == EAxis::Y) ? 1
                : (Axis == EAxis::Z) ? 2
                : 0;
        }
    };
 
    struct FTransformSubGizmoSharedState
    {
        UGizmoScaledAndUnscaledTransformSources* TransformSource = nullptr;
        UGizmoTransformChangeStateTarget* StateTarget = nullptr;
        UGizmoConstantFrameAxisSource* CameraAxisSource = nullptr;
        UGizmoComponentAxisSource* CardinalAxisSources[3] = { 0 };
        UGizmoComponentAxisSource* UnitCardinalAxisSources[3] = { 0 };
    };
 
    INTERACTIVETOOLSFRAMEWORK_API FTransform GetRotatedBasisTransform(const FTransform& TransformIn, EAxis::Type AxisToBeX);
 
    // Parameter struct for InitializeSubGizmoElementsWithMesh
    struct FInitMeshSubGizmoParams
    {
        // Required parameters:
 
        UCombinedTransformGizmo* ParentGizmo = nullptr;
        // If there are multiple elements, the same mesh will be set for all of them. This makes
        //  it easy to, for example, set all of the arrow components at once.
        ETransformGizmoSubElements Elements = ETransformGizmoSubElements::None;
        UStaticMesh* Mesh = nullptr;
        
        // Optional parameters:
 
        FTransform ComponentToGizmo = FTransform::Identity;
 
        // When true, ComponentToGizmo is adjusted such that the gizmo basis points along
        //  the relevant element axis. This allows ComponentToGizmo to be specified once
        //  for the x axis case, and be reused for the y/z axes with the proper rotation.
        bool bRotateTransformBasisBasedOnElement = true;
 
        // When true, the sub gizmo is mirrored across the gizmo origin depending on where
        //  in relation to the gizmo the camera is positioned.
        bool bMirrorBasedOnOctant = false;
 
        // Leaving this unset causes the color to be determined by axis.
        TOptional<FLinearColor> Color;
 
        // Mesh to swap in when the user is dragging the gizmo.
        UStaticMesh* SubstituteInteractionMesh = nullptr;
        // Only used when SubstituteInteractionMesh is being set
        FTransform SubstituteMeshToComponent = FTransform::Identity;
    };
 
    INTERACTIVETOOLSFRAMEWORK_API void InitializeSubGizmoElementsWithMesh(const FInitMeshSubGizmoParams& Params, 
        TArray<TPair<ETransformGizmoSubElements, UViewAdjustedStaticMeshGizmoComponent*>>* ElementComponentsOut = nullptr);
 
}