GizmoScale

GizmoScale

#Overview

name: GizmoScale

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 36 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of GizmoScale is to control the size of gizmo handles in various Unreal Engine 5 tools and editors, particularly in the viewport interaction and VR editing systems. It is used to scale the visual representation of transformation gizmos, which are interactive tools that allow users to manipulate objects in 3D space.

Key points about GizmoScale:

  1. Subsystems and modules: It is primarily used in the ViewportInteraction, VREditor, and ControlRigEditor modules.

  2. Value setting: The value is typically set through editor settings, such as UControlRigEditModeSettings or UVRModeSettings, and can be adjusted dynamically during runtime.

  3. Interaction with other variables: It often interacts with other scaling factors like AnimationAlpha, GizmoHoverScale, and WorldScaleFactor to determine the final size of gizmo handles.

  4. Usage considerations:

    • The scale affects the visual size of gizmo handles but not their functionality.
    • It’s important for maintaining proper proportions in different viewing contexts, especially in VR.
    • The scale may need to be adjusted based on the distance from the camera or the size of the scene.

  5. Best practices:

    • Keep the scale within reasonable bounds to ensure gizmos remain usable and visible.
    • Consider providing user options to adjust the scale for different preferences or use cases.
    • When implementing custom gizmos, follow the existing patterns for applying GizmoScale to maintain consistency across the editor.

Developers should be aware that changes to GizmoScale will affect the user experience in manipulating objects in the viewport, so it should be tuned carefully for optimal usability across different scenarios and viewing modes.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEditorSettings.ini:61, section: [/Script/VREditor.VRModeSettings]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditMode.cpp:174

Scope (from outer to inner):

file
function     FControlRigEditMode::FControlRigEditMode
lambda-function

Source code excerpt:

	bShowControlsAsOverlay = Settings->bShowControlsAsOverlay;

	Settings->GizmoScaleDelegate.AddLambda([this](float GizmoScale)
	{
		if (FEditorModeTools* ModeTools = GetModeManager())
		{
			ModeTools->SetWidgetScale(GizmoScale);
		}
	});

	CommandBindings = MakeShareable(new FUICommandList);
	BindCommands();

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditMode.cpp:439

Scope (from outer to inner):

file
function     void FControlRigEditMode::Enter

Source code excerpt:

	if (const UControlRigEditModeSettings* Settings = GetDefault<UControlRigEditModeSettings>())
	{
		GetModeManager()->SetWidgetScale(Settings->GizmoScale);
	}
}

//todo get working with Persona
static void ClearOutAnyActiveTools()
{

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditMode.cpp:2937

Scope (from outer to inner):

file
function     void FControlRigEditMode::IncreaseShapeSize

Source code excerpt:

{
	UControlRigEditModeSettings* Settings = GetMutableDefault<UControlRigEditModeSettings>();
	Settings->GizmoScale += 0.1f;
	GetModeManager()->SetWidgetScale(Settings->GizmoScale);
}

void FControlRigEditMode::DecreaseShapeSize()
{
	UControlRigEditModeSettings* Settings = GetMutableDefault<UControlRigEditModeSettings>();
	Settings->GizmoScale -= 0.1f;
	GetModeManager()->SetWidgetScale(Settings->GizmoScale);
}

void FControlRigEditMode::ResetControlShapeSize()
{
	UControlRigEditModeSettings* Settings = GetMutableDefault<UControlRigEditModeSettings>();
	GetModeManager()->SetWidgetScale(PreviousGizmoScale);

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditModeSettings.cpp:15

Scope (from outer to inner):

file
function     void UControlRigEditModeSettings::PostEditChangeProperty

Source code excerpt:

	Super::PostEditChangeProperty(PropertyChangedEvent);
#if WITH_EDITOR
	if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UControlRigEditModeSettings, GizmoScale))
	{
		GizmoScaleDelegate.Broadcast(GizmoScale);
	}
#endif
	if (PropertyChangedEvent.ChangeType != EPropertyChangeType::Interactive)
	{
		// Dragging spinboxes causes this to be called every frame so we wait until they've finished dragging before saving.
		SaveConfig();

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditModeSettings.cpp:30

Scope (from outer to inner):

file
function     void UControlRigEditModeSettings::PostEditUndo

Source code excerpt:

void UControlRigEditModeSettings::PostEditUndo()
{
	GizmoScaleDelegate.Broadcast(GizmoScale);
}
#endif

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditModeSettings.h:7

Scope: file

Source code excerpt:

#include "ControlRigEditModeSettings.generated.h"

DECLARE_MULTICAST_DELEGATE_OneParam(FGizmoScaleSet, float /* GizmoScale */);

/** Settings object used to show useful information in the details panel */
UCLASS(config=EditorPerProjectUserSettings, MinimalAPI)
class UControlRigEditModeSettings : public UObject
{
	GENERATED_BODY()

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditModeSettings.h:27

Scope (from outer to inner):

file
class        class UControlRigEditModeSettings : public UObject
function     UControlRigEditModeSettings

Source code excerpt:

		, bOnlySelectRigControls(false)
		, bLocalTransformsInEachLocalSpace(true)
		, GizmoScale(1.0f)
	{
		LastInViewportTweenWidgetLocation = FVector2D(EForceInit::ForceInitToZero);
		DrivenControlColor = FLinearColor::White * FLinearColor(FVector::OneVector * 0.8f);
	}

	// UObject interface

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/EditMode/ControlRigEditModeSettings.h:91

Scope (from outer to inner):

file
class        class UControlRigEditModeSettings : public UObject

Source code excerpt:

	/** The scale for Gizmos */
	UPROPERTY(config, EditAnywhere, Category = "Animation Settings")
	float GizmoScale;

	UPROPERTY(config)
	FVector2D LastInViewportTweenWidgetLocation;

	/** Delegate broadcasted whenever GizmoScale is modified */
	FGizmoScaleSet GizmoScaleDelegate;
};

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponents/Private/Mechanics/CollisionPrimitivesMechanic.cpp:828

Scope (from outer to inner):

file
function     void UCollisionPrimitivesMechanic::UpdateGizmoLocation
lambda-function

Source code excerpt:

	ForAllGizmos([](UCombinedTransformGizmo& Gizmo)
	{
		FVector GizmoScale{ 1.0, 1.0, 1.0 };
		Gizmo.SetNewChildScale(GizmoScale);
	});
}


void UCollisionPrimitivesMechanic::UpdateGizmoVisibility()
{

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponents/Private/Mechanics/LatticeControlPointsMechanic.cpp:491

Scope (from outer to inner):

file
function     void ULatticeControlPointsMechanic::UpdateGizmoLocation

Source code excerpt:


	// Clear the child scale
	FVector GizmoScale{ 1.0, 1.0, 1.0 };
	PointTransformGizmo->SetNewChildScale(GizmoScale);
}


void ULatticeControlPointsMechanic::UpdateGizmoVisibility()
{
	if (!PointTransformGizmo)

#Loc: <Workspace>/Engine/Source/Editor/Experimental/EditorInteractiveToolsFramework/Private/EditorGizmos/TransformGizmo.cpp:2449

Scope (from outer to inner):

file
function     float UTransformGizmo::GetWorldRadius

Source code excerpt:

{
	const float PixelToWorldScale = GizmoRenderingUtil::CalculateLocalPixelToWorldScale(GizmoViewContext, CurrentTransform.GetLocation());
	const float GizmoScale = TransformGizmoSource ? TransformGizmoSource->GetGizmoScale() : 1.0f;
	return InRadius * GetSizeCoefficient() * PixelToWorldScale * GizmoScale;
}

float UTransformGizmo::GetSizeCoefficient() const
{
	return CustomizationFunction ? CustomizationFunction().SizeCoefficient : 1.5f;
}

#Loc: <Workspace>/Engine/Source/Editor/VREditor/Private/VREditorMode.cpp:304

Scope (from outer to inner):

file
function     void UVREditorMode::BeginEntry

Source code excerpt:

			// When actually in VR, make sure the transform gizmo is big!
			SavedEditorState.TransformGizmoScale = WorldInteraction->GetTransformGizmoScale();
			WorldInteraction->SetTransformGizmoScale(GetDefault<UVRModeSettings>()->GizmoScale);
			WorldInteraction->SetShouldSuppressExistingCursor(true);
			WorldInteraction->SetInVR(true);
		}
	}

	// Switch us back to default mode and close any open sequencer windows

#Loc: <Workspace>/Engine/Source/Editor/VREditor/Public/VRModeSettings.h:67

Scope (from outer to inner):

file
class        class UVRModeSettings : public UVISettings

Source code excerpt:

	/** The size of the transform gizmo */
	UPROPERTY(EditAnywhere, config, Category = "UI Customization", meta = (ClampMin = 0.1, ClampMax = 2.0))
	float GizmoScale;

	/** The maximum time in seconds between two clicks for a double-click to register */
	UPROPERTY(EditAnywhere, config, Category = "Motion Controllers", meta = (ClampMin = 0.01, ClampMax = 1.0))
	float DoubleClickTime;

	/** The amount (between 0-1) you have to depress the Vive controller trigger to register a press */

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIGizmoHandle.cpp:112

Scope (from outer to inner):

file
function     void UGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:


void UGizmoHandleGroup::UpdateGizmoHandleGroup(const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, 
	const TArray< UActorComponent* >& HoveringOverHandles, float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
	UpdateHoverAnimation(DraggingHandle, HoveringOverHandles, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup);
}

int32 UGizmoHandleGroup::GetDraggedHandleIndex(class UStaticMeshComponent* DraggedMesh)
{

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIGizmoHandle.cpp:365

Scope (from outer to inner):

file
function     void UAxisGizmoHandleGroup::UpdateHandlesRelativeTransformOnAxis

Source code excerpt:

}

void UAxisGizmoHandleGroup::UpdateHandlesRelativeTransformOnAxis( const FTransform& HandleToCenter, const float AnimationAlpha, const float GizmoScale, const float GizmoHoverScale,
	const FVector& ViewLocation, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles )
{
	const float WorldScaleFactor = GetWorld()->GetWorldSettings()->WorldToMeters / 100.0f;

	for (int32 HandleIndex = 0; HandleIndex < Handles.Num(); ++HandleIndex)
	{

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIGizmoHandle.cpp:410

Scope (from outer to inner):

file
function     void UAxisGizmoHandleGroup::UpdateHandlesRelativeTransformOnAxis

Source code excerpt:

				GizmoSpaceFacingAxisOffset *= AnimationAlpha;

				HandleToGizmoOrigin.SetLocation( GizmoSpaceFacingAxisOffset * GizmoScale );

				// Set the final transform
				GizmoHandleMeshComponent->SetRelativeTransform( HandleToGizmoOrigin );
			
				float GizmoHandleScale = GizmoScale;

				// Make the handle bigger while hovered (but don't affect the offset -- we want it to scale about it's origin)
				GizmoHandleScale *= FMath::Lerp( 1.0f, GizmoHoverScale, Handle.HoverAlpha );
			
				GizmoHandleScale *= AnimationAlpha;
				GizmoHandleMeshComponent->SetRelativeScale3D( FVector( GizmoHandleScale ) );

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:88

Scope (from outer to inner):

file
function     void APivotTransformGizmo::UpdateGizmo

Source code excerpt:

	const double WorldSpaceDistanceToToPivot = FMath::Max(VREd::PivotGizmoMinDistanceForScaling->GetFloat(), FMath::Sqrt(FVector::DistSquared( GetActorLocation(), InViewLocation )));
	const double WorldScaleFactor = WorldInteraction->GetWorldScaleFactor();
	const double GizmoScale = (InScaleMultiplier * ((WorldSpaceDistanceToToPivot / WorldScaleFactor) * VREd::PivotGizmoDistanceScaleFactor->GetFloat())) * WorldScaleFactor;
	const bool bIsWorldSpaceGizmo = (WorldInteraction->GetTransformGizmoCoordinateSpace() == COORD_World);

	if (LastDraggingHandle != nullptr && DraggingHandle == nullptr)
	{
		AimingAtGizmoScaleAlpha = 0.0f;
	}

	double AnimatedGizmoScale = GizmoScale;
	// Only scale the gizmo down when not aiming at it for VR implementations
	if (WorldInteraction->IsInVR())
	{
		bool bIsAimingTowards = false;
		const double GizmoRadius = (GizmoScale * 350) * 0.5f;

		// Check if any interactor has a laser close to the gizmo
		for (UViewportInteractor* Interactor : WorldInteraction->GetInteractors())
		{	
			// We only want the interactor to affect the size when aiming at the gizmo if they are dragging nothing
			if (!Interactor->GetIsLaserBlocked() && Interactor->GetDraggingMode() != EViewportInteractionDraggingMode::World)

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:147

Scope (from outer to inner):

file
function     void APivotTransformGizmo::UpdateGizmo

Source code excerpt:

			bool bIsHoveringOrDraggingThisHandleGroup = false;
			
			const double Scale = HandleGroup == StretchGizmoHandleGroup ? GizmoScale : AnimatedGizmoScale;
			const float FloatScale = FloatCastChecked<float>(Scale, 1.0 / 16.0);

			HandleGroup->UpdateGizmoHandleGroup(InLocalToWorld, InLocalBounds, InViewLocation, bInAllHandlesVisible, DraggingHandle,
				InHoveringOverHandles, AnimationAlpha, FloatScale, InGizmoHoverScale, InGizmoHoverAnimationDuration, /* Out */ bIsHoveringOrDraggingThisHandleGroup);

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:183

Scope (from outer to inner):

file
function     void UPivotTranslationGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:


void UPivotTranslationGizmoHandleGroup::UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, 
	const TArray< UActorComponent* >& HoveringOverHandles, float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
	// Call parent implementation (updates hover animation)
	Super::UpdateGizmoHandleGroup( LocalToWorld, LocalBounds, ViewLocation, bAllHandlesVisible, DraggingHandle, HoveringOverHandles, AnimationAlpha,
		GizmoScale, GizmoHoverScale, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup );
	
	const float MultipliedGizmoScale = GizmoScale * VREd::PivotGizmoTranslationScaleMultiply->GetFloat();
	const float MultipliedGizmoHoverScale = GizmoHoverScale * VREd::PivotGizmoTranslationHoverScaleMultiply->GetFloat();

	UpdateHandlesRelativeTransformOnAxis( FTransform( FVector( VREd::PivotGizmoTranslationPivotOffsetX->GetFloat(), 0, 0 ) ), AnimationAlpha, MultipliedGizmoScale, MultipliedGizmoHoverScale, ViewLocation, DraggingHandle, HoveringOverHandles );
}

EGizmoHandleTypes UPivotTranslationGizmoHandleGroup::GetHandleType() const

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:218

Scope (from outer to inner):

file
function     void UPivotScaleGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:


void UPivotScaleGizmoHandleGroup::UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, 
	const TArray< UActorComponent* >& HoveringOverHandles, float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
	// Call parent implementation (updates hover animation)
	Super::UpdateGizmoHandleGroup( LocalToWorld, LocalBounds, ViewLocation,bAllHandlesVisible, DraggingHandle, HoveringOverHandles, AnimationAlpha, 
		GizmoScale, GizmoHoverScale, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup );

	UpdateHandlesRelativeTransformOnAxis( FTransform( FVector( VREd::PivotGizmoScalePivotOffsetX->GetFloat(), 0, 0 ) ), AnimationAlpha, GizmoScale, GizmoHoverScale, ViewLocation, DraggingHandle, HoveringOverHandles );
}

EGizmoHandleTypes UPivotScaleGizmoHandleGroup::GetHandleType() const
{
	return EGizmoHandleTypes::Scale;
}

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:255

Scope (from outer to inner):

file
function     void UPivotPlaneTranslationGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:


void UPivotPlaneTranslationGizmoHandleGroup::UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle,
	const TArray< UActorComponent* >& HoveringOverHandles, float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
	// Call parent implementation (updates hover animation)
	Super::UpdateGizmoHandleGroup( LocalToWorld, LocalBounds, ViewLocation, bAllHandlesVisible, DraggingHandle, HoveringOverHandles, AnimationAlpha,
		GizmoScale, GizmoHoverScale, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup );

	UpdateHandlesRelativeTransformOnAxis( FTransform( FVector( 0, VREd::PivotGizmoPlaneTranslationPivotOffsetYZ->GetFloat(), VREd::PivotGizmoPlaneTranslationPivotOffsetYZ->GetFloat() ) ), 
		AnimationAlpha, GizmoScale, GizmoHoverScale, ViewLocation, DraggingHandle, HoveringOverHandles );
}

EGizmoHandleTypes UPivotPlaneTranslationGizmoHandleGroup::GetHandleType() const
{
	return EGizmoHandleTypes::Translate;
}

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:341

Scope (from outer to inner):

file
function     void UPivotRotationGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:


void UPivotRotationGizmoHandleGroup::UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle,
	const TArray< UActorComponent* >& HoveringOverHandles, float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
	// Call parent implementation
	Super::UpdateGizmoHandleGroup(LocalToWorld, LocalBounds, ViewLocation, bAllHandlesVisible, DraggingHandle, HoveringOverHandles, AnimationAlpha,
		GizmoScale, GizmoHoverScale, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup);

	bool bShowFullRotationDragHandle = false;
	UViewportWorldInteraction* WorldInteraction = OwningTransformGizmoActor->GetOwnerWorldInteraction();
	const ECoordSystem CoordSystem = WorldInteraction->GetTransformGizmoCoordinateSpace();
	const bool bIsTypeSupported = (OwningTransformGizmoActor->GetGizmoType() == EGizmoHandleTypes::All && GetShowOnUniversalGizmo()) || GetHandleType() == OwningTransformGizmoActor->GetGizmoType();
	const bool bSupportsCurrentCoordinateSpace = SupportsWorldCoordinateSpace() || CoordSystem != COORD_World;

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:385

Scope (from outer to inner):

file
function     void UPivotRotationGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:

				RootFullRotationHandleComponent->SetWorldRotation(StartDragRotation.GetValue());	

				FullRotationHandleMeshComponent->SetRelativeTransform(FTransform(GizmoSpaceFacingAxisVector.ToOrientationQuat(), FVector::ZeroVector, FVector(GizmoScale)));

				URotateOnAngleDragOperation* DragOperation = StaticCast<URotateOnAngleDragOperation*>(GetDragOperationComponent()->GetDragOperation());
				const FVector LocalIntersectPoint = DragOperation->GetLocalIntersectPointOnRotationGizmo();

				UpdateIndicator(RootDeltaRotationIndicatorComponent, LocalIntersectPoint, FacingAxisIndex);

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.cpp:449

Scope (from outer to inner):

file
function     void UPivotRotationGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:

				}

				const float GizmoHandleScale = GizmoScale * AnimationAlpha;

				// Set the final transform
				GizmoHandleMeshComponent->SetRelativeTransform(FTransform(Rotation, FVector::ZeroVector, FVector(GizmoHandleScale)));

				// Update material
				UpdateHandleColor(FacingAxisIndex, Handle, DraggingHandle, HoveringOverHandles);

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.h:76

Scope (from outer to inner):

file
class        class UPivotTranslationGizmoHandleGroup : public UAxisGizmoHandleGroup

Source code excerpt:

	/** Updates the gizmo handles */
	virtual void UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
		float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup ) override;

	/** Gets the GizmoType for this Gizmo handle */
	virtual EGizmoHandleTypes GetHandleType() const override;
};

/**

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.h:97

Scope (from outer to inner):

file
class        class UPivotScaleGizmoHandleGroup : public UAxisGizmoHandleGroup

Source code excerpt:

	/** Updates the gizmo handles */
	virtual void UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds,  const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
		float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup ) override;

	/** Gets the GizmoType for this Gizmo handle */
	virtual EGizmoHandleTypes GetHandleType() const override;

	/** Returns true if this type of handle is allowed with world space gizmos */
	virtual bool SupportsWorldCoordinateSpace() const override;

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.h:121

Scope (from outer to inner):

file
class        class UPivotPlaneTranslationGizmoHandleGroup : public UAxisGizmoHandleGroup

Source code excerpt:

	/** Updates the gizmo handles */
	virtual void UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
		float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup ) override;

	/** Gets the GizmoType for this Gizmo handle */
	virtual EGizmoHandleTypes GetHandleType() const override;
};

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIPivotTransformGizmo.h:143

Scope (from outer to inner):

file
class        class UPivotRotationGizmoHandleGroup : public UAxisGizmoHandleGroup

Source code excerpt:

	/** Updates the gizmo handles */
	virtual void UpdateGizmoHandleGroup(const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
		float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup ) override;

	/** Gets the GizmoType for this Gizmo handle */
	virtual EGizmoHandleTypes GetHandleType() const override;

private:

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIStretchGizmoHandle.cpp:80

Scope (from outer to inner):

file
function     void UStretchGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:


void UStretchGizmoHandleGroup::UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
	float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
	// Call parent implementation (updates hover animation)
	Super::UpdateGizmoHandleGroup(LocalToWorld, LocalBounds, ViewLocation, bAllHandlesVisible, DraggingHandle, HoveringOverHandles,
		AnimationAlpha, GizmoScale, GizmoHoverScale, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup );

	for (int32 HandleIndex = 0; HandleIndex < Handles.Num(); ++HandleIndex)
	{
		FGizmoHandle& Handle = Handles[ HandleIndex ];

		UStaticMeshComponent* StretchingHandle = Handle.HandleMesh;

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIStretchGizmoHandle.cpp:95

Scope (from outer to inner):

file
function     void UStretchGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:

			const FTransformGizmoHandlePlacement HandlePlacement = MakeHandlePlacementForIndex( HandleIndex );

			float GizmoHandleScale = GizmoScale;

			const float OffsetFromSide = GizmoHandleScale *
				(0.0f +	// @todo vreditor tweak: Hard coded handle offset from side of primitive
				(1.0f - AnimationAlpha) * 10.0f);	// @todo vreditor tweak: Animation offset

			// Make the handle bigger while hovered (but don't affect the offset -- we want it to scale about it's origin)

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIStretchGizmoHandle.h:25

Scope (from outer to inner):

file
class        class UStretchGizmoHandleGroup : public UGizmoHandleGroup

Source code excerpt:

	/** Updates the Gizmo handles */
	virtual void UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
		float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup ) override;

	/** Gets the GizmoType for this Gizmo handle */
	virtual EGizmoHandleTypes GetHandleType() const override;

	/** Returns true if this type of handle is allowed with world space gizmos */
	virtual bool SupportsWorldCoordinateSpace() const override;

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIUniformScaleGizmoHandle.cpp:35

Scope (from outer to inner):

file
function     void UUniformScaleGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:


void UUniformScaleGizmoHandleGroup::UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
	float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
	// Call parent implementation (updates hover animation)
	Super::UpdateGizmoHandleGroup( LocalToWorld, LocalBounds, ViewLocation, bAllHandlesVisible, DraggingHandle, HoveringOverHandles, 
		AnimationAlpha, GizmoScale, GizmoHoverScale, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup );

	FGizmoHandle& Handle = Handles[ 0 ];
	UStaticMeshComponent* UniformScaleHandle = Handle.HandleMesh;
	if (UniformScaleHandle != nullptr)	// Can be null if no handle for this specific placement
	{
		FVector HandleRelativeLocation;

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIUniformScaleGizmoHandle.cpp:51

Scope (from outer to inner):

file
function     void UUniformScaleGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:

		}

		float GizmoHandleScale = GizmoScale;

		// Make the handle bigger while hovered (but don't affect the offset -- we want it to scale about it's origin)
		GizmoHandleScale *= FMath::Lerp( 1.0f, GizmoHoverScale, Handle.HoverAlpha );

		UniformScaleHandle->SetRelativeScale3D( FVector( GizmoHandleScale ) );

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/Gizmo/VIUniformScaleGizmoHandle.h:24

Scope (from outer to inner):

file
class        class UUniformScaleGizmoHandleGroup : public UGizmoHandleGroup

Source code excerpt:

	/** Updates the Gizmo handles */
	virtual void UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
		float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup ) override;

	/** Gets the GizmoType for this Gizmo handle */
	virtual EGizmoHandleTypes GetHandleType() const override;

	/** Sets if the pivot point is used as location for the handle */
	void SetUsePivotPointAsLocation( const bool bInUsePivotAsLocation );

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Public/VIGizmoHandle.h:54

Scope (from outer to inner):

file
class        class UGizmoHandleGroup : public USceneComponent

Source code excerpt:

	/** Updates the Gizmo handles, needs to be implemented by derived classes */
	virtual void UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, const bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles, 
		float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup );

	/** Default setting the visibility and collision for all the handles in this group */
	void UpdateVisibilityAndCollision(const EGizmoHandleTypes GizmoType, const ECoordSystem GizmoCoordinateSpace, const bool bAllHandlesVisible, const bool bAllowRotationAndScaleHandles, UActorComponent* DraggingHandle);

	class UViewportDragOperationComponent* GetDragOperationComponent();

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Public/VIGizmoHandle.h:152

Scope (from outer to inner):

file
class        class UAxisGizmoHandleGroup : public UGizmoHandleGroup

Source code excerpt:

	 * @param HandleToCenter - The offset from the center of the gizmo in roomspace
	 */
	void UpdateHandlesRelativeTransformOnAxis( const FTransform& HandleToCenter, const float AnimationAlpha, const float GizmoScale, const float GizmoHoverScale, 
		const FVector& ViewLocation, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles );
};