CoordSystem

CoordSystem

#Overview

name: CoordSystem

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 35 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of CoordSystem is to represent the coordinate system used for transformations and manipulations in the Unreal Engine editor and tools. It is primarily used in the context of gizmos, which are visual tools for manipulating objects in 3D space.

CoordSystem is an enumeration that typically includes values such as COORD_World (for world-space coordinates) and COORD_Local (for local-space coordinates). It is used across various subsystems and modules in Unreal Engine, particularly in:

  1. Editor modules: Such as LevelEditor, UnrealEd, and Persona.
  2. Viewport interaction systems: Including ViewportInteraction and EditorViewport.
  3. Gizmo and transformation tools: Like CombinedTransformGizmo and IntervalGizmo.
  4. Animation and skeletal mesh editing tools: As seen in the SkeletonSelectionEditMode.

The value of CoordSystem is typically set through user interaction in the editor, such as toggling between world and local space in the viewport. It can be accessed and modified through the EditorModeManager (FEditorModeTools class).

CoordSystem often interacts with other variables related to transformation and manipulation, such as WidgetMode (which determines the type of transformation: translate, rotate, or scale) and CurrentAxis (which specifies which axis is being manipulated).

Developers should be aware that the coordinate system affects how transformations are applied to objects. Operations in world space will be relative to the global coordinate system, while operations in local space will be relative to the object’s own coordinate system.

Best practices when using CoordSystem include:

  1. Always check the current coordinate system before applying transformations.
  2. Provide users with clear visual feedback about the current coordinate system.
  3. Ensure that all relevant components and subsystems are updated when the coordinate system changes.
  4. Consider the implications of coordinate system changes on snapping, grid alignment, and other precision-focused features.
  5. When implementing new tools or gizmos, make sure they respect and properly handle different coordinate systems.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEditorPerProjectUserSettings.ini:497, section: [FEditorModeTools]

#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:421

Scope (from outer to inner):

file
function     void FControlRigEditMode::Enter

Source code excerpt:

		{
			CoordSystemPerWidgetMode.SetNum(UE::Widget::WM_Max);
			ECoordSystem CoordSystem = ModeManager->GetCoordSystem();
			for (int32 i = 0; i < UE::Widget::WM_Max; ++i)
			{
				CoordSystemPerWidgetMode[i] = CoordSystem;
			}
		}

		ModeManager->OnWidgetModeChanged().AddSP(this, &FControlRigEditMode::OnWidgetModeChanged);
		ModeManager->OnCoordSystemChanged().AddSP(this, &FControlRigEditMode::OnCoordSystemChanged);
	}

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

Scope (from outer to inner):

file
function     bool FControlRigEditMode::InputDelta

Source code excerpt:

	const UE::Widget::EWidgetMode WidgetMode = InViewportClient->GetWidgetMode();
	const EAxisList::Type CurrentAxis = InViewportClient->GetCurrentWidgetAxis();
	const ECoordSystem CoordSystem = InViewportClient->GetWidgetCoordSystemSpace();

	const bool bDoRotation = !Rot.IsZero() && (WidgetMode == UE::Widget::WM_Rotate || WidgetMode == UE::Widget::WM_TranslateRotateZ);
	const bool bDoTranslation = !Drag.IsZero() && (WidgetMode == UE::Widget::WM_Translate || WidgetMode == UE::Widget::WM_TranslateRotateZ);
	const bool bDoScale = !Scale.IsZero() && WidgetMode == UE::Widget::WM_Scale;

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

Scope (from outer to inner):

file
function     bool FControlRigEditMode::InputDelta

Source code excerpt:

				{
					const UControlRigEditModeSettings* Settings = GetDefault<UControlRigEditModeSettings>();
					bool bDoLocal = (CoordSystem == ECoordSystem::COORD_Local && Settings && Settings->bLocalTransformsInEachLocalSpace);
					bool bUseLocal = false;
					bool bCalcLocal = bDoLocal;
					bool bFirstTime = true;
					FTransform InOutLocal = FTransform::Identity;
					
					bool const bJustStartedManipulation = !bManipulatorMadeChange;

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

Scope (from outer to inner):

file
function     void FControlRigEditMode::OnCoordSystemChanged

Source code excerpt:

	FEditorModeTools* ModeManager = GetModeManager();
	int32 WidgetMode = (int32)ModeManager->GetWidgetMode();
	ECoordSystem CoordSystem = ModeManager->GetCoordSystem();
	if (WidgetMode >= 0 && WidgetMode < CoordSystemPerWidgetMode.Num())
	{
		CoordSystemPerWidgetMode[WidgetMode] = CoordSystem;
	}
}

bool FControlRigEditMode::CanChangeControlShapeTransform()
{
	if (AreEditingControlRigDirectly())

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithFBXImporter/Source/DatasmithFBXTranslator/Private/DatasmithFBXFileImporter.cpp:296

Scope (from outer to inner):

file
function     void FDatasmithFBXFileImporter::ConvertCoordinateSystem

Source code excerpt:

	// you want +X facing in engine. Only thing that doesn't work is hand flipping because Max/Maya is RHS but UE is LHS
	// On the positive note, we now have import transform set up you can do to rotate mesh if you don't like default setting.
	FbxAxisSystem::ECoordSystem CoordSystem = FbxAxisSystem::eRightHanded;
	FbxAxisSystem::EUpVector UpVector = FbxAxisSystem::eZAxis;
	FbxAxisSystem::EFrontVector FrontVector = (FbxAxisSystem::EFrontVector) - FbxAxisSystem::eParityOdd;

	FbxAxisSystem UnrealImportAxis(UpVector, FrontVector, CoordSystem);
	FbxAxisSystem SourceSetup = InScene->GetGlobalSettings().GetAxisSystem();

#Loc: <Workspace>/Engine/Plugins/Experimental/XRCreativeFramework/Source/XRCreative/Private/ITF/XRCreativeITFComponent.cpp:935

Scope (from outer to inner):

file
function     void UXRCreativeITFComponent::SetCurrentCoordinateSystem

Source code excerpt:



void UXRCreativeITFComponent::SetCurrentCoordinateSystem(EToolContextCoordinateSystem CoordSystem)
{
	if(IsValid(GetSelectionSet()))
	{
		CurrentCoordinateSystem = CoordSystem; 
		TransformInteraction->ForceUpdateGizmoState();	
	}

}

#Loc: <Workspace>/Engine/Plugins/Experimental/XRCreativeFramework/Source/XRCreative/Public/XRCreativeITFComponent.h:83

Scope (from outer to inner):

file
class        class UXRCreativeITFComponent : public UActorComponent

Source code excerpt:


	UFUNCTION(BlueprintCallable, Category="XR Creative|Tools")
	void SetCurrentCoordinateSystem(EToolContextCoordinateSystem CoordSystem);


	UFUNCTION(BlueprintCallable, Category="XR Creative|Tools")
	EToolContextTransformGizmoMode GetCurrentTransformGizmoMode() const { return CurrentTransformGizmoMode; }

	UFUNCTION(BlueprintCallable, Category="XR Creative|Tools")

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Parsers/Fbx/Private/FbxConvert.cpp:52

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private
function     void FFbxConvert::ConvertScene

Source code excerpt:

					FbxAxisSystem::EUpVector UpVector = FbxAxisSystem::EUpVector::eZAxis;
					FbxAxisSystem::EFrontVector FrontVector = (FbxAxisSystem::EFrontVector)(bForceFrontXAxis ? FbxAxisSystem::eParityEven : -FbxAxisSystem::eParityOdd);
					FbxAxisSystem::ECoordSystem CoordSystem = FbxAxisSystem::ECoordSystem::eRightHanded;
					FbxAxisSystem UnrealImportAxis(UpVector, FrontVector, CoordSystem);

					if (FileAxisSystem != UnrealImportAxis)
					{
						FbxRootNodeUtility::RemoveAllFbxRoots(SDKScene);
						UnrealImportAxis.ConvertScene(SDKScene);

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponents/Private/Transforms/MultiTransformer.cpp:45

Scope (from outer to inner):

file
function     void UMultiTransformer::SetOverrideGizmoCoordinateSystem

Source code excerpt:



void UMultiTransformer::SetOverrideGizmoCoordinateSystem(EToolContextCoordinateSystem CoordSystem)
{
	if (GizmoCoordSystem != CoordSystem || bForceGizmoCoordSystem == false)
	{
		bForceGizmoCoordSystem = true;
		GizmoCoordSystem = CoordSystem;
		if (TransformGizmo != nullptr)
		{
			UpdateShowGizmoState(false);
			UpdateShowGizmoState(true);
		}
	}

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponents/Public/Transforms/MultiTransformer.h:54

Scope (from outer to inner):

file
class        class UMultiTransformer : public UObject

Source code excerpt:

	virtual void SetGizmoVisibility(bool bVisible);

	virtual void SetOverrideGizmoCoordinateSystem(EToolContextCoordinateSystem CoordSystem);

	virtual void SetEnabledGizmoSubElements(ETransformGizmoSubElements EnabledSubElements);

	virtual void SetGizmoRepositionable(bool bOn);

	virtual EToolContextCoordinateSystem GetGizmoCoordinateSystem();

#Loc: <Workspace>/Engine/Plugins/Runtime/ScriptableToolsFramework/Source/ScriptableToolsFramework/Private/ScriptableInteractiveTool.cpp:900

Scope (from outer to inner):

file
function     void UScriptableInteractiveTool::CreateTRSGizmo

Source code excerpt:

	}

	NewGizmo->bUseContextCoordinateSystem = (GizmoOptions.CoordSystem == EScriptableToolGizmoCoordinateSystem::FromViewportSettings);
	switch (GizmoOptions.CoordSystem)
	{
		case EScriptableToolGizmoCoordinateSystem::Local:
			NewGizmo->CurrentCoordinateSystem = EToolContextCoordinateSystem::Local;
			break;
		case EScriptableToolGizmoCoordinateSystem::World:
			NewGizmo->CurrentCoordinateSystem = EToolContextCoordinateSystem::World;

#Loc: <Workspace>/Engine/Plugins/Runtime/ScriptableToolsFramework/Source/ScriptableToolsFramework/Public/ScriptableInteractiveTool.h:148

Scope: file

Source code excerpt:


	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gizmo)
	EScriptableToolGizmoCoordinateSystem CoordSystem = EScriptableToolGizmoCoordinateSystem::Local;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gizmo)
	bool bSnapTranslation = true;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gizmo)
	bool bSnapRotation = true;

#Loc: <Workspace>/Engine/Source/Editor/LevelEditor/Public/LevelEditorActions.h:1273

Scope (from outer to inner):

file
class        class FLevelEditorActionCallbacks

Source code excerpt:

	static bool CanSetWidgetMode( UE::Widget::EWidgetMode WidgetMode );
	static bool IsTranslateRotateModeVisible();
	static void SetCoordinateSystem( ECoordSystem CoordSystem );
	static bool IsCoordinateSystemActive( ECoordSystem CoordSystem );

	/**
	 * Return a world
	 */
	static class UWorld* GetWorld();
public:

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SkeletonSelectionEditMode.cpp:258

Scope (from outer to inner):

file
function     bool FSkeletonSelectionEditMode::InputDelta

Source code excerpt:

	const EAxisList::Type CurrentAxis = InViewportClient->GetCurrentWidgetAxis();
	const UE::Widget::EWidgetMode WidgetMode = InViewportClient->GetWidgetMode();
	const ECoordSystem CoordSystem = InViewportClient->GetWidgetCoordSystemSpace();

	bool bHandled = false;

	UDebugSkelMeshComponent* PreviewMeshComponent = GetAnimPreviewScene().GetPreviewMeshComponent();

	if ( bManipulating && CurrentAxis != EAxisList::None )

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SkeletonSelectionEditMode.cpp:347

Scope (from outer to inner):

file
function     bool FSkeletonSelectionEditMode::InputDelta

Source code excerpt:

				FVector4 BoneSpaceScaleOffset;

				if (CoordSystem == COORD_World)
				{
					BoneSpaceScaleOffset = BaseTM.TransformVector(InScale);
				}
				else
				{
					BoneSpaceScaleOffset = InScale;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/EditorModeManager.cpp:71

Scope (from outer to inner):

file
function     FEditorModeTools::FEditorModeTools

Source code excerpt:

	, bSelectionHasSceneComponent(false)
	, WidgetScale(1.0f)
	, CoordSystem(COORD_World)
	, bIsTracking(false)
{
	DefaultModeIDs.Add( FBuiltinEditorModes::EM_Default );

	InteractiveToolsContext = NewObject<UModeManagerInteractiveToolsContext>(GetTransientPackage(), UModeManagerInteractiveToolsContext::StaticClass(), NAME_None, RF_Transient);
	InteractiveToolsContext->InitializeContextWithEditorModeManager(this);

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/EditorModeManager.cpp:131

Scope (from outer to inner):

file
function     void FEditorModeTools::LoadConfig

Source code excerpt:

	static constexpr bool bGetRawValue = true;
	int32 CoordSystemAsInt = (int32)GetCoordSystem(bGetRawValue);
	GConfig->GetInt(TEXT("FEditorModeTools"),TEXT("CoordSystem"), CoordSystemAsInt,
		GEditorPerProjectIni);

	if (static_cast<ECoordSystem>(CoordSystemAsInt) == COORD_Parent)
	{
		// parent mode is only supported with new trs gizmos for now
		const bool bUseNewGizmo = UEditorInteractiveGizmoManager::UsesNewTRSGizmos();
		if (!bUseNewGizmo)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/EditorModeManager.cpp:154

Scope (from outer to inner):

file
function     void FEditorModeTools::SaveConfig

Source code excerpt:


	static constexpr bool bGetRawValue = true;
	GConfig->SetInt(TEXT("FEditorModeTools"), TEXT("CoordSystem"), (int32)GetCoordSystem(bGetRawValue), GEditorPerProjectIni);

	SaveWidgetSettings();
}

TSharedPtr<class IToolkitHost> FEditorModeTools::GetToolkitHost() const
{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/EditorModeManager.cpp:689

Scope (from outer to inner):

file
function     ECoordSystem FEditorModeTools::GetCoordSystem

Source code excerpt:

	}
	
	return CoordSystem;
}

void FEditorModeTools::SetCoordSystem(ECoordSystem NewCoordSystem)
{
	CoordSystem = NewCoordSystem;
	BroadcastCoordSystemChanged(NewCoordSystem);
}

void FEditorModeTools::SetDefaultMode( const FEditorModeID DefaultModeID )
{
	DefaultModeIDs.Reset();

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1515

Scope (from outer to inner):

file
namespace    UnFbx
function     void FFbxImporter::ConvertScene

Source code excerpt:

		// only thing that doesn't work is hand flipping because Max/Maya is RHS but UE is LHS
		// On the positive note, we now have import transform set up you can do to rotate mesh if you don't like default setting
		FbxAxisSystem::ECoordSystem CoordSystem = FbxAxisSystem::eRightHanded;
		FbxAxisSystem::EUpVector UpVector = FbxAxisSystem::eZAxis;
		FbxAxisSystem::EFrontVector FrontVector = (FbxAxisSystem::EFrontVector) - FbxAxisSystem::eParityOdd;
		if (GetImportOptions()->bForceFrontXAxis)
		{
			FrontVector = FbxAxisSystem::eParityEven;
		}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/SEditorViewport.cpp:720

Scope (from outer to inner):

file
function     bool SEditorViewport::IsCoordSystemActive

Source code excerpt:

}

bool SEditorViewport::IsCoordSystemActive(ECoordSystem CoordSystem) const
{
	return Client->GetWidgetCoordSystemSpace() == CoordSystem;
}

void SEditorViewport::OnCycleWidgetMode()
{
	UE::Widget::EWidgetMode WidgetMode = Client->GetWidgetMode();

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/EditorModeManager.h:396

Scope: file

Source code excerpt:

	
	/**
	 * Returns the current CoordSystem
	 * 
	 * @param bGetRawValue true when you want the actual value of CoordSystem, not the value modified by the state.
	 */
	UNREALED_API ECoordSystem GetCoordSystem(bool bGetRawValue = false) const;

	/** Sets the current CoordSystem */
	UNREALED_API void SetCoordSystem(ECoordSystem NewCoordSystem);

	/** Sets the hide viewport UI state */
	void SetHideViewportUI( bool bInHideViewportUI ) { bHideViewportUI = bInHideViewportUI; }

	/** Is the viewport UI hidden? */

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/EditorModeManager.h:615

Scope (from outer to inner):

file
class        class FEditorModeTools : public FGCObject, public FEditorUndoClient, public TSharedFromThis<FEditorModeTools>

Source code excerpt:


	/** The coordinate system the widget is operating within. */
	ECoordSystem CoordSystem;

	/** Multicast delegate that is broadcast when a mode is entered or exited */
	FEditorModeIDChangedEvent EditorModeIDChangedEvent;

	/** Multicast delegate that is broadcast when a widget mode is changed */
	FWidgetModeChangedEvent WidgetModeChangedEvent;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/SEditorViewport.h:72

Scope (from outer to inner):

file
class        class SEditorViewport : public SCompoundWidget

Source code excerpt:

	 * @return true if the specified coordinate system the active one active
	 */
	UNREALED_API virtual bool IsCoordSystemActive( ECoordSystem CoordSystem ) const;

	/**
	 * Cycles between world and local coordinate systems
	 */
	UNREALED_API virtual void OnCycleCoordinateSystem();

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

Scope (from outer to inner):

file
function     void UPivotRotationGizmoHandleGroup::UpdateGizmoHandleGroup

Source code excerpt:

	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;
	const bool bShowAnyRotationHandle = (bIsTypeSupported && bSupportsCurrentCoordinateSpace && bAllHandlesVisible);

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

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/ViewportInteractionDragOperations.cpp:71

Scope (from outer to inner):

file
function     void URotateOnAngleDragOperation::ExecuteDrag

Source code excerpt:

			// Get the laser pointer intersection on the plane of the handle
			const FPlane RotationPlane = FPlane(GizmoStartTransform.GetLocation(), DraggingRotationHandleDirection.GetValue());
			const ECoordSystem CoordSystem = DraggingData.WorldInteraction->GetTransformGizmoCoordinateSpace();
			const FVector LaserImpactOnRotationPlane = FMath::LinePlaneIntersection(DraggingData.LaserPointerStart, DraggingData.LaserPointerStart + DraggingData.LaserPointerDirection, RotationPlane);

			{
				FTransform GizmoTransformNoRotation = FTransform(FRotator::ZeroRotator, GizmoStartTransform.GetLocation());
				if (CoordSystem == COORD_Local)
				{
					GizmoTransformNoRotation.SetRotation(GizmoStartTransform.GetRotation());
				}

				LocalIntersectPointOnRotationGizmo = GizmoTransformNoRotation.InverseTransformPositionNoScale(LaserImpactOnRotationPlane);
			}

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/ViewportInteractionDragOperations.cpp:90

Scope (from outer to inner):

file
function     void URotateOnAngleDragOperation::ExecuteDrag

Source code excerpt:

			const FVector GizmoSpaceLaserImpactOnRotationPlane = WorldToGizmo.TransformPosition(LaserImpactOnRotationPlane);
			FVector RotatedIntersectLocationOnPlane;
			if (CoordSystem == COORD_Local)
			{
				RotatedIntersectLocationOnPlane = GizmoSpaceFacingAxisVector.Rotation().UnrotateVector(GizmoSpaceLaserImpactOnRotationPlane);
			}
			else
			{
				RotatedIntersectLocationOnPlane = GizmoStartTransform.TransformVector(GizmoSpaceFacingAxisVector).Rotation().UnrotateVector(GizmoSpaceLaserImpactOnRotationPlane);

#Loc: <Workspace>/Engine/Source/Editor/ViewportInteraction/Private/ViewportWorldInteraction.cpp:1613

Scope (from outer to inner):

file
function     BEGIN_FUNCTION_BUILD_OPTIMIZATION void UViewportWorldInteraction::UpdateDragging

Source code excerpt:

	bool bShouldApplyVelocitiesFromDrag = false;

	const ECoordSystem CoordSystem = GetTransformGizmoCoordinateSpace();

	// Always snap objects relative to where they were when we first grabbed them.  We never want objects to immediately
	// teleport to the closest snap, but instead snaps should always be relative to the gizmo center
	// NOTE: While placing objects, we always snap in world space, since the initial position isn't really at all useful
	const bool bLocalSpaceSnapping =
		CoordSystem == COORD_Local &&
		DraggingMode != EViewportInteractionDraggingMode::TransformablesAtLaserImpact;
	const FVector SnapGridBase = ( DraggingMode == EViewportInteractionDraggingMode::TransformablesAtLaserImpact ||  bLocalSpaceSnapping ) ? FVector::ZeroVector : GizmoStartTransform.GetLocation();

	// Okay, time to move stuff!  We'll do this part differently depending on whether we're dragging actual actors around
	// or we're moving the camera (aka. dragging the world)
	if (DragOperation != nullptr && DraggingMode == EViewportInteractionDraggingMode::TransformablesWithGizmo)

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/BaseGizmos/CombinedTransformGizmo.cpp:459

Scope (from outer to inner):

file
function     void UCombinedTransformGizmo::Setup
lambda-function

Source code excerpt:

	};

	UpdateCoordSystemFunction = [](UPrimitiveComponent* Component, EToolContextCoordinateSystem CoordSystem)
	{
		if (Cast<UGizmoBaseComponent>(Component) != nullptr)
		{
			Cast<UGizmoBaseComponent>(Component)->UpdateWorldLocalState(CoordSystem == EToolContextCoordinateSystem::World);
		}
	};

	GizmoActor = GizmoActorBuilder->CreateNewGizmoActor(World);
}

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/BaseGizmos/CombinedTransformGizmo.cpp:1113

Scope (from outer to inner):

file
function     bool UCombinedTransformGizmo::PositionSnapFunction

Source code excerpt:


	// we can only snap positions in world coordinate system
	EToolContextCoordinateSystem CoordSystem = GetGizmoManager()->GetContextQueriesAPI()->GetCurrentCoordinateSystem();
	if (CoordSystem != EToolContextCoordinateSystem::World)
	{
		return false;
	}

	// need a snapping manager
	if ( USceneSnappingManager* SnapManager = USceneSnappingManager::Find(GetGizmoManager()) )

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/BaseGizmos/CombinedTransformGizmo.cpp:1148

Scope (from outer to inner):

file
function     bool UCombinedTransformGizmo::PositionAxisDeltaSnapFunction

Source code excerpt:

	if (!bSnapToWorldGrid) return false;

	EToolContextCoordinateSystem CoordSystem = GetGizmoManager()->GetContextQueriesAPI()->GetCurrentCoordinateSystem();
	bool bUseRelativeSnapping = RelativeTranslationSnapping.IsEnabled() || (CoordSystem != EToolContextCoordinateSystem::World);
	if (!bUseRelativeSnapping)
	{
		return false;
	}

	if ( USceneSnappingManager* SnapManager = USceneSnappingManager::Find(GetGizmoManager()) )

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/BaseGizmos/CombinedTransformGizmo.cpp:1199

Scope (from outer to inner):

file
function     FQuat UCombinedTransformGizmo::RotationSnapFunction

Source code excerpt:


	// can only snap absolute rotations in World coordinates
	EToolContextCoordinateSystem CoordSystem = GetGizmoManager()->GetContextQueriesAPI()->GetCurrentCoordinateSystem();
	if (CoordSystem != EToolContextCoordinateSystem::World)
	{
		return SnappedDeltaRotation;
	}

	// need a snapping manager
	if ( USceneSnappingManager* SnapManager = USceneSnappingManager::Find(GetGizmoManager()) )

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/BaseGizmos/IntervalGizmo.cpp:238

Scope (from outer to inner):

file
function     void UIntervalGizmo::Setup
lambda-function

Source code excerpt:

	};

	UpdateCoordSystemFunction = [](UPrimitiveComponent* Component, EToolContextCoordinateSystem CoordSystem)
	{
		if (Cast<UGizmoBaseComponent>(Component) != nullptr)
		{
			Cast<UGizmoBaseComponent>(Component)->UpdateWorldLocalState(CoordSystem == EToolContextCoordinateSystem::World);
		}
	};

	GizmoActor = GizmoActorBuilder->CreateNewGizmoActor(World);
}

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/BaseGizmos/IntervalGizmo.cpp:265

Scope (from outer to inner):

file
function     void UIntervalGizmo::Tick

Source code excerpt:

void UIntervalGizmo::Tick(float DeltaTime)
{
	EToolContextCoordinateSystem CoordSystem = GetGizmoManager()->GetContextQueriesAPI()->GetCurrentCoordinateSystem();
	check(CoordSystem == EToolContextCoordinateSystem::World || CoordSystem == EToolContextCoordinateSystem::Local)
		bool bUseLocalAxes =
		(GetGizmoManager()->GetContextQueriesAPI()->GetCurrentCoordinateSystem() == EToolContextCoordinateSystem::Local);

	// Update gizmo location.
	{
		USceneComponent* GizmoComponent = GizmoActor->GetRootComponent();

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/BaseGizmos/IntervalGizmo.cpp:299

Scope (from outer to inner):

file
function     void UIntervalGizmo::Tick

Source code excerpt:

		for (UPrimitiveComponent* Component : ActiveComponents)
		{
			UpdateCoordSystemFunction(Component, CoordSystem);
		}
	}
}

void UIntervalGizmo::SetActiveTarget(UTransformProxy* TransformTargetIn, UGizmoLocalFloatParameterSource* UpInterval , UGizmoLocalFloatParameterSource* DownInterval, UGizmoLocalFloatParameterSource* ForwardInterval, IToolContextTransactionProvider* TransactionProvider)
{