// Copyright Epic Games, Inc. All Rights Reserved.

#include "ControlRigAsset.h"

#include "EdGraph/EdGraph.h"
#include "EdGraphNode_Comment.h"
#include "Engine/SkeletalMesh.h"
#include "BlueprintActionDatabaseRegistrar.h"
#include "ControlRig.h"
#include "ControlRigBlueprintGeneratedClass.h"
#include "Graph/ControlRigGraph.h"
#include "Graph/ControlRigGraphSchema.h"
#include "UObject/ObjectSaveContext.h"
#include "UObject/UObjectGlobals.h"
#include "ControlRigObjectVersion.h"
#include "ModularRig.h"
#include "ModularRigController.h"
#include "RigVMCompiler/RigVMCompiler.h"
#include "RigVMCore/RigVMRegistry.h"
#include "Units/Execution/RigUnit_BeginExecution.h"
#include "Units/Hierarchy/RigUnit_SetBoneTransform.h"
#include "AssetRegistry/AssetRegistryModule.h"
#include "RigVMPythonUtils.h"
#include "RigVMTypeUtils.h"
#include "UObject/UObjectIterator.h"
#include "MVVM/ViewModels/ViewDensity.h"
#include "RigVMModel/Nodes/RigVMAggregateNode.h"
#include "Rigs/RigControlHierarchy.h"
#include "Settings/ControlRigSettings.h"
#include "Units/ControlRigNodeWorkflow.h"
#include "Units/Execution/RigUnit_PrepareForExecution.h"
#include "Units/Execution/RigUnit_DynamicHierarchy.h"

#include UE_INLINE_GENERATED_CPP_BY_NAME(ControlRigAsset)

#if WITH_EDITOR
#include "IControlRigEditorModule.h"
#include "Kismet2/WatchedPin.h"
#include "Kismet2/BlueprintEditorUtils.h"
#include "Editor/UnrealEdEngine.h"
#include "Editor/Transactor.h"
#include "CookOnTheSide/CookOnTheFlyServer.h"
#include "ScopedTransaction.h"
#include "Algo/Count.h"
#endif//WITH_EDITOR

#define LOCTEXT_NAMESPACE "ControlRigBlueprint"

TArray<FControlRigAssetInterfacePtr> IControlRigAssetInterface::sCurrentlyOpenedRigBlueprints;

FControlRigAssetInterfacePtr IControlRigAssetInterface::GetInterfaceOuter(const UObject* InObject)
{
	if (FRigVMAssetInterfacePtr RigVMAsset = IRigVMAssetInterface::GetInterfaceOuter(InObject))
	{
		if (RigVMAsset.GetObject()->Implements<UControlRigAssetInterface>())
		{
			return RigVMAsset.GetObject();
		}
	}
	return nullptr;
}

TArray<UClass*> IControlRigAssetInterface::FindAllImplementingClasses()
{
	TArray<UClass*> Result;
	for (TObjectIterator<UClass> ClassIterator; ClassIterator; ++ClassIterator)
	{
		if (ClassIterator->ImplementsInterface(UControlRigAssetInterface::StaticClass()))
		{
			Result.AddUnique(*ClassIterator);
		}
	}
	return Result;
}

FRigVMClient* IControlRigAssetInterface::GetRigVMClient()
{
	return GetRigVMAssetInterface()->GetRigVMClient();
}

void IControlRigAssetInterface::CommonInitialization(const FObjectInitializer& ObjectInitializer)
{
	FControlRigAssetInterfacePtr Asset = ObjectInitializer.GetObj();
#if WITH_EDITORONLY_DATA
	Asset->GetShapeLibraries().Add(UControlRigSettings::Get()->DefaultShapeLibrary);
#endif

	Asset->GetValidator() = ObjectInitializer.CreateDefaultSubobject<UControlRigValidator>(Asset.GetObject(), TEXT("ControlRigValidator"));
	Asset->GetDebugBoneRadius() = 1.f;

	Asset->GetExposesAnimatableControls() = false;

	Asset->SetHierarchy(ObjectInitializer.CreateDefaultSubobject<URigHierarchy>(Asset.GetObject(), TEXT("Hierarchy")));
	URigHierarchyController* Controller = Asset->GetHierarchy()->GetController(true);
	// give BP a chance to propagate hierarchy changes to available control rig instances
	Controller->OnModified().AddRaw(Asset.GetInterface(), &IControlRigAssetInterface::HandleHierarchyModified);

	Asset->GetRigVMAssetInterface()->IRigVMAssetInterface::CommonInitialization(ObjectInitializer);
	
	Asset->GetModularRigModel().SetOuterClientHost(Asset.GetObject());
	UModularRigController* ModularController = Asset->GetModularRigModel().GetController();
	ModularController->OnModified().AddRaw(Asset.GetInterface(), &IControlRigAssetInterface::HandleRigModulesModified);
}

IControlRigAssetInterface::IControlRigAssetInterface()
{
	ModulesRecompilationBracket = 0;
}

void IControlRigAssetInterface::OnRegeneratedClass(UClass* ClassToRegenerate, UObject* PreviousCDO)
{
	GetHierarchy()->CleanupInvalidCaches();
	PropagateHierarchyFromBPToInstances();
}

bool IControlRigAssetInterface::RequiresForceLoadMembers(UObject* InObject) const
{
	// old assets don't support preload filtering
	if (GetObject()->GetLinkerCustomVersion(FControlRigObjectVersion::GUID) < FControlRigObjectVersion::RemoveParameters)
	{
		return RequiresForceLoadMembersSuper(InObject);
	}
	
	return GetRigVMAssetInterface()->IRigVMAssetInterface::RequiresForceLoadMembers(InObject);
}

void IControlRigAssetInterface::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
	// if this is any of our external variables we need to request construction so that the rig rebuilds itself
	TArray<FRigVMGraphVariableDescription> Variables = GetRigVMAssetInterface()->GetAssetVariables();
	if(Variables.ContainsByPredicate([&PropertyChangedEvent](const FRigVMGraphVariableDescription& Variable)
	{
		return Variable.Name == PropertyChangedEvent.GetMemberPropertyName();
	}))
	{
		if(UControlRig* DebuggedControlRig = Cast<UControlRig>(GetObjectBeingDebugged()))
		{
			if(const FProperty* PropertyOnRig = DebuggedControlRig->GetClass()->FindPropertyByName(PropertyChangedEvent.MemberProperty->GetFName()))
			{
				if(PropertyOnRig->SameType(PropertyChangedEvent.MemberProperty))
				{
					UControlRig* CDO = DebuggedControlRig->GetClass()->GetDefaultObject<UControlRig>();
					const uint8* SourceMemory = PropertyOnRig->ContainerPtrToValuePtr<uint8>(CDO);
					uint8* TargetMemory = PropertyOnRig->ContainerPtrToValuePtr<uint8>(DebuggedControlRig);
					PropertyOnRig->CopyCompleteValue(TargetMemory, SourceMemory);
				}
			}
			DebuggedControlRig->RequestConstruction();
		}
	}
}

void IControlRigAssetInterface::PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent)
{
	// Propagate shape libraries
	if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == TEXT("ShapeLibraries"))
	{
		UClass* RigClass = GetRigVMAssetInterface()->GetRigVMGeneratedClass();
		UControlRig* CDO = Cast<UControlRig>(RigClass->GetDefaultObject(false /* create if needed */));

		TArray<UObject*> ArchetypeInstances;
		CDO->GetArchetypeInstances(ArchetypeInstances);
		ArchetypeInstances.Add(CDO);

		// Propagate libraries to archetypes
		for (UObject* Instance : ArchetypeInstances)
		{
			if (UControlRig* InstanceRig = Cast<UControlRig>(Instance))
			{
				InstanceRig->ShapeLibraries = GetShapeLibraries();
			}
		}
	}
}

UClass* IControlRigAssetInterface::GetControlRigClass() const
{
	return GetRigVMAssetInterface()->GetRigVMGeneratedClass();
}

bool IControlRigAssetInterface::IsModularRig() const
{
	if(const UClass* Class = GetControlRigClass())
	{
		return Class->IsChildOf(UModularRig::StaticClass());
	}
	return false;
}

UControlRig* IControlRigAssetInterface::CreateControlRig()
{
	return Cast<UControlRig>( GetRigVMAssetInterface()->CreateRigVMHostImpl());
}

USkeletalMesh* IControlRigAssetInterface::GetPreviewMesh() const
{
	DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()

#if WITH_EDITORONLY_DATA
	if (!GetPreviewSkeletalMesh().IsValid())
	{
		(void)GetPreviewSkeletalMesh().LoadSynchronous();
	}

	return GetPreviewSkeletalMesh().Get();
#else
	return nullptr;
#endif
}

bool IControlRigAssetInterface::IsControlRigModule() const
{
	return GetRigModuleSettings().Identifier.IsValid();
}

#if WITH_EDITORONLY_DATA

bool IControlRigAssetInterface::CanTurnIntoControlRigModule(bool InAutoConvertHierarchy, FString* OutErrorMessage) const
{
	if(IsControlRigModule())
	{
		if(OutErrorMessage)
		{
			static const FString Message = TEXT("This asset is already a Control Rig Module.");
			*OutErrorMessage = Message;
		}
		return false;
	}

	if (GetRigVMAssetInterface()->GetRigVMGeneratedClass()->IsChildOf<UModularRig>())
	{
		if(OutErrorMessage)
		{
			static const FString Message = TEXT("This asset is a Modular Rig.");
			*OutErrorMessage = Message;
		}
		return false;
	}

	if(GetHierarchy() == nullptr)
	{
		if(OutErrorMessage)
		{
			static const FString Message = TEXT("This asset contains no hierarchy.");
			*OutErrorMessage = Message;
		}
		return false;
	}

	const TArray<FRigElementKey> Keys = GetHierarchy()->GetAllKeys(true);
	for(const FRigElementKey& Key : Keys)
	{
		if(!InAutoConvertHierarchy)
		{
			if(Key.Type != ERigElementType::Bone &&
				Key.Type != ERigElementType::Curve &&
				Key.Type != ERigElementType::Connector)
			{
				if(OutErrorMessage)
				{
					static constexpr TCHAR Format[] = TEXT("The hierarchy contains elements other than bones (for example '%s'). Modules only allow imported bones and user authored connectors.");
					*OutErrorMessage = FString::Printf(Format, *Key.ToString());
				}
				return false;
			}

			if(Key.Type == ERigElementType::Bone)
			{
				if(GetHierarchy()->FindChecked<FRigBoneElement>(Key)->BoneType != ERigBoneType::Imported)
				{
					if(OutErrorMessage)
					{
						static constexpr TCHAR Format[] = TEXT("The hierarchy contains a user defined bone ('%s') - only imported bones are allowed.");
						*OutErrorMessage = FString::Printf(Format, *Key.ToString());
					}
					return false;
				}
			}
		}
	}
	
	return true;
}

bool IControlRigAssetInterface::TurnIntoControlRigModule(bool InAutoConvertHierarchy, FString* OutErrorMessage)
{
	if(!CanTurnIntoControlRigModule(InAutoConvertHierarchy, OutErrorMessage))
	{
		return false;
	}

	FScopedTransaction Transaction(LOCTEXT("TurnIntoControlRigModule", "Turn Rig into Module"));

	GetRigVMAssetInterface()->GetObject()->Modify();
	GetRigModuleSettings().Identifier = FRigModuleIdentifier();
	GetRigModuleSettings().Identifier.Name = GetRigVMAssetInterface()->GetObject()->GetName();

	if(GetHierarchy())
	{
		GetHierarchy()->Modify();
		URigHierarchyController* Controller = GetHierarchy()->GetController(true);

		// create a copy of this hierarchy
		URigHierarchy* CopyOfHierarchy = NewObject<URigHierarchy>(GetTransientPackage());
		CopyOfHierarchy->CopyHierarchy(GetHierarchy());

		// also create a hierarchy based on the preview mesh
		URigHierarchy* PreviewMeshHierarchy = NewObject<URigHierarchy>(GetTransientPackage());
		if(GetPreviewSkeletalMesh())
		{
			PreviewMeshHierarchy->GetController(true)->ImportBones(GetPreviewSkeletalMesh()->GetSkeleton());
			PreviewMeshHierarchy->GetController(true)->ImportSocketsFromSkeletalMesh(GetPreviewSkeletalMesh().Get(), NAME_None, false, false, false, false, false);;
		}

		// disable compilation
		{
			FRigVMBlueprintCompileScope CompileScope(GetRigVMAssetInterface());

			// remove everything from the hierarchy
			GetHierarchy()->Reset();

			const TArray<FRigElementKey> AllKeys = CopyOfHierarchy->GetAllKeys(true);
			TArray<FRigElementKey> KeysToSpawn;

			for(const FRigElementKey& Key : AllKeys)
			{
				if(Key.Type == ERigElementType::Curve)
				{
					continue;
				}
				if(Key.Type == ERigElementType::Bone)
				{
					if(PreviewMeshHierarchy->Contains(Key))
					{
						continue;
					}
				}
				if(Key.Type == ERigElementType::Null)
				{
					// if this is a mesh socket based null
					if(PreviewMeshHierarchy->Contains(Key))
					{
						continue;
					}
				}
				KeysToSpawn.Add(Key);
			}

			(void)ConvertHierarchyElementsToSpawnerNodes(CopyOfHierarchy, KeysToSpawn, false);

			if(GetHierarchy()->Num(ERigElementType::Connector) == 0)
			{
				static const FName RootName = TEXT("Root");
				static const FString RootDescription = TEXT("This is the default temporary socket used for the root connection.");
				const FRigElementKey ConnectorKey = Controller->AddConnector(RootName);
				const FRigElementKey SocketKey = Controller->AddSocket(RootName, FRigElementKey(), FTransform::Identity, false, FRigSocketElement::SocketDefaultColor, RootDescription, false);
				(void)ResolveConnector(ConnectorKey, SocketKey);
			}
		}
	}

	OnRigTypeChangedDelegate.Broadcast(GetControlRigAssetInterface().GetObject());
	return true;
}

bool IControlRigAssetInterface::CanTurnIntoStandaloneRig(FString* OutErrorMessage) const
{
	return IsControlRigModule();
}

bool IControlRigAssetInterface::TurnIntoStandaloneRig(FString* OutErrorMessage)
{
	if(!CanTurnIntoStandaloneRig(OutErrorMessage))
	{
		return false;
	}

	FScopedTransaction Transaction(LOCTEXT("TurnIntoStandaloneRig", "Turn Module into Rig"));

	GetObject()->Modify();
	GetRigModuleSettings() = FRigModuleSettings();

	if(GetHierarchy())
	{
		GetHierarchy()->Modify();
		GetHierarchy()->Reset();
		if(GetPreviewSkeletalMesh())
		{
			GetHierarchy()->GetController(true)->ImportBones(GetPreviewSkeletalMesh()->GetSkeleton());
			GetHierarchy()->GetController(true)->ImportSocketsFromSkeletalMesh(GetPreviewSkeletalMesh().Get(), NAME_None, false, false, false, false, false);
		}
	}

	OnRigTypeChangedDelegate.Broadcast(GetControlRigAssetInterface()->GetObject());
	return true;
}

TArray<URigVMNode*> IControlRigAssetInterface::ConvertHierarchyElementsToSpawnerNodes(URigHierarchy* InHierarchy, TArray<FRigElementKey> InKeys, bool bRemoveElements)
{
	TArray<URigVMNode*> SpawnerNodes;

	// find the construction event 
	const URigVMNode* EventNode = nullptr;
	for(const URigVMGraph* Graph : GetRigVMClient()->GetAllModels(false, false))
	{
		for(const URigVMNode* Node : Graph->GetNodes())
		{
			if(Node->IsEvent() && Node->GetEventName() == FRigUnit_PrepareForExecution::EventName)
			{
				EventNode = Node;
				break;
			}
		}
		if(EventNode)
		{
			break;
		}
	}

	FVector2D NodePosition = FVector2D::ZeroVector;
	const FVector2D NodePositionIncrement = FVector2D(400, 0);
	
	// if we didn't find the construction event yet, create it
	if(EventNode == nullptr)
	{
		const URigVMGraph* ConstructionGraph = GetRigVMClient()->AddModel(TEXT("ConstructionGraph"), true);
		URigVMController* GraphController = GetRigVMClient()->GetOrCreateController(ConstructionGraph);
		EventNode = GraphController->AddUnitNode(FRigUnit_PrepareForExecution::StaticStruct(), FRigUnit::GetMethodName(), NodePosition);
		NodePosition += NodePositionIncrement;
	}

	const URigVMPin* LastPin = EventNode->FindExecutePin();
	if(LastPin)
	{
		// follow the node's execution links to find the last one
		bool bCarryOn = true;
		while(bCarryOn)
		{
			static const TArray<FString> ExecutePinPaths = {
				FRigVMStruct::ControlFlowCompletedName.ToString(),
				FRigVMStruct::ExecuteContextName.ToString()
			};

			for(const FString& ExecutePinPath : ExecutePinPaths)
			{
				if(const URigVMPin* ExecutePin = LastPin->GetNode()->FindPin(ExecutePinPath))
				{
					const TArray<URigVMPin*> TargetPins = ExecutePin->GetLinkedTargetPins();
					if(TargetPins.IsEmpty())
					{
						bCarryOn = false;
						break;
					}
					LastPin = TargetPins[0];
					NodePosition = LastPin->GetNode()->GetPosition() + NodePositionIncrement;
				}
			}
		}
	}

	const URigVMGraph* ConstructionGraph = EventNode->GetGraph();
	URigVMController* GraphController = GetRigVMClient()->GetOrCreateController(ConstructionGraph);

	auto GetParentAndTransformDefaults = [InHierarchy](const FRigElementKey& InKey, FString& OutParentDefault, FString& OutTransformDefault)
	{
		const FRigElementKey Parent = InHierarchy->GetFirstParent(InKey);
		OutParentDefault.Reset();
		FRigElementKey::StaticStruct()->ExportText(OutParentDefault, &Parent, nullptr, nullptr, PPF_None, nullptr);

		const FTransform Transform = InHierarchy->GetInitialLocalTransform(InKey);
		OutTransformDefault.Reset();
		TBaseStructure<FTransform>::Get()->ExportText(OutTransformDefault, &Transform, nullptr, nullptr, PPF_None, nullptr);
	};

	TMap<FRigElementKey, const URigVMPin*> ParentItemPinMap;
	auto AddParentItemLink = [GraphController, InHierarchy, &SpawnerNodes, &ParentItemPinMap]
		(const FRigElementKey& Key, URigVMNode* Node)
		{
			SpawnerNodes.Add(Node);
			ParentItemPinMap.Add(Key, Node->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Item)));

			if(const URigVMPin** SourcePin = ParentItemPinMap.Find(InHierarchy->GetFirstParent(Key)))
			{
				if(const URigVMPin* TargetPin = Node->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Parent)))
				{
					GraphController->AddLink((*SourcePin)->GetPinPath(), TargetPin->GetPinPath(), true);
				}
			}
		};
	
	for(const FRigElementKey& Key : InKeys)
	{
		if(Key.Type == ERigElementType::Bone)
		{
			FString ParentDefault, TransformDefault;
			GetParentAndTransformDefaults(Key, ParentDefault, TransformDefault);

			URigVMNode* AddBoneNode = GraphController->AddUnitNode(FRigUnit_HierarchyAddBone::StaticStruct(), FRigUnit::GetMethodName(), NodePosition);
			NodePosition += NodePositionIncrement;
			AddParentItemLink(Key, AddBoneNode);

			if(LastPin)
			{
				if(const URigVMPin* NextPin = AddBoneNode->FindExecutePin())
				{
					GraphController->AddLink(LastPin->GetPinPath(), NextPin->GetPinPath(), true);
					LastPin = NextPin;
				}
			}

			GraphController->SetPinDefaultValue(AddBoneNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Name))->GetPinPath(), Key.Name.ToString(), true, true);
			GraphController->SetPinDefaultValue(AddBoneNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Parent))->GetPinPath(), ParentDefault, true, true);
			GraphController->SetPinDefaultValue(AddBoneNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddBone, Space))->GetPinPath(), TEXT("LocalSpace"), true, true);
			GraphController->SetPinDefaultValue(AddBoneNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddBone, Transform))->GetPinPath(), TransformDefault, true, true);
		}
		else if(Key.Type == ERigElementType::Null)
		{
			FString ParentDefault, TransformDefault;
			GetParentAndTransformDefaults(Key, ParentDefault, TransformDefault);

			URigVMNode* AddNullNode = GraphController->AddUnitNode(FRigUnit_HierarchyAddNull::StaticStruct(), FRigUnit::GetMethodName(), NodePosition);
			NodePosition += NodePositionIncrement;
			AddParentItemLink(Key, AddNullNode);
			SpawnerNodes.Add(AddNullNode);

			if(LastPin)
			{
				if(const URigVMPin* NextPin = AddNullNode->FindExecutePin())
				{
					GraphController->AddLink(LastPin->GetPinPath(), NextPin->GetPinPath(), true);
					LastPin = NextPin;
				}
			}

			GraphController->SetPinDefaultValue(AddNullNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Name))->GetPinPath(), Key.Name.ToString(), true, true);
			GraphController->SetPinDefaultValue(AddNullNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Parent))->GetPinPath(), ParentDefault, true, true);
			GraphController->SetPinDefaultValue(AddNullNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddNull, Space))->GetPinPath(), TEXT("LocalSpace"), true, true);
			GraphController->SetPinDefaultValue(AddNullNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddNull, Transform))->GetPinPath(), TransformDefault, true, true);
		}
		else if(Key.Type == ERigElementType::Control)
		{
			FRigControlElement* ControlElement = InHierarchy->FindChecked<FRigControlElement>(Key);
			
			FString ParentDefault, TransformDefault;
			GetParentAndTransformDefaults(Key, ParentDefault, TransformDefault);

			const FTransform OffsetTransform = InHierarchy->GetControlOffsetTransform(ControlElement, ERigTransformType::InitialLocal);
			FString OffsetDefault;
			TBaseStructure<FTransform>::Get()->ExportText(OffsetDefault, &OffsetTransform, nullptr, nullptr, PPF_None, nullptr);
			
			if(ControlElement->Settings.AnimationType == ERigControlAnimationType::AnimationChannel)
			{
				UScriptStruct* UnitNodeStruct = nullptr;
				TRigVMTypeIndex TypeIndex = INDEX_NONE;
				FString InitialValue, MinimumValue, MaximumValue, SettingsValue;
				switch(ControlElement->Settings.ControlType)
				{
					case ERigControlType::Bool:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelBool::StaticStruct();
						TypeIndex = RigVMTypeUtils::TypeIndex::Bool;
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<float>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<float>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<float>();
						break;
					}
					case ERigControlType::Float:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelFloat::StaticStruct();
						TypeIndex = RigVMTypeUtils::TypeIndex::Float;
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<float>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<float>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<float>();

						if(ControlElement->Settings.LimitEnabled.Num() == 1)
						{
							FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings Settings;
							Settings.Enabled = ControlElement->Settings.LimitEnabled[0];
							FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings::StaticStruct()->ExportText(SettingsValue, &Settings, &Settings, nullptr, PPF_None, nullptr);
						}
						break;
					}
					case ERigControlType::ScaleFloat:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelScaleFloat::StaticStruct();
						TypeIndex = RigVMTypeUtils::TypeIndex::Float;
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<float>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<float>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<float>();

						if(ControlElement->Settings.LimitEnabled.Num() == 1)
						{
							FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings Settings;
							Settings.Enabled = ControlElement->Settings.LimitEnabled[0];
							FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings::StaticStruct()->ExportText(SettingsValue, &Settings, &Settings, nullptr, PPF_None, nullptr);
						}
						break;
					}
					case ERigControlType::Integer:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelInteger::StaticStruct();
						TypeIndex = RigVMTypeUtils::TypeIndex::Int32; 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<int32>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<int32>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<int32>();

						if(ControlElement->Settings.LimitEnabled.Num() == 1)
						{
							FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings Settings;
							Settings.Enabled = ControlElement->Settings.LimitEnabled[0];
							FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings::StaticStruct()->ExportText(SettingsValue, &Settings, &Settings, nullptr, PPF_None, nullptr);
						}
						break;
					}
					case ERigControlType::Vector2D:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelVector2D::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FVector2D>(); 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<FVector2D>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<FVector2D>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<FVector2D>();

						if(ControlElement->Settings.LimitEnabled.Num() == 2)
						{
							FRigUnit_HierarchyAddAnimationChannel2DLimitSettings Settings;
							Settings.X = ControlElement->Settings.LimitEnabled[0];
							Settings.Y = ControlElement->Settings.LimitEnabled[1];
							FRigUnit_HierarchyAddAnimationChannel2DLimitSettings::StaticStruct()->ExportText(SettingsValue, &Settings, &Settings, nullptr, PPF_None, nullptr);
						}
						break;
					}
					case ERigControlType::Position:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelVector::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FVector>(); 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<FVector>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<FVector>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<FVector>();

						if(ControlElement->Settings.LimitEnabled.Num() == 3)
						{
							FRigUnit_HierarchyAddAnimationChannelVectorLimitSettings Settings;
							Settings.X = ControlElement->Settings.LimitEnabled[0];
							Settings.Y = ControlElement->Settings.LimitEnabled[1];
							Settings.Z = ControlElement->Settings.LimitEnabled[2];
							FRigUnit_HierarchyAddAnimationChannelVectorLimitSettings::StaticStruct()->ExportText(SettingsValue, &Settings, &Settings, nullptr, PPF_None, nullptr);
						}
						break;
					}
					case ERigControlType::Scale:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelScaleVector::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FVector>(); 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<FVector>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<FVector>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<FVector>();

						if(ControlElement->Settings.LimitEnabled.Num() == 3)
						{
							FRigUnit_HierarchyAddAnimationChannelVectorLimitSettings Settings;
							Settings.X = ControlElement->Settings.LimitEnabled[0];
							Settings.Y = ControlElement->Settings.LimitEnabled[1];
							Settings.Z = ControlElement->Settings.LimitEnabled[2];
							FRigUnit_HierarchyAddAnimationChannelVectorLimitSettings::StaticStruct()->ExportText(SettingsValue, &Settings, &Settings, nullptr, PPF_None, nullptr);
						}
						break;
					}
					case ERigControlType::Rotator:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddAnimationChannelRotator::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FRotator>(); 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<FRotator>();
						MinimumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Minimum).ToString<FRotator>();
						MaximumValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Maximum).ToString<FRotator>();

						if(ControlElement->Settings.LimitEnabled.Num() == 3)
						{
							FRigUnit_HierarchyAddAnimationChannelRotatorLimitSettings Settings;
							Settings.Pitch = ControlElement->Settings.LimitEnabled[0];
							Settings.Yaw = ControlElement->Settings.LimitEnabled[1];
							Settings.Roll = ControlElement->Settings.LimitEnabled[2];
							FRigUnit_HierarchyAddAnimationChannelRotatorLimitSettings::StaticStruct()->ExportText(SettingsValue, &Settings, &Settings, nullptr, PPF_None, nullptr);
						}
						break;
					}
					default:
					{
						break;
					}
				}

				if(UnitNodeStruct == nullptr)
				{
					continue;
				}

				URigVMNode* AddControlNode = GraphController->AddUnitNode(UnitNodeStruct, FRigUnit::GetMethodName(), NodePosition);
				NodePosition += NodePositionIncrement;
				AddParentItemLink(Key, AddControlNode);

				if(LastPin)
				{
					if(const URigVMPin* NextPin = AddControlNode->FindExecutePin())
					{
						GraphController->AddLink(LastPin->GetPinPath(), NextPin->GetPinPath(), true);
						LastPin = NextPin;
					}
				}

				GraphController->ResolveWildCardPin(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddAnimationChannelFloat, InitialValue))->GetPinPath(), TypeIndex, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddAnimationChannelFloat, Name))->GetPinPath(), Key.Name.ToString(), true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddAnimationChannelFloat, Parent))->GetPinPath(), ParentDefault, true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddAnimationChannelFloat, InitialValue))->GetPinPath(), InitialValue, true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddAnimationChannelFloat, MinimumValue))->GetPinPath(), MinimumValue, true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddAnimationChannelFloat, MaximumValue))->GetPinPath(), MaximumValue, true, true);

				if(!SettingsValue.IsEmpty())
				{
					GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddAnimationChannelFloat, LimitsEnabled))->GetPinPath(), SettingsValue, true, true);
				}
			}
			else
			{
				UScriptStruct* UnitNodeStruct = nullptr;
				TRigVMTypeIndex TypeIndex = INDEX_NONE;
				FString InitialValue;
				switch(ControlElement->Settings.ControlType)
				{
					case ERigControlType::Float:
					case ERigControlType::ScaleFloat:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddControlFloat::StaticStruct();
						TypeIndex = RigVMTypeUtils::TypeIndex::Float;
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<float>();
						break;
					}
					case ERigControlType::Integer:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddControlInteger::StaticStruct();
						TypeIndex = RigVMTypeUtils::TypeIndex::Int32; 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<int32>();
						break;
					}
					case ERigControlType::Vector2D:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddControlVector2D::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FVector2D>(); 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<FVector2D>();
						break;
					}
					case ERigControlType::Position:
					case ERigControlType::Scale:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddControlVector::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FVector>(); 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<FVector>();
						break;
					}
					case ERigControlType::Rotator:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddControlRotator::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FRotator>(); 
						InitialValue = InHierarchy->GetControlValue(Key, ERigControlValueType::Initial).ToString<FRotator>();
						break;
					}
					case ERigControlType::Transform:
					case ERigControlType::TransformNoScale:
					case ERigControlType::EulerTransform:
					{
						UnitNodeStruct = FRigUnit_HierarchyAddControlTransform::StaticStruct();
						TypeIndex = FRigVMRegistry::Get().GetTypeIndex<FTransform>(); 
						const FTransform InitialTransform = InHierarchy->GetInitialLocalTransform(Key);
						TBaseStructure<FTransform>::Get()->ExportText(InitialValue, &InitialTransform, nullptr, nullptr, PPF_None, nullptr);
						break;
					}
					default:
					{
						break;
					}
				}

				if(UnitNodeStruct == nullptr)
				{
					continue;
				}

				URigVMNode* AddControlNode = GraphController->AddUnitNode(UnitNodeStruct, FRigUnit::GetMethodName(), NodePosition);
				NodePosition += NodePositionIncrement;
				AddParentItemLink(Key, AddControlNode);

				if(LastPin)
				{
					if(const URigVMPin* NextPin = AddControlNode->FindExecutePin())
					{
						GraphController->AddLink(LastPin->GetPinPath(), NextPin->GetPinPath(), true);
						LastPin = NextPin;
					}
				}

				GraphController->ResolveWildCardPin(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddControlInteger, InitialValue))->GetPinPath(), TypeIndex, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Name))->GetPinPath(), Key.Name.ToString(), true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Parent))->GetPinPath(), ParentDefault, true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddControlElement, OffsetSpace))->GetPinPath(), TEXT("LocalSpace"), true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddControlElement, OffsetTransform))->GetPinPath(), OffsetDefault, true, true);
				GraphController->SetPinDefaultValue(AddControlNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddControlInteger, InitialValue))->GetPinPath(), InitialValue, true, true);

				if(const FStructProperty* SettingsProperty = CastField<FStructProperty>(UnitNodeStruct->FindPropertyByName(TEXT("Settings"))))
				{
					UScriptStruct* SettingsStruct = CastChecked<UScriptStruct>(SettingsProperty->Struct);
					FStructOnScope SettingsScope(SettingsStruct);
					FRigUnit_HierarchyAddControl_Settings* Settings = (FRigUnit_HierarchyAddControl_Settings*)SettingsScope.GetStructMemory();
					Settings->ConfigureFrom(ControlElement, ControlElement->Settings);
					FString SettingsDefault;
					SettingsStruct->ExportText(SettingsDefault, Settings, nullptr, nullptr, PPF_None, nullptr);

					GraphController->SetPinDefaultValue(AddControlNode->FindPin(SettingsProperty->GetName())->GetPinPath(), SettingsDefault, true, true);
				}
			}
		}
		else if(Key.Type == ERigElementType::Socket)
		{
			FString ParentDefault, TransformDefault;
			GetParentAndTransformDefaults(Key, ParentDefault, TransformDefault);

			URigVMNode* AddSocketNode = GraphController->AddUnitNode(FRigUnit_HierarchyAddSocket::StaticStruct(), FRigUnit::GetMethodName(), NodePosition);
			NodePosition += NodePositionIncrement;
			AddParentItemLink(Key, AddSocketNode);
			SpawnerNodes.Add(AddSocketNode);

			if(LastPin)
			{
				if(const URigVMPin* NextPin = AddSocketNode->FindExecutePin())
				{
					GraphController->AddLink(LastPin->GetPinPath(), NextPin->GetPinPath(), true);
					LastPin = NextPin;
				}
			}

			GraphController->SetPinDefaultValue(AddSocketNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Name))->GetPinPath(), Key.Name.ToString(), true, true);
			GraphController->SetPinDefaultValue(AddSocketNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddElement, Parent))->GetPinPath(), ParentDefault, true, true);
			GraphController->SetPinDefaultValue(AddSocketNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddNull, Space))->GetPinPath(), TEXT("LocalSpace"), true, true);
			GraphController->SetPinDefaultValue(AddSocketNode->FindPin(GET_MEMBER_NAME_STRING_CHECKED(FRigUnit_HierarchyAddNull, Transform))->GetPinPath(), TransformDefault, true, true);
		}
	}

	if(bRemoveElements && InHierarchy)
	{
		InHierarchy->Modify();
		for(const FRigElementKey& Key : InKeys)
		{
			InHierarchy->GetController(true)->RemoveElement(Key, true);
		}
	}

	return SpawnerNodes;
}

#endif // WITH_EDITORONLY_DATA

UTexture2D* IControlRigAssetInterface::GetRigModuleIcon() const
{
	if(IsControlRigModule())
	{
		if(UTexture2D* Icon = Cast<UTexture2D>(GetRigModuleSettings().Icon.TryLoad()))
		{
			return Icon;
		}
	}
	return nullptr;
}

UControlRig* IControlRigAssetInterface::GetDebuggedControlRig()
{
	return Cast<UControlRig>(GetRigVMAssetInterface()->GetDebuggedRigVMHost());
}

void IControlRigAssetInterface::SetPreviewMesh(USkeletalMesh* PreviewMesh, bool bMarkAsDirty/*=true*/)
{
#if WITH_EDITORONLY_DATA
	if(bMarkAsDirty)
	{
		Modify();
	}

	GetPreviewSkeletalMesh() = PreviewMesh;

	if(IsControlRigModule())
	{
		GetSourceHierarchyImport().Reset();
		GetSourceCurveImport().Reset();
	}
#endif
}

void IControlRigAssetInterface::Serialize(FArchive& Ar)
{
	UE_RIGVM_ARCHIVETRACE_SCOPE(Ar, FString::Printf(TEXT("IControlRigAssetInterface(%s)"), *GetName()));

	if(IsValidChecked(GetObject()))
	{
		GetRigVMClient()->SetOuterClientHost(GetObject(), TEXT("RigVMClient"));
		GetModularRigModel().SetOuterClientHost(GetObject());
	}
	
	GetRigVMAssetInterface()->IRigVMAssetInterface::SerializeImpl(Ar);
	UE_RIGVM_ARCHIVETRACE_ENTRY(Ar, TEXT("Super::Serialize"));

	if(Ar.IsObjectReferenceCollector())
	{
		Ar.UsingCustomVersion(FControlRigObjectVersion::GUID);


#if WITH_EDITORONLY_DATA
		if (Ar.IsCooking() && GetRigVMAssetInterface()->IsReferencedObjectPathsStored())
		{
			for (FSoftObjectPath ObjectPath : GetRigVMAssetInterface()->GetReferencedObjectPaths())
			{
				ObjectPath.Serialize(Ar);
			}
		}
		else
#endif
		{
			TArray<IRigVMGraphFunctionHost*> ReferencedFunctionHosts = GetRigVMAssetInterface()->GetReferencedFunctionHosts(false);

			for(IRigVMGraphFunctionHost* ReferencedFunctionHost : ReferencedFunctionHosts)
			{
				if (URigVMBlueprintGeneratedClass* BPGeneratedClass = Cast<URigVMBlueprintGeneratedClass>(ReferencedFunctionHost))
				{
					Ar << BPGeneratedClass;
				}
			}

			for(const TSoftObjectPtr<UControlRigShapeLibrary>& ShapeLibraryPtr : GetShapeLibraries())
			{
				if(ShapeLibraryPtr.IsValid())
				{
					UControlRigShapeLibrary* ShapeLibrary = ShapeLibraryPtr.Get();
					Ar << ShapeLibrary;
				}
			}
		}
	}

	if(Ar.IsLoading())
	{
		GetModularRigModel().UpdateCachedChildren();
		GetModularRigModel().Connections.UpdateFromConnectionList();
	}
}

UClass* IControlRigAssetInterface::GetBlueprintClass() const
{
	return GetRigVMAssetInterface()->GetRigVMGeneratedClassPrototype();
}

void IControlRigAssetInterface::PreSave(FObjectPreSaveContext ObjectSaveContext)
{
	// make sure to save the VM with high performance settings
	// so that during cooking we reach small footprints.
	// these settings may have changed during the user session.
	GetRigVMAssetInterface()->GetVMCompileSettings().ASTSettings.bFoldAssignments = true;
	GetRigVMAssetInterface()->GetVMCompileSettings().ASTSettings.bFoldLiterals = true;

	GetExposesAnimatableControls() = false;
	GetHierarchy()->ForEach<FRigControlElement>([this](FRigControlElement* ControlElement) -> bool
    {
		if (GetHierarchy()->IsAnimatable(ControlElement))
		{
			GetExposesAnimatableControls() = true;
			return false;
		}
		return true;
	});

	if(IsControlRigModule())
	{
		URigHierarchy* DebuggedHierarchy = GetHierarchy();
		if(UControlRig* DebuggedRig = Cast<UControlRig>(GetObjectBeingDebugged()))
		{
			DebuggedHierarchy = DebuggedRig->GetHierarchy();
		}

		TGuardValue<bool> SuspendNotifGuard(GetHierarchy()->GetSuspendNotificationsFlag(), true);
		TGuardValue<bool> SuspendNotifGuardOnDebuggedHierarchy(DebuggedHierarchy->GetSuspendNotificationsFlag(), true);

		UpdateExposedModuleConnectors();

		GetSourceHierarchyImport().Reset();
		GetSourceCurveImport().Reset();
	}

	if (IsControlRigModule())
	{
		GetControlRigType() = EControlRigType::RigModule;
		GetItemTypeDisplayName() = TEXT("Rig Module");
		GetCustomThumbnail() = GetRigModuleSettings().Icon.ToString();
	}
	else if (GetControlRigClass()->IsChildOf(UModularRig::StaticClass()))
	{
		GetControlRigType() = EControlRigType::ModularRig;
		GetItemTypeDisplayName() = TEXT("Modular Rig");
	}
	else
	{
		GetControlRigType() = EControlRigType::IndependentRig;
		GetItemTypeDisplayName() = TEXT("Control Rig");
	}

	if (IsModularRig())
	{
		GetModuleReferenceData() = GetModuleReferenceDataImpl();
		IAssetRegistry::GetChecked().AssetTagsFinalized(*GetObject());
	}
}

TArray<FModuleReferenceData> IControlRigAssetInterface::FindReferencesToModule() const
{
	TArray<FModuleReferenceData> Result;
	if (!IsControlRigModule())
	{
		return Result;
	}

	const UClass* RigModuleClass = GetControlRigClass();
	if (!RigModuleClass)
	{
		return Result;
	}

	// Load the asset registry module
	const FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));

	// Collect a full list of assets with the control rig class
	TArray<FAssetData> AssetDataList;
	AssetRegistryModule.Get().GetAssetsByClass(UControlRigAssetInterface::StaticClass()->GetClassPathName(), AssetDataList, true);

	static const FLazyName ModuleReferenceDataName(TEXT("ModuleReferenceData"));

	for(const FAssetData& AssetData : AssetDataList)
	{
		UClass* AssetClass = FindObject<UClass>(AssetData.AssetClassPath);
		if (!AssetClass)
		{
			continue;
		}

		FArrayProperty* ModuleReferenceDataProperty = CastField<FArrayProperty>(AssetClass->StaticClass()->FindPropertyByName(ModuleReferenceDataName));
		if (!ModuleReferenceDataProperty)
		{
			continue;
		}
		
		// Check only modular rigs
		if (IControlRigAssetInterface::GetRigType(AssetData) != EControlRigType::ModularRig)
		{
			continue;
		}
		
		const FString ModularRigDataString = AssetData.GetTagValueRef<FString>(ModuleReferenceDataName);
		if (ModularRigDataString.IsEmpty())
		{
			continue;
		}

		TArray<FModuleReferenceData> Modules;
		ModuleReferenceDataProperty->ImportText_Direct(*ModularRigDataString, &Modules, nullptr, EPropertyPortFlags::PPF_None);

		for (FModuleReferenceData& Module : Modules)
		{
			if (Module.ReferencedModule == RigModuleClass)
			{
				Result.Add(Module);
			}
		}
	}

	return Result;
}

EControlRigType IControlRigAssetInterface::GetRigType(const FAssetData& InAsset)
{
	EControlRigType Result = EControlRigType::MAX;
	static const FLazyName ControlRigTypeName( TEXT("ControlRigType"));

	UClass* AssetClass = FindObject<UClass>(InAsset.AssetClassPath);
	if (!AssetClass)
	{
		return Result;
	}

	FProperty* ControlRigTypeProperty = CastField<FProperty>(AssetClass->FindPropertyByName(ControlRigTypeName));
	if (!ControlRigTypeProperty)
	{
		return Result;
	}
	
	const FString ControlRigTypeString = InAsset.GetTagValueRef<FString>(ControlRigTypeName);
	if (ControlRigTypeString.IsEmpty())
	{
		return Result;
	}

	EControlRigType RigType;
	ControlRigTypeProperty->ImportText_Direct(*ControlRigTypeString, &RigType, nullptr, EPropertyPortFlags::PPF_None);
	return RigType;
}

TArray<FSoftObjectPath> IControlRigAssetInterface::GetReferencesToRigModule(const FAssetData& InModuleAsset)
{
	TArray<FSoftObjectPath> Result;
	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
	IAssetRegistry& AssetRegistry = AssetRegistryModule.GetRegistry();
	
	TArray<FName> PackageDependencies;
	AssetRegistry.GetReferencers(InModuleAsset.PackageName, PackageDependencies);

	for (FName& DependencyPath : PackageDependencies)
	{
		TArray<FAssetData> Assets;
		AssetRegistry.GetAssetsByPackageName(DependencyPath, Assets);

		for (const FAssetData& DependencyData : Assets)
		{
			if (DependencyData.IsAssetLoaded())
			{
				if (IControlRigAssetInterface* Blueprint = Cast<IControlRigAssetInterface>(DependencyData.GetAsset()))
				{
					if (Blueprint->IsModularRig())
					{
						TArray<const FRigModuleReference*> Modules = Blueprint->GetModularRigModel().FindModuleInstancesOfClass(InModuleAsset);
						for (const FRigModuleReference* Module : Modules)
						{
							FSoftObjectPath ModulePath = DependencyData.GetSoftObjectPath();
							ModulePath.SetSubPathString(Module->GetModulePath().GetPath());
							Result.Add(ModulePath);
						}
					}
				}
				else if (UControlRigBlueprintGeneratedClass* Generated = Cast<UControlRigBlueprintGeneratedClass>(DependencyData.GetAsset()))
				{
					if (Generated->ControlRigType == EControlRigType::ModularRig)
					{
						for (FModuleReferenceData& Module : Generated->ModuleReferenceData)
						{
							if (Module.ReferencedModule == InModuleAsset.GetClass())
							{
								FSoftObjectPath ModulePath = DependencyData.GetSoftObjectPath();
								ModulePath.SetSubPathString(Module.ModulePath);
								Result.Add(ModulePath);
							}
						}
					}
				}
			}
			else
			{
				// Check only modular rigs
				if (IControlRigAssetInterface::GetRigType(DependencyData) != EControlRigType::ModularRig)
				{
					continue;
				}

				UClass* AssetClass = FindObject<UClass>(DependencyData.AssetClassPath);
				if (!AssetClass)
				{
					continue;
				}

				static const FLazyName ModuleReferenceDataName(TEXT("ModuleReferenceData"));
				FArrayProperty* ModuleReferenceDataProperty = CastField<FArrayProperty>(AssetClass->StaticClass()->FindPropertyByName(ModuleReferenceDataName));
				if (!ModuleReferenceDataProperty)
				{
					continue;
				}
				const FString ModularRigDataString = DependencyData.GetTagValueRef<FString>(ModuleReferenceDataName);
				if (ModularRigDataString.IsEmpty())
				{
					continue;
				}

				

				TArray<FModuleReferenceData> Modules;
				ModuleReferenceDataProperty->ImportText_Direct(*ModularRigDataString, &Modules, nullptr, EPropertyPortFlags::PPF_None);

				for (const FModuleReferenceData& Module : Modules)
				{
					FTopLevelAssetPath ModulePath = Module.ReferencedModule.GetAssetPath();
					FString AssetName = ModulePath.GetAssetName().ToString();
					AssetName.RemoveFromEnd(TEXT("_C"));
					ModulePath = FTopLevelAssetPath(ModulePath.GetPackageName(), *AssetName);
					if (ModulePath == InModuleAsset.GetSoftObjectPath().GetAssetPath())
					{
						FSoftObjectPath ResultModulePath = DependencyData.GetSoftObjectPath();
						ResultModulePath.SetSubPathString(Module.ModulePath);
						Result.Add(ResultModulePath);
					}
				}
			}
		}
	}
	
	return Result;
}

TArray<FModuleReferenceData> IControlRigAssetInterface::GetModuleReferenceDataImpl() const
{
	TArray<FModuleReferenceData> Result;
	Result.Reserve(GetModularRigModel().Modules.Num());
	GetModularRigModel().ForEachModule([&Result](const FRigModuleReference* Module) -> bool
	{
		Result.Add(Module);
		return true;
	});
	return Result;
}

void IControlRigAssetInterface::UpdateExposedModuleConnectors() const
{
	IControlRigAssetInterface* MutableThis = ((IControlRigAssetInterface*)this);
	MutableThis->GetRigModuleSettings().ExposedConnectors.Reset();
	GetHierarchy()->ForEach<FRigConnectorElement>([MutableThis, this](const FRigConnectorElement* ConnectorElement) -> bool
	{
		const FRigElementKey ConnectorKey = ConnectorElement->GetKey().ConvertToModuleNameFormat(&GetModularRigModel().PreviousModulePaths);
		
		FRigModuleConnector ExposedConnector;
		ExposedConnector.Name = ConnectorKey.Name.ToString();
		ExposedConnector.Settings = ConnectorElement->Settings;
		MutableThis->GetRigModuleSettings().ExposedConnectors.Add(ExposedConnector);
		return true;
	});
	PropagateHierarchyFromBPToInstances();
}

#if WITH_EDITOR

TArray<FOverrideStatusSubject> IControlRigAssetInterface::GetOverrideSubjects() const
{
	TArray<FOverrideStatusSubject> Subjects;

	if(const UModularRig* DebuggedRig = Cast<UModularRig>(GetObjectBeingDebugged()))
	{
		GetModularRigModel().ForEachModule([&Subjects, DebuggedRig](const FRigModuleReference* ModuleReference) -> bool
		{
			if(const FRigModuleInstance* ModuleInstance = DebuggedRig->FindModule(ModuleReference->Name))
			{
				if(const UControlRig* ModuleRig = ModuleInstance->GetRig())
				{
					for(const FControlRigOverrideValue& Override : ModuleReference->ConfigOverrides)
					{
						Subjects.Add({ModuleRig, Override.ToPropertyPath()});
					}
				}
			}
			return true;
		});
	}

	return Subjects;
}

uint32 IControlRigAssetInterface::GetOverrideSubjectsHash() const
{
	uint32 Hash = 0;
	
	GetModularRigModel().ForEachModule([&Hash](const FRigModuleReference* ModuleReference) -> bool
	{
		Hash = HashCombine(Hash, GetTypeHash(ModuleReference->Name));
		Hash = HashCombine(Hash, GetTypeHash(ModuleReference->ConfigOverrides));
		return true;
	});

	return Hash;
}

FName IControlRigAssetInterface::FindHostMemberVariableUniqueName(TSharedPtr<FRigVMNameValidator> InNameValidator, const FString& InBaseName)
{
	FString BaseName = InBaseName;
	if (InNameValidator->IsValid(BaseName, false) == EValidatorResult::ContainsInvalidCharacters)
	{
		for (TCHAR& TestChar : BaseName)
		{
			for (TCHAR BadChar : UE_BLUEPRINT_INVALID_NAME_CHARACTERS)
			{
				if (TestChar == BadChar)
				{
					TestChar = TEXT('_');
					break;
				}
			}
		}
	}

	FString KismetName = BaseName;

	int32 Suffix = 0;
	while (InNameValidator->IsValid(KismetName, false) != EValidatorResult::Ok)
	{
		KismetName = FString::Printf(TEXT("%s_%d"), *BaseName, Suffix);
		Suffix++;
	}


	return *KismetName;
}

#endif

bool IControlRigAssetInterface::ResolveConnector(const FRigElementKey& DraggedKey, const FRigElementKey& TargetKey, bool bSetupUndoRedo)
{
	return ResolveConnectorToArray(DraggedKey, {TargetKey}, bSetupUndoRedo);
}

bool IControlRigAssetInterface::ResolveConnectorToArray(const FRigElementKey& DraggedKey, const TArray<FRigElementKey>& TargetKeys, bool bSetupUndoRedo)
{
	FScopedTransaction Transaction(LOCTEXT("ResolveConnector", "Resolve connector"));

	if(bSetupUndoRedo)
	{
		Modify();
	}

	TArray<FRigElementKey> FilteredKeys = TargetKeys;
	FilteredKeys.RemoveAll([](const FRigElementKey& Key)
	{
		return !Key.IsValid();
	});
	
	if(!FilteredKeys.IsEmpty())
	{
		FRigElementKeyCollection& ExistingTargetKeys = GetArrayConnectionMap().FindOrAdd(DraggedKey);

		if(ExistingTargetKeys.Num() == FilteredKeys.Num())
		{
			bool bCompleteMatch = true;
			for(int32 Index = 0; Index < ExistingTargetKeys.Num(); Index++)
			{
				if(ExistingTargetKeys[Index] != FilteredKeys[Index])
				{
					bCompleteMatch = false;
					break;
				}
			}
			if(bCompleteMatch)
			{
				return false;
			}
		}
		ExistingTargetKeys.Keys = FilteredKeys;

		if (IsModularRig())
		{
			// Add connection to the model
			if (UModularRigController* Controller = GetModularRigController())
			{
				Controller->ConnectConnectorToElements(DraggedKey, FilteredKeys, bSetupUndoRedo, GetModularRigSettings().bAutoResolve);
			}
		}
		else
		{
			GetArrayConnectionMap().FindOrAdd(DraggedKey) = ExistingTargetKeys;
		}
	}
	else
	{
		if (IsModularRig())
		{
			// Add connection to the model
			if (UModularRigController* Controller = GetModularRigController())
			{
				Controller->DisconnectConnector(DraggedKey, false, bSetupUndoRedo);
			}
		}
		else
		{
			GetArrayConnectionMap().Remove(DraggedKey);
		}
	}

	RecompileModularRig();

	PropagateHierarchyFromBPToInstances();

	if(UControlRig* ControlRig = Cast<UControlRig>(GetObjectBeingDebugged()))
	{
		for (UEdGraph* Graph : GetRigVMAssetInterface()->GetUberGraphs())
		{
			UControlRigGraph* RigGraph = Cast<UControlRigGraph>(Graph);
			if (RigGraph == nullptr)
			{
				continue;
			}
			RigGraph->CacheNameLists(ControlRig->GetHierarchy(), &GetDrawContainer(), GetShapeLibraries());
		}
	}

	return true;
}

void IControlRigAssetInterface::UpdateConnectionMapFromModel()
{
	if (IsModularRig())
	{
		GetArrayConnectionMap().Reset();

		for (const FModularRigSingleConnection& Connection : GetModularRigModel().Connections)
		{
			GetArrayConnectionMap().Add(Connection.Connector, {Connection.Targets});
		}
	}
}

void IControlRigAssetInterface::PostLoad()
{
	GetModularRigModel().PatchModelsOnLoad();
	
#if WITH_EDITOR
	if(IsControlRigModule() && GetHierarchy())
	{
		// backwards compat - makes sure to only ever allow one primary connector
		TArray<FRigConnectorElement*> Connectors = GetHierarchy()->GetConnectors();
		const int32 NumPrimaryConnectors = Algo::CountIf(Connectors, [](const FRigConnectorElement* InConnector) -> bool
		{
			return InConnector->IsPrimary();
		});
		if(NumPrimaryConnectors > 1)
		{
			bool bHasSeenPrimary = false;
			for(FRigConnectorElement* Connector : Connectors)
			{
				if(bHasSeenPrimary)
				{
					Connector->Settings.Type = EConnectorType::Secondary;
				}
				else
				{
					bHasSeenPrimary = Connector->IsPrimary();
				}
			}
			UpdateExposedModuleConnectors();
		}
	}
#endif

	// patch from previously used module paths to unique module names
	TMap<FRigElementKey, FRigElementKeyCollection> PreviousArrayConnectionMap;
	Swap(PreviousArrayConnectionMap, GetArrayConnectionMap());

	GetArrayConnectionMap().Reset();
	for(TPair<FRigElementKey, FRigElementKeyCollection>& Connection : PreviousArrayConnectionMap)
	{
		FRigElementKey Key = Connection.Key.ConvertToModuleNameFormat(&GetModularRigModel().PreviousModulePaths);
		FRigElementKeyCollection& Targets = Connection.Value;
		for(FRigElementKey& TargetKey : Targets.Keys)
		{
			TargetKey.ConvertToModuleNameFormatInline(&GetModularRigModel().PreviousModulePaths);
		}
		GetArrayConnectionMap().Add(Key, Targets);
	}

	UpdateModularDependencyDelegates();

	if(GetHierarchy())
	{
		GetHierarchy()->PatchElementMetadata(GetModularRigModel().PreviousModulePaths);
		GetHierarchy()->PatchModularRigComponentKeys(GetModularRigModel().PreviousModulePaths);
	}
}

#if WITH_EDITOR

void IControlRigAssetInterface::HandlePackageDone()
{
	if (ShapeLibrariesToLoadOnPackageLoaded.Num() > 0)
	{
		for(const FString& ShapeLibraryToLoadOnPackageLoaded : ShapeLibrariesToLoadOnPackageLoaded)
		{
			GetShapeLibraries().Add(LoadObject<UControlRigShapeLibrary>(nullptr, *ShapeLibraryToLoadOnPackageLoaded));
		}

		TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(true, true);
		for (UObject* Instance : ArchetypeInstances)
		{
			if (UControlRig* InstanceRig = Cast<UControlRig>(Instance))
			{
				InstanceRig->ShapeLibraries = GetShapeLibraries();
			}
		}

		ShapeLibrariesToLoadOnPackageLoaded.Reset();
	}

	PropagateHierarchyFromBPToInstances();

	HandlePackageDoneSuper();
	
	if(IsModularRig())
	{
		// force load all dependencies
		GetModularRigModel().ForEachModule([](const FRigModuleReference* Element) -> bool
		{
			(void)Element->Class.LoadSynchronous();
			const_cast<FRigModuleReference*>(Element)->PatchModelsOnLoad();
			return true;
		});

		RecompileModularRig();
	}
}

void IControlRigAssetInterface::HandleConfigureRigVMController(const FRigVMClient* InClient, URigVMController* InControllerToConfigure)
{
	GetRigVMAssetInterface()->IRigVMAssetInterface::HandleConfigureRigVMController(InClient, InControllerToConfigure);

	TWeakObjectPtr<UObject> WeakThis(GetObject());
	InControllerToConfigure->ConfigureWorkflowOptionsDelegate.BindLambda([WeakThis](URigVMUserWorkflowOptions* Options)
	{
		if(UControlRigWorkflowOptions* ControlRigNodeWorkflowOptions = Cast<UControlRigWorkflowOptions>(Options))
		{
			ControlRigNodeWorkflowOptions->Hierarchy = nullptr;
			ControlRigNodeWorkflowOptions->Selection.Reset();

			if (UObject* StrongThis = WeakThis.Get())
			{
				if (StrongThis->Implements<URigVMAssetInterface>())
				{
					FRigVMAssetInterfacePtr Asset = StrongThis;
					if(UControlRig* ControlRig = Cast<UControlRig>(Asset->GetObjectBeingDebugged()))
					{
						ControlRigNodeWorkflowOptions->Hierarchy = ControlRig->GetHierarchy();
						ControlRigNodeWorkflowOptions->Selection = ControlRig->GetHierarchy()->GetSelectedKeys();
					}
				}
			}
		}
	});
}

#endif

void IControlRigAssetInterface::UpdateConnectionMapAfterRename(const FString& InOldModuleName)
{
	const FString OldModuleName = InOldModuleName + FRigHierarchyModulePath::ModuleNameSuffix;
	const FString NewModuleName = GetRigModuleSettings().Identifier.Name + FRigHierarchyModulePath::ModuleNameSuffix;
	
	TMap<FRigElementKey, FRigElementKeyCollection> FixedConnectionMap;
	for(const TPair<FRigElementKey, FRigElementKeyCollection>& Pair : GetArrayConnectionMap())
	{
		auto FixUpConnectionMap = [OldModuleName, NewModuleName](const FRigElementKey& InKey) -> FRigElementKey
		{
			const FString NameString = InKey.Name.ToString();
			if(NameString.StartsWith(OldModuleName, ESearchCase::CaseSensitive))
			{
				return FRigElementKey(*(NewModuleName + NameString.Mid(OldModuleName.Len())), InKey.Type);
			}
			return InKey;
		};

		const FRigElementKey Key = FixUpConnectionMap(Pair.Key);
		FRigElementKeyCollection Values;
		for(const FRigElementKey& OldValue : Pair.Value)
		{
			Values.Keys.Add(FixUpConnectionMap(OldValue));
		}
		FixedConnectionMap.FindOrAdd(Key) = Values;
	}

	Swap(GetArrayConnectionMap(), FixedConnectionMap);
}

UClass* IControlRigAssetInterface::GetRigVMEdGraphNodeClass() const
{
	return UControlRigGraphNode::StaticClass();
}

UClass* IControlRigAssetInterface::GetRigVMEdGraphSchemaClass() const
{
	return UControlRigGraphSchema::StaticClass();
}

UClass* IControlRigAssetInterface::GetRigVMEdGraphClass() const
{
	return UControlRigGraph::StaticClass();
}

UClass* IControlRigAssetInterface::GetRigVMEditorSettingsClass() const
{
	return UControlRigEditorSettings::StaticClass();
}

void IControlRigAssetInterface::GetPreloadDependencies(TArray<UObject*>& OutDeps)
{
	for (FRigModuleReference& Module : GetModularRigModel().Modules)
	{
		OutDeps.Add(Module.Class.Get());
	}
}

#if WITH_EDITOR
const FLazyName& IControlRigAssetInterface::GetPanelPinFactoryName() const
{
	return ControlRigPanelNodeFactoryName;
}

IRigVMEditorModule* IControlRigAssetInterface::GetEditorModule() const
{
	return &IControlRigEditorModule::Get();
}
#endif

TArray<FString> IControlRigAssetInterface::GeneratePythonCommands(const FString InNewBlueprintName)
{
	TArray<FString> InternalCommands;
	InternalCommands.Add(TEXT("import unreal"));
	InternalCommands.Add(TEXT("unreal.load_module('ControlRigDeveloper')"));
	InternalCommands.Add(TEXT("factory = unreal.ControlRigBlueprintFactory"));
	InternalCommands.Add(FString::Printf(TEXT("blueprint = factory.create_new_control_rig_asset(desired_package_path = '%s')"), *InNewBlueprintName));
	InternalCommands.Add(TEXT("hierarchy = blueprint.hierarchy"));
	InternalCommands.Add(TEXT("hierarchy_controller = hierarchy.get_controller()"));

	// Hierarchy
	InternalCommands.Append(GetHierarchy()->GetController(true)->GeneratePythonCommands());

#if WITH_EDITORONLY_DATA
	const FString PreviewMeshPath = GetPreviewMesh()->GetPathName();
	InternalCommands.Add(FString::Printf(TEXT("blueprint.set_preview_mesh(unreal.load_object(name='%s', outer=None))"),
		*PreviewMeshPath));
#endif

	InternalCommands.Append(GetRigVMAssetInterface()->IRigVMAssetInterface::GeneratePythonCommands(InNewBlueprintName));
	return InternalCommands;
}

void IControlRigAssetInterface::GetTypeActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const
{
	DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()

	IControlRigEditorModule::Get().GetTypeActions(FRigVMAssetInterfacePtr(const_cast<UObject*>(GetObject())), ActionRegistrar);
}

void IControlRigAssetInterface::GetInstanceActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const
{
	DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()

	IControlRigEditorModule::Get().GetInstanceActions(FRigVMAssetInterfacePtr(const_cast<UObject*>(GetObject())), ActionRegistrar);
}

void IControlRigAssetInterface::PostTransacted(const FTransactionObjectEvent& TransactionEvent)
{
	DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()

	if (TransactionEvent.GetEventType() == ETransactionObjectEventType::UndoRedo)
	{
		TArray<FName> PropertiesChanged = TransactionEvent.GetChangedProperties();
		int32 TransactionIndex = GEditor->Trans->FindTransactionIndex(TransactionEvent.GetTransactionId());
		const FTransaction* Transaction = GEditor->Trans->GetTransaction(TransactionIndex);
		if (Transaction && Transaction->ContainsObject(GetHierarchy()))
		{
			if (Transaction->GetTitle().BuildSourceString() == TEXT("Transform Gizmo"))
			{
				PropagatePoseFromBPToInstances();
				return;
			}

			PropagateHierarchyFromBPToInstances();

			// make sure the bone name list is up 2 date for the editor graph
			for (UEdGraph* Graph : GetRigVMAssetInterface()->GetUberGraphs())
			{
				UControlRigGraph* RigGraph = Cast<UControlRigGraph>(Graph);
				if (RigGraph == nullptr)
				{
					continue;
				}
				RigGraph->CacheNameLists(GetHierarchy(), &GetDrawContainer(), GetShapeLibraries());
			}

			GetRigVMAssetInterface()->RequestAutoVMRecompilation();
			(void) GetObject()->MarkPackageDirty();
		}

		if (PropertiesChanged.Contains(TEXT("ModularRigModel")))
		{
			if (IsModularRig())
			{
				GetModularRigModel().UpdateCachedChildren();
				GetModularRigModel().Connections.UpdateFromConnectionList();
				RecompileModularRig();
			}
		}
		
		if (PropertiesChanged.Contains(TEXT("DrawContainer")))
		{
			PropagateDrawInstructionsFromBPToInstances();
		}

		if (PropertiesChanged.Contains(TEXT("ArrayConnectionMap")))
		{
			PropagateHierarchyFromBPToInstances();
		}
	}
}

void IControlRigAssetInterface::PostDuplicate(bool bDuplicateForPIE)
{
	if (URigHierarchyController* Controller = GetHierarchy()->GetController(true))
	{
		Controller->OnModified().RemoveAll(this);
		Controller->OnModified().AddRaw(this, &IControlRigAssetInterface::HandleHierarchyModified);
	}

	if (UModularRigController* ModularController = GetModularRigModel().GetController())
	{
		ModularController->OnModified().RemoveAll(this);
		ModularController->OnModified().AddRaw(this, &IControlRigAssetInterface::HandleRigModulesModified);
	}

	// update the rig module identifier after save-as or duplicate asset
	if(IsControlRigModule())
	{
		const FString OldNameSpace = GetRigModuleSettings().Identifier.Name;
		GetRigModuleSettings().Identifier.Name = URigHierarchy::GetSanitizedName(FRigName(GetObject()->GetName())).ToString();
		UpdateConnectionMapAfterRename(OldNameSpace);
	}

	GetModularRigModel().UpdateCachedChildren();
	GetModularRigModel().Connections.UpdateFromConnectionList();
}

void IControlRigAssetInterface::PostRename(UObject* OldOuter, const FName OldName)
{
	// update the rig module identifier after renaming the asset
	if(IsControlRigModule())
	{
		const FString OldNameSpace = GetRigModuleSettings().Identifier.Name; 
		GetRigModuleSettings().Identifier.Name = URigHierarchy::GetSanitizedName(FRigName(GetObject()->GetName())).ToString();
		UpdateConnectionMapAfterRename(OldNameSpace);
	}
}

TArray<FControlRigAssetInterfacePtr> IControlRigAssetInterface::GetCurrentlyOpenRigAssets()
{
	return sCurrentlyOpenedRigBlueprints;
}

#if WITH_EDITOR

const FControlRigShapeDefinition* IControlRigAssetInterface::GetControlShapeByName(const FName& InName) const
{
	TMap<FString, FString> LibraryNameMap;
	if(const UControlRig* ControlRig = Cast<UControlRig>(GetObjectBeingDebugged()))
	{
		LibraryNameMap = ControlRig->ShapeLibraryNameMap;
	}
	return UControlRigShapeLibrary::GetShapeByName(InName, GetShapeLibraries(), LibraryNameMap);
}

FName IControlRigAssetInterface::AddTransientControl(const URigVMUnitNode* InNode, const FRigDirectManipulationTarget& InTarget)
{
	TUniquePtr<FControlValueScope> ValueScope;
	if (!UControlRigEditorSettings::Get()->bResetControlsOnPinValueInteraction) // if we need to retain the controls
	{
		ValueScope = MakeUnique<FControlValueScope>(GetObject());
	}

	// for now we only allow one pin control at the same time
	ClearTransientControls();

	FName ReturnName = NAME_None;
	TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(false, true);
	for (UObject* ArchetypeInstance : ArchetypeInstances)
	{
		UControlRig* InstancedControlRig = Cast<UControlRig>(ArchetypeInstance);
		if (InstancedControlRig)
		{
			FName ControlName = InstancedControlRig->AddTransientControl(InNode, InTarget);
			if (ReturnName.IsEqual(NAME_None))
			{
				ReturnName = ControlName;
			}
		}
	}

	return ReturnName;
}

FName IControlRigAssetInterface::RemoveTransientControl(const URigVMUnitNode* InNode, const FRigDirectManipulationTarget& InTarget)
{
	TUniquePtr<FControlValueScope> ValueScope;
	if (!UControlRigEditorSettings::Get()->bResetControlsOnPinValueInteraction) // if we need to retain the controls
	{
		ValueScope = MakeUnique<FControlValueScope>(GetObject());
	}

	FName RemovedName = NAME_None;
	TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(false, true);
	for (UObject* ArchetypeInstance : ArchetypeInstances)
	{
		UControlRig* InstancedControlRig = Cast<UControlRig>(ArchetypeInstance);
		if (InstancedControlRig)
		{
			FName Name = InstancedControlRig->RemoveTransientControl(InNode, InTarget);
			if (RemovedName.IsEqual(NAME_None))
	{
				RemovedName = Name;
			}
		}
	}

	return RemovedName;
}

FName IControlRigAssetInterface::AddTransientControl(const FRigElementKey& InElement)
{
	TUniquePtr<FControlValueScope> ValueScope;
	if (!UControlRigEditorSettings::Get()->bResetControlsOnPinValueInteraction) // if we need to retain the controls
	{
		ValueScope = MakeUnique<FControlValueScope>(GetObject());
	}
	FName ReturnName = NAME_None;
	TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(false, true);
	
	// hierarchy transforms will be reset when ClearTransientControls() is called,
	// so to retain any bone transform modifications we have to save them
	TMap<UObject*, FTransform> SavedElementLocalTransforms;
	for (UObject* ArchetypeInstance : ArchetypeInstances)
	{
		UControlRig* InstancedControlRig = Cast<UControlRig>(ArchetypeInstance);
		if (InstancedControlRig)
		{
			if (InstancedControlRig->DynamicHierarchy)
			{ 
				SavedElementLocalTransforms.FindOrAdd(InstancedControlRig) = InstancedControlRig->DynamicHierarchy->GetLocalTransform(InElement);
			}
		}
	}

	// for now we only allow one pin control at the same time
	ClearTransientControls();
	
	for (UObject* ArchetypeInstance : ArchetypeInstances)
	{
		UControlRig* InstancedControlRig = Cast<UControlRig>(ArchetypeInstance);
		if (InstancedControlRig)
		{
			// restore the element transforms so that transient controls are created at the right place
			if (const FTransform* SavedTransform = SavedElementLocalTransforms.Find(InstancedControlRig))
			{
				if (InstancedControlRig->DynamicHierarchy)
				{ 
					InstancedControlRig->DynamicHierarchy->SetLocalTransform(InElement, *SavedTransform);
				}
			}
			
			FName ControlName = InstancedControlRig->AddTransientControl(InElement);
			if (ReturnName.IsEqual(NAME_None))
			{
				ReturnName = ControlName;
			}
		}
	}

	return ReturnName;

}

FName IControlRigAssetInterface::RemoveTransientControl(const FRigElementKey& InElement)
{
	TUniquePtr<FControlValueScope> ValueScope;
	if (!UControlRigEditorSettings::Get()->bResetControlsOnPinValueInteraction) // if we need to retain the controls
	{
		ValueScope = MakeUnique<FControlValueScope>(GetObject());
	}

	FName RemovedName = NAME_None;
	TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(false, true);
	for (UObject* ArchetypeInstance : ArchetypeInstances)
	{
		UControlRig* InstancedControlRig = Cast<UControlRig>(ArchetypeInstance);
		if (InstancedControlRig)
		{
			FName Name = InstancedControlRig->RemoveTransientControl(InElement);
			if (RemovedName.IsEqual(NAME_None))
			{
				RemovedName = Name;
			}
		}
	}

	return RemovedName;
}

void IControlRigAssetInterface::ClearTransientControls()
{
	bool bHasAnyTransientControls = false;
	
	{
		TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(false, true);
		for (UObject* ArchetypeInstance : ArchetypeInstances)
		{
			UControlRig* InstancedControlRig = Cast<UControlRig>(ArchetypeInstance);
			if (InstancedControlRig)
			{
				if (URigHierarchy* InstanceHierarchy = InstancedControlRig->GetHierarchy())
				{
					if(!InstanceHierarchy->GetTransientControls().IsEmpty())
					{
						bHasAnyTransientControls = true;
						break;
					}
				}
			}
		}
	}

	if(!bHasAnyTransientControls)
	{
		return;
	}

	TUniquePtr<FControlValueScope> ValueScope;
	if (!UControlRigEditorSettings::Get()->bResetControlsOnPinValueInteraction) // if we need to retain the controls
	{
		ValueScope = MakeUnique<FControlValueScope>(GetObject());
	}

	{
		TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(false, true);
		for (UObject* ArchetypeInstance : ArchetypeInstances)
		{
			UControlRig* InstancedControlRig = Cast<UControlRig>(ArchetypeInstance);
			if (InstancedControlRig)
			{
				InstancedControlRig->ClearTransientControls();
			}
		}
	}
}

UModularRigController* IControlRigAssetInterface::GetModularRigController() 
{
	if (!GetControlRigClass()->IsChildOf(UModularRig::StaticClass()))
	{
		return nullptr;
	}

	return GetModularRigModel().GetController();
}

void IControlRigAssetInterface::RecompileModularRig()
{
	RefreshModuleConnectors();
	OnModularRigPreCompiled().Broadcast(GetRigVMAssetInterface());
	if (const UClass* MyControlRigClass = GetControlRigClass())
	{
		if (UModularRig* DefaultObject = Cast<UModularRig>(MyControlRigClass->GetDefaultObject(false)))
		{
			PropagateModuleHierarchyFromBPToInstances();
			RequestConstructionOnAllModules();
		}
	}
	UpdateModularDependencyDelegates();

#if WITH_EDITOR
	if(GetObjectBeingDebugged() == nullptr)
	{
		GetRigVMAssetInterface()->SetObjectBeingDebugged(CreateControlRig());
	}
#endif

	OnModularRigCompiled().Broadcast(GetRigVMAssetInterface());
}

#endif

void IControlRigAssetInterface::SetupDefaultObjectDuringCompilation(URigVMHost* InCDO)
{
	GetRigVMAssetInterface()->IRigVMAssetInterface::SetupDefaultObjectDuringCompilation(InCDO);
	CastChecked<UControlRig>(InCDO)->GetHierarchy()->CopyHierarchy(GetHierarchy());
}

void IControlRigAssetInterface::SetupPinRedirectorsForBackwardsCompatibility()
{
	for(URigVMGraph* Model : *GetRigVMClient())
	{
		for (URigVMNode* Node : Model->GetNodes())
		{
			if (URigVMUnitNode* UnitNode = Cast<URigVMUnitNode>(Node))
			{
				UScriptStruct* Struct = UnitNode->GetScriptStruct();
				if (Struct == FRigUnit_SetBoneTransform::StaticStruct())
				{
					URigVMPin* TransformPin = UnitNode->FindPin(TEXT("Transform"));
					URigVMPin* ResultPin = UnitNode->FindPin(TEXT("Result"));
					GetRigVMAssetInterface()->GetOrCreateController()->AddPinRedirector(false, true, TransformPin->GetPinPath(), ResultPin->GetPinPath());
				}
			}
		}
	}
}

void IControlRigAssetInterface::PathDomainSpecificContentOnLoad()
{
	PatchRigElementKeyCacheOnLoad();
	PatchPropagateToChildren();
}

void IControlRigAssetInterface::PatchRigElementKeyCacheOnLoad()
{
	if (GetObject()->GetLinkerCustomVersion(FControlRigObjectVersion::GUID) < FControlRigObjectVersion::RigElementKeyCache)
	{
		for (URigVMGraph* Graph : GetRigVMAssetInterface()->GetAllModels())
		{
			URigVMController* Controller = GetRigVMAssetInterface()->GetOrCreateController(Graph);
			TGuardValue<bool> DisablePinDefaultValueValidation(Controller->bValidatePinDefaults, false);
			FRigVMControllerNotifGuard NotifGuard(Controller, true);
			for (URigVMNode* Node : Graph->GetNodes())
			{
				if (URigVMUnitNode* UnitNode = Cast<URigVMUnitNode>(Node))
				{
					UScriptStruct* ScriptStruct = UnitNode->GetScriptStruct();
					FString FunctionName = FString::Printf(TEXT("%s::%s"), *ScriptStruct->GetStructCPPName(), *UnitNode->GetMethodName().ToString());
					const FRigVMFunction* Function = FRigVMRegistry::Get().FindFunction(*FunctionName);
					check(Function);
					for (TFieldIterator<FProperty> It(Function->Struct); It; ++It)
					{
						if (It->GetCPPType() == TEXT("FCachedRigElement"))
						{
							if (URigVMPin* Pin = Node->FindPin(It->GetName()))
							{
								int32 BoneIndex = FCString::Atoi(*Pin->GetDefaultValue());
								FRigElementKey Key = GetHierarchy()->GetKey(BoneIndex);
								FCachedRigElement DefaultValueElement(Key, GetHierarchy());
								FString Result;
								TBaseStructure<FCachedRigElement>::Get()->ExportText(Result, &DefaultValueElement, nullptr, nullptr, PPF_None, nullptr);								
								FRigVMDefaultValueTypeGuard _(Controller, ERigVMPinDefaultValueType::Override);
								Controller->SetPinDefaultValue(Pin->GetPinPath(), Result, true, false, false);
								GetRigVMAssetInterface()->MarkDirtyDuringLoad();
							}
						}
					}
				}
			}
		}
	}
}

// change the default value form False to True for transform nodes
void IControlRigAssetInterface::PatchPropagateToChildren()
{
	// no need to update default value past this version
	if (GetObject()->GetLinkerCustomVersion(FControlRigObjectVersion::GUID) >= FControlRigObjectVersion::RenameGizmoToShape)
	{
		return;
	}
	
	auto IsNullOrControl = [](const URigVMPin* InPin)
	{
		const bool bHasItem = InPin->GetCPPTypeObject() == FRigElementKey::StaticStruct() && InPin->GetName() == "Item";
		if (!bHasItem)
		{
			return false;
		}

		if (const URigVMPin* TypePin = InPin->FindSubPin(TEXT("Type")))
		{
			const FString& TypeValue = TypePin->GetDefaultValue();
			return TypeValue == TEXT("Null") || TypeValue == TEXT("Space") || TypeValue == TEXT("Control");
		}
		
		return false;
	};

	auto IsPropagateChildren = [](const URigVMPin* InPin)
	{
		return InPin->GetCPPType() == TEXT("bool") && InPin->GetName() == TEXT("bPropagateToChildren");
	};

	auto FindPropagatePin = [IsNullOrControl, IsPropagateChildren](const URigVMNode* InNode)-> URigVMPin*
	{
		URigVMPin* PropagatePin = nullptr;
		URigVMPin* ItemPin = nullptr;  
		for (URigVMPin* Pin: InNode->GetPins())
		{
			// look for Item pin
			if (!ItemPin && IsNullOrControl(Pin))
			{
				ItemPin = Pin;
			}

			// look for bPropagateToChildren pin
			if (!PropagatePin && IsPropagateChildren(Pin))
			{
				PropagatePin = Pin;
			}

			// return propagation pin if both found
			if (ItemPin && PropagatePin)
			{
				return PropagatePin;
			}
		}
		return nullptr;
	};

	for (URigVMGraph* Graph : GetRigVMAssetInterface()->GetAllModels())
	{
		TArray< const URigVMPin* > PinsToUpdate;
		for (const URigVMNode* Node : Graph->GetNodes())
		{
			if (const URigVMPin* PropagatePin = FindPropagatePin(Node))
			{
				PinsToUpdate.Add(PropagatePin);
			}
		}
		
		if (URigVMController* Controller = GetRigVMAssetInterface()->GetOrCreateController(Graph))
		{
			FRigVMControllerNotifGuard NotifGuard(Controller, true);
			for (const URigVMPin* Pin: PinsToUpdate)
			{
				Controller->SetPinDefaultValue(Pin->GetPinPath(), TEXT("True"), false, false, false);
			}
		}
	}
}

void IControlRigAssetInterface::CreateMemberVariablesOnLoad()
{
#if WITH_EDITOR

	const int32 LinkerVersion = GetObject()->GetLinkerCustomVersion(FControlRigObjectVersion::GUID);
	if (LinkerVersion < FControlRigObjectVersion::SwitchedToRigVM)
	{
		// ignore errors during the first potential compile of the VM
		// since that this point variable nodes may still be ill-formed.
		TGuardValue<FRigVMReportDelegate> SuspendReportDelegate(GetRigVMAssetInterface()->GetVMCompileSettings().ASTSettings.ReportDelegate,
			FRigVMReportDelegate::CreateLambda([](EMessageSeverity::Type,  UObject*, const FString&)
			{
				// do nothing
			})
		);
		GetRigVMAssetInterface()->InitializeModelIfRequired();
	}

	GetRigVMAssetInterface()->AddedMemberVariableMap.Reset();

	for (int32 VariableIndex = 0; VariableIndex < GetRigVMAssetInterface()->GetAssetVariables().Num(); VariableIndex++)
	{
		GetRigVMAssetInterface()->AddedMemberVariableMap.Add(GetRigVMAssetInterface()->GetAssetVariables()[VariableIndex].Name, VariableIndex);
	}

	if (GetRigVMClient()->Num() == 0)
	{
		return;
	}

	// setup variables on the blueprint based on the previous "parameters"
	if (GetObject()->GetLinkerCustomVersion(FControlRigObjectVersion::GUID) < FControlRigObjectVersion::BlueprintVariableSupport)
	{
		
		TSharedPtr<FRigVMNameValidator> NameValidator = MakeShareable(new FRigVMNameValidator(GetRigVMAssetInterface(), nullptr));

		auto CreateVariable = [this, NameValidator](const URigVMVariableNode* InVariableNode)
		{
			if (!InVariableNode)
			{
				return;
			}
			
			static const FString VariableString = TEXT("Variable");
			if (URigVMPin* VariablePin = InVariableNode->FindPin(VariableString))
			{
				if (VariablePin->GetDirection() != ERigVMPinDirection::Visible)
				{
					return;
				}
			}

			const FRigVMGraphVariableDescription Description = InVariableNode->GetVariableDescription();
			if (GetRigVMAssetInterface()->AddedMemberVariableMap.Contains(Description.Name))
			{
				return;
			}

			const FEdGraphPinType PinType = RigVMTypeUtils::PinTypeFromExternalVariable(Description.ToExternalVariable());
			if (!PinType.PinCategory.IsValid())
			{
				return;
			}

			const FName VarName = FindHostMemberVariableUniqueName(NameValidator, Description.Name.ToString());
			const FName ResultName = GetRigVMAssetInterface()->AddAssetVariableFromPinType(VarName, PinType, false, false, FString());
			if (ResultName != NAME_None)
			{
				TArray<FRigVMGraphVariableDescription> Variables = GetRigVMAssetInterface()->GetAssetVariables();
				for (int32 VariableIndex = 0; VariableIndex < Variables.Num(); VariableIndex++)
				{
					if (Variables[VariableIndex].Name == ResultName)
					{
						GetRigVMAssetInterface()->AddedMemberVariableMap.Add(Description.Name, VariableIndex);
						GetRigVMAssetInterface()->MarkDirtyDuringLoad();
						break;
					}
				}
			}
		};

		auto CreateParameter = [this, NameValidator](const URigVMParameterNode* InParameterNode)
		{
			if (!InParameterNode)
			{
				return;
			}

			static const FString ParameterString = TEXT("Parameter");
			if (const URigVMPin* ParameterPin = InParameterNode->FindPin(ParameterString))
			{
				if (ParameterPin->GetDirection() != ERigVMPinDirection::Visible)
				{
					return;
				}
			}

			const FRigVMGraphParameterDescription Description = InParameterNode->GetParameterDescription();
			if (GetRigVMAssetInterface()->AddedMemberVariableMap.Contains(Description.Name))
			{
				return;
			}

			const FName VarName = FindHostMemberVariableUniqueName(NameValidator, Description.Name.ToString());
			FRigVMExternalVariable ExternalVariable = Description.ToExternalVariable();
			ExternalVariable.Name = VarName;
			ExternalVariable.bIsPublic = true; // parameters get this set by default
			const FName ResultName = GetRigVMAssetInterface()->AddHostMemberVariableFromExternal(ExternalVariable, FString());
			if (!ResultName.IsNone())
			{
				TArray<FRigVMGraphVariableDescription> Variables = GetRigVMAssetInterface()->GetAssetVariables();
				for (int32 VariableIndex = 0; VariableIndex < Variables.Num(); VariableIndex++)
				{
					if (Variables[VariableIndex].Name == ResultName)
					{
						GetRigVMAssetInterface()->AddedMemberVariableMap.Add(Description.Name, VariableIndex);
						GetRigVMAssetInterface()->MarkDirtyDuringLoad();
						break;
					}
				}
			}
		};
		
		for (const URigVMGraph* Model : *GetRigVMClient())
		{
			const TArray<URigVMNode*>& Nodes = Model->GetNodes();
			for (const URigVMNode* Node : Nodes)
			{
				if (const URigVMVariableNode* VariableNode = Cast<URigVMVariableNode>(Node))
				{
					CreateVariable(VariableNode);
				}

				// Leaving this for backwards compatibility, even though we don't support parameters anymore
				// When a parameter node is found, we will create a variable
				else if (const URigVMParameterNode* ParameterNode = Cast<URigVMParameterNode>(Node))
				{
					CreateParameter(ParameterNode);
				}
			}
		}
	}

#endif
}

void IControlRigAssetInterface::PatchVariableNodesOnLoad()
{
#if WITH_EDITOR

	// setup variables on the blueprint based on the previous "parameters"
	if (GetObject()->GetLinkerCustomVersion(FControlRigObjectVersion::GUID) < FControlRigObjectVersion::BlueprintVariableSupport)
	{
		TGuardValue<bool> GuardNotifsSelf(GetRigVMAssetInterface()->bSuspendModelNotificationsForSelf, true);
		
		check(GetRigVMClient()->GetDefaultModel());

		auto PatchVariableNode = [this](const URigVMVariableNode* InVariableNode)
		{
			if (!InVariableNode)
			{
				return;
			}

			const FRigVMGraphVariableDescription Description = InVariableNode->GetVariableDescription();
			if (!GetRigVMAssetInterface()->AddedMemberVariableMap.Contains(Description.Name))
			{
				return;
			}
			
			const int32 VariableIndex = GetRigVMAssetInterface()->AddedMemberVariableMap.FindChecked(Description.Name);
			const FName VarName = GetRigVMAssetInterface()->GetAssetVariables()[VariableIndex].Name;
			
			GetRigVMAssetInterface()->GetOrCreateController()->RefreshVariableNode(
				InVariableNode->GetFName(), VarName, Description.CPPType, Description.CPPTypeObject, false);
			
			GetRigVMAssetInterface()->MarkDirtyDuringLoad();
		};

		auto PatchParameterNode = [this](const URigVMParameterNode* InParameterNode)
		{
			if (!InParameterNode)
			{
				return;
			}
			
			const FRigVMGraphParameterDescription Description = InParameterNode->GetParameterDescription();
			if (!GetRigVMAssetInterface()->AddedMemberVariableMap.Contains(Description.Name))
			{
				return;
			}

			const int32 VariableIndex = GetRigVMAssetInterface()->AddedMemberVariableMap.FindChecked(Description.Name);
			const FName VarName = GetRigVMAssetInterface()->GetAssetVariables()[VariableIndex].Name;
			
			GetRigVMAssetInterface()->GetOrCreateController()->ReplaceParameterNodeWithVariable(
				InParameterNode->GetFName(), VarName, Description.CPPType, Description.CPPTypeObject, false);

			GetRigVMAssetInterface()->MarkDirtyDuringLoad();	
		};
		
		for(const URigVMGraph* Model : *GetRigVMClient())
		{
			TArray<URigVMNode*> Nodes = Model->GetNodes();
			for (URigVMNode* Node : Nodes)
			{
				if (const URigVMVariableNode* VariableNode = Cast<URigVMVariableNode>(Node))
				{
					PatchVariableNode(VariableNode);
				}
				else if (const URigVMParameterNode* ParameterNode = Cast<URigVMParameterNode>(Node))
				{
					PatchParameterNode(ParameterNode);
				}
			}
		}
	}

#endif
}

void IControlRigAssetInterface::UpdateElementKeyRedirector(UControlRig* InControlRig) const
{
	InControlRig->HierarchySettings = GetHierarchySettings();
	InControlRig->RigModuleSettings = GetRigModuleSettings();
	if (URigHierarchy* RigHierarchy = InControlRig->GetHierarchy())
	{
		const FRigHierarchyNameSpaceWarningBracket SuspendNameSpaceWarnings(RigHierarchy); 
		InControlRig->ElementKeyRedirector = FRigElementKeyRedirector(GetArrayConnectionMap(), RigHierarchy);
	}
}

void IControlRigAssetInterface::PropagatePoseFromInstanceToBP(UControlRig* InControlRig) const
{
	check(InControlRig);
	// current transforms in BP and CDO are meaningless, no need to copy them
	// we use BP hierarchy to initialize CDO and instances' hierarchy, 
	// so it should always be in the initial state.
	GetHierarchy()->CopyPose(InControlRig->GetHierarchy(), false, true, false, true);
}

void IControlRigAssetInterface::PropagatePoseFromBPToInstances() const
{
	if (UClass* MyControlRigClass = GetRigVMAssetInterface()->GetRigVMGeneratedClass())
	{
		if (UControlRig* DefaultObject = Cast<UControlRig>(MyControlRigClass->GetDefaultObject(false)))
		{
			DefaultObject->PostInitInstanceIfRequired();
			DefaultObject->GetHierarchy()->CopyPose(GetHierarchy(), true, true, true);

			TArray<UObject*> ArchetypeInstances;
			DefaultObject->GetArchetypeInstances(ArchetypeInstances);
			for (UObject* ArchetypeInstance : ArchetypeInstances)
			{
				if (UControlRig* InstanceRig = Cast<UControlRig>(ArchetypeInstance))
				{
					InstanceRig->PostInitInstanceIfRequired();
					if(!InstanceRig->IsRigModuleInstance())
					{
						InstanceRig->GetHierarchy()->CopyPose(GetHierarchy(), true, true, true);
					}
				}
			}
		}
	}
}

void IControlRigAssetInterface::PropagateHierarchyFromBPToInstances() const
{
	if (UClass* MyControlRigClass = GetRigVMAssetInterface()->GetRigVMGeneratedClass())
	{
		if (UControlRig* DefaultObject = Cast<UControlRig>(MyControlRigClass->GetDefaultObject(false)))
		{
			DefaultObject->PostInitInstanceIfRequired();
			DefaultObject->GetHierarchy()->CopyHierarchy(GetHierarchy());

			UpdateElementKeyRedirector(DefaultObject);

			if (!DefaultObject->HasAnyFlags(RF_NeedPostLoad)) // If CDO is loading, skip Init, it will be done later
			{
				DefaultObject->Initialize(true);
			}

			TArray<UObject*> ArchetypeInstances;
			DefaultObject->GetArchetypeInstances(ArchetypeInstances);
			for (UObject* ArchetypeInstance : ArchetypeInstances)
			{
				if (UControlRig* InstanceRig = Cast<UControlRig>(ArchetypeInstance))
				{
					if (InstanceRig->IsRigModuleInstance())
					{
						if (UModularRig* ModularRig = Cast<UModularRig>(InstanceRig->GetOuter()))
						{
							ModularRig->RequestInit();
						}
					}
					else
					{
						InstanceRig->PostInitInstanceIfRequired();
						InstanceRig->GetHierarchy()->CopyHierarchy(GetHierarchy());
						InstanceRig->HierarchySettings = GetHierarchySettings();
						UpdateElementKeyRedirector(InstanceRig);
						InstanceRig->Initialize(true);
					}
				}
			}
		}
	}
}

void IControlRigAssetInterface::PropagateDrawInstructionsFromBPToInstances() const
{
	if (UClass* MyControlRigClass = GetRigVMAssetInterface()->GetRigVMGeneratedClass())
	{
		if (UControlRig* DefaultObject = Cast<UControlRig>(MyControlRigClass->GetDefaultObject(false)))
	{
			DefaultObject->DrawContainer = GetDrawContainer();

			TArray<UObject*> ArchetypeInstances;
			DefaultObject->GetArchetypeInstances(ArchetypeInstances);

			for (UObject* ArchetypeInstance : ArchetypeInstances)
			{
				if (UControlRig* InstanceRig = Cast<UControlRig>(ArchetypeInstance))
	{
					InstanceRig->DrawContainer = GetDrawContainer();
				}
			}
		}
	}


	// make sure the bone name list is up 2 date for the editor graph
	for (UEdGraph* Graph : GetRigVMAssetInterface()->GetUberGraphs())
	{
		UControlRigGraph* RigGraph = Cast<UControlRigGraph>(Graph);
		if (RigGraph == nullptr)
		{
			continue;
		}
		RigGraph->CacheNameLists(GetHierarchy(), &GetDrawContainer(), GetShapeLibraries());
	}
}

void IControlRigAssetInterface::PropagatePropertyFromBPToInstances(FRigElementKey InRigElement, const FProperty* InProperty) const
{
	int32 ElementIndex = GetHierarchy()->GetIndex(InRigElement);
	ensure(ElementIndex != INDEX_NONE);
	check(InProperty);

	if (UClass* MyControlRigClass = GetRigVMAssetInterface()->GetRigVMGeneratedClass())
	{
		if (UControlRig* DefaultObject = Cast<UControlRig>(MyControlRigClass->GetDefaultObject(false)))
		{
			TArray<UObject*> ArchetypeInstances;
			DefaultObject->GetArchetypeInstances(ArchetypeInstances);

			const int32 PropertyOffset = InProperty->GetOffset_ReplaceWith_ContainerPtrToValuePtr();
			const int32 PropertySize = InProperty->GetSize();

			uint8* Source = ((uint8*)GetHierarchy()->Get(ElementIndex)) + PropertyOffset;
			for (UObject* ArchetypeInstance : ArchetypeInstances)
			{
				if (UControlRig* InstanceRig = Cast<UControlRig>(ArchetypeInstance))
				{
					InstanceRig->PostInitInstanceIfRequired();
					uint8* Dest = ((uint8*)InstanceRig->GetHierarchy()->Get(ElementIndex)) + PropertyOffset;
					FMemory::Memcpy(Dest, Source, PropertySize);
				}
			}
		}
	}
}

void IControlRigAssetInterface::PropagatePropertyFromInstanceToBP(FRigElementKey InRigElement, const FProperty* InProperty, UControlRig* InInstance) const
{
	const int32 ElementIndex = GetHierarchy()->GetIndex(InRigElement);
	ensure(ElementIndex != INDEX_NONE);
	check(InProperty);

	const int32 PropertyOffset = InProperty->GetOffset_ReplaceWith_ContainerPtrToValuePtr();
	const int32 PropertySize = InProperty->GetSize();
	uint8* Source = ((uint8*)InInstance->GetHierarchy()->Get(ElementIndex)) + PropertyOffset;
	uint8* Dest = ((uint8*)GetHierarchy()->Get(ElementIndex)) + PropertyOffset;
	FMemory::Memcpy(Dest, Source, PropertySize);
}

void IControlRigAssetInterface::PropagateModuleHierarchyFromBPToInstances() const
{
	if (const UClass* MyControlRigClass = GetRigVMAssetInterface()->GetRigVMGeneratedClass())
	{
		if (UModularRig* DefaultObject = Cast<UModularRig>(MyControlRigClass->GetDefaultObject(false)))
		{
			// We need to first transfer the model from the blueprint to the CDO
			// We then ask instances to initialize which will provoke a call UModularRig::UpdateModuleHierarchyFromCDO
			
			DefaultObject->ResetModules();

			// copy the model over to the CDO.
			// non-CDO instances are going to instantiate the model into a
			// UObject module instance tree. CDO's are data only to avoid bugs / 
			// behaviors in the blueprint re-instancer - which is disregarding any
			// object under a CDO.
			DefaultObject->ModularRigModel = GetModularRigModel();
			DefaultObject->ModularRigModel.SetOuterClientHost(DefaultObject);
			DefaultObject->ModularRigSettings = GetModularRigSettings();
			
			TArray<UObject*> ArchetypeInstances;
			DefaultObject->GetArchetypeInstances(ArchetypeInstances);
			for (UObject* ArchetypeInstance : ArchetypeInstances)
			{
				if (UControlRig* InstanceRig = Cast<UControlRig>(ArchetypeInstance))
				{
					// this will provoke a call to InitializeFromCDO
					InstanceRig->Initialize(true);
				}
			}
		}
	}
}

void IControlRigAssetInterface::UpdateModularDependencyDelegates()
{
	TArray<FControlRigAssetInterfacePtr> VisitList;
	GetModularRigModel().ForEachModule([&VisitList, this](const FRigModuleReference* Element) -> bool
	{
		if(const UClass* Class = Element->Class.Get())
		{
			if(FControlRigAssetInterfacePtr ModuleBlueprint = Class->ClassGeneratedBy)
			{
				if(!VisitList.Contains(ModuleBlueprint))
				{
					ModuleBlueprint->GetRigVMAssetInterface()->OnVMCompiled().RemoveAll(GetObject());
					ModuleBlueprint->OnModularRigCompiled().RemoveAll(GetObject());
					ModuleBlueprint->GetRigVMAssetInterface()->OnVMCompiled().AddWeakLambda(GetObject(), [this](UObject* InModuleBlueprint, URigVM* InVM, FRigVMExtendedExecuteContext& InExecuteContext)
						{
							OnModularDependencyVMCompiled(InModuleBlueprint, InVM, InExecuteContext);
						});
					ModuleBlueprint->OnModularRigCompiled().AddWeakLambda(GetObject(), [this](FRigVMAssetInterfacePtr InModuleBlueprint)
						{
							OnModularDependencyChanged(InModuleBlueprint);
						});
					VisitList.Add(ModuleBlueprint);
				}
			}
		}
		return true;
	});
}

void IControlRigAssetInterface::OnModularDependencyVMCompiled(UObject* InModuleBlueprint, URigVM* InVM, FRigVMExtendedExecuteContext& InExecuteContext)
{
	if(URigVMBlueprint* RigVMBlueprint = Cast<URigVMBlueprint>(InModuleBlueprint))
	{
		OnModularDependencyChanged(FRigVMAssetInterfacePtr(RigVMBlueprint));
	}
}

void IControlRigAssetInterface::OnModularDependencyChanged(FRigVMAssetInterfacePtr InModuleBlueprint)
{
	RefreshModuleVariables();
	RefreshModuleConnectors();
	RecompileModularRig();
}

void IControlRigAssetInterface::RequestConstructionOnAllModules()
{
	// the rig will perform initialize itself - but we should request construction
	check(IsModularRig());

	TArray<UObject*> ArchetypeInstances = GetRigVMAssetInterface()->GetArchetypeInstances(false, true);

	// visit all or our instances and request construction
	for (UObject* Instance : ArchetypeInstances)
	{
		if (UModularRig* InstanceRig = Cast<UModularRig>(Instance))
		{
			InstanceRig->RequestConstruction();
		}
	}

}

void IControlRigAssetInterface::RefreshModuleVariables()
{
	if(!IsModularRig())
	{
		return;
	}

	if (UModularRigController* Controller = GetModularRigController())
	{
		Controller->RefreshModuleVariables(false);
	}
}

void IControlRigAssetInterface::RefreshModuleConnectors()
{
	if(!IsModularRig())
	{
		return;
	}

	if (UModularRigController* Controller = GetModularRigController())
	{
		TGuardValue<bool> NotificationsGuard(Controller->bSuspendNotifications, true);
		GetModularRigModel().ForEachModule([this](const FRigModuleReference* Element) -> bool
		{
			RefreshModuleConnectors(Element, false);
			return true;
		});
	}

	PropagateHierarchyFromBPToInstances();
}

void IControlRigAssetInterface::RefreshModuleConnectors(const FRigModuleReference* InModule, bool bPropagateHierarchy)
{
	if(!IsModularRig())
	{
		return;
	}

	// avoid dead class pointers
	if(InModule->Class.Get() == nullptr)
	{
		return;
	}
	
	const bool bRemoveAllConnectors = !GetModularRigModel().FindModule(InModule->Name);
	
	if (URigHierarchyController* Controller = GetHierarchyController())
	{
		if (UControlRig* CDO = GetControlRigClass()->GetDefaultObject<UControlRig>())
		{
			const TArray<FRigElementKey> AllConnectors = GetHierarchy()->GetKeysOfType<FRigConnectorElement>();
			TArray<FRigElementKey> ExistingConnectors = AllConnectors.FilterByPredicate([InModule, this](const FRigElementKey& ConnectorKey) -> bool
			{
				const FRigElementKey PatchedKey = ConnectorKey.ConvertToModuleNameFormat(&GetModularRigModel().PreviousModulePaths);
				const FRigHierarchyModulePath ConnectorModulePath(PatchedKey.Name);
				return ConnectorModulePath.HasModuleName(InModule->Name);
			});

			// setup the module information. this is needed so that newly added
			// connectors result in the right namespace metadata etc
			FRigVMExtendedExecuteContext& Context = CDO->GetRigVMExtendedExecuteContext();
			FControlRigExecuteContext& PublicContext = Context.GetPublicDataSafe<FControlRigExecuteContext>();
			const UControlRig* ModuleCDO = InModule->Class->GetDefaultObject<UControlRig>();
			const TArray<FRigModuleConnector>& ExpectedConnectors = ModuleCDO->GetRigModuleSettings().ExposedConnectors;

			// rename the connectors since their keys have been patched
			for(FRigElementKey& ConnectorKey : ExistingConnectors)
			{
				const FRigElementKey PatchedKey = ConnectorKey.ConvertToModuleNameFormat(&GetModularRigModel().PreviousModulePaths);
				if(ConnectorKey != PatchedKey)
				{
					ConnectorKey = Controller->RenameElement(ConnectorKey, PatchedKey.Name);
				}
			}

			// remove the obsolete connectors
			for(const FRigElementKey& ConnectorKey : ExistingConnectors)
			{
				const FRigHierarchyModulePath ConnectorModulePath(ConnectorKey.Name);
				const bool bConnectorExpected = ExpectedConnectors.ContainsByPredicate(
					[&ConnectorModulePath](const FRigModuleConnector& ExpectedConnector) -> bool
					{
						return ConnectorModulePath.HasElementName(ExpectedConnector.Name);
					}
				);

				if(bRemoveAllConnectors || !bConnectorExpected)
				{
					GetHierarchy()->Modify();
					(void)Controller->RemoveElement(ConnectorKey);
					GetArrayConnectionMap().Remove(ConnectorKey);
				}
			}

			// add the missing expected connectors
			if(!bRemoveAllConnectors)
			{
				for (const FRigModuleConnector& Connector : ExpectedConnectors)
				{
					const FName ConnectorName = *Connector.Name;
					const FRigHierarchyModulePath ConnectorModulePath(InModule->Name.ToString(), Connector.Name);
					const FRigElementKey CombinedConnectorKey(ConnectorModulePath.GetPathFName(), ERigElementType::Connector);
					if(!GetHierarchy()->Contains(CombinedConnectorKey))
					{
						const FString ModulePrefix = InModule->GetElementPrefix();
						const FString ParentModulePrefix = InModule->GetParentModule() ? InModule->GetParentModule()->GetElementPrefix() : ModulePrefix;
						const FString RootModulePrefix = InModule->GetRootModule() ? InModule->GetRootModule()->GetElementPrefix() : ModulePrefix;
						FRigHierarchyExecuteContextBracket HierarchyContextGuard(GetHierarchy(), &Context);
						FControlRigExecuteContextRigModuleGuard RigModuleGuard(PublicContext, ModulePrefix, ParentModulePrefix, RootModulePrefix);
						GetHierarchy()->Modify();
						(void)Controller->AddConnector(ConnectorName, Connector.Settings);
					}
					else
					{
						// copy the connector settings
						FRigConnectorElement* ExistingConnector = GetHierarchy()->FindChecked<FRigConnectorElement>(CombinedConnectorKey);
						ExistingConnector->Settings = Connector.Settings;
					}
				}
			}

			if (bPropagateHierarchy)
			{
				PropagateHierarchyFromBPToInstances();
			}
		}
	}
}

void IControlRigAssetInterface::HandleHierarchyModified(ERigHierarchyNotification InNotification, URigHierarchy* InHierarchy, const FRigNotificationSubject& InSubject)
{
#if WITH_EDITOR

	if(GetRigVMAssetInterface()->bSuspendAllNotifications)
	{
		return;
	}

	const FRigBaseElement* InElement = InSubject.Element;
	const FRigBaseComponent* InComponent = InSubject.Component;

	switch(InNotification)
	{
		case ERigHierarchyNotification::ElementRemoved:
		{
			Modify();
			GetInfluences().OnKeyRemoved(InElement->GetKey());
			PropagateHierarchyFromBPToInstances();
			break;
		}
		case ERigHierarchyNotification::ElementRenamed:
		{
			Modify();
			if(InElement)
			{
				const FName PreviousName = InHierarchy->GetPreviousHierarchyName(InElement->GetKey());
				const FRigElementKey OldKey(PreviousName, InElement->GetType());
				HandleHierarchyElementKeyChanged(OldKey, InElement->GetKey());
			}
			break;
		}
		case ERigHierarchyNotification::ElementAdded:
		case ERigHierarchyNotification::ParentChanged:
		case ERigHierarchyNotification::ElementReordered:
		case ERigHierarchyNotification::HierarchyReset:
		case ERigHierarchyNotification::ComponentAdded:
		case ERigHierarchyNotification::ComponentRemoved:
		case ERigHierarchyNotification::ComponentContentChanged:
		{
			Modify();
			PropagateHierarchyFromBPToInstances();
			break;
		}
		case ERigHierarchyNotification::ComponentRenamed:
		{
			Modify();
			if(InComponent)
			{
				const FName PreviousName = InHierarchy->GetPreviousHierarchyName(InComponent->GetKey());
				const FRigComponentKey OldKey(InComponent->GetElementKey(), PreviousName);
				HandleHierarchyComponentKeyChanged(OldKey, InComponent->GetKey());
			}
			break;
		}
		case ERigHierarchyNotification::ComponentReparented:
		{
			Modify();
			if(InComponent)
			{
				const FRigHierarchyKey PreviousParent = InHierarchy->GetPreviousHierarchyParent(InComponent->GetKey());
				if(PreviousParent.IsElement())
				{
					const FRigComponentKey OldKey(PreviousParent.GetElement(), InComponent->GetFName());
					HandleHierarchyComponentKeyChanged(OldKey, InComponent->GetKey());
				}
			}
			break;
		}
		case ERigHierarchyNotification::ElementSelected:
		{
			bool bClearTransientControls = true;
			if (const FRigControlElement* ControlElement = Cast<FRigControlElement>(InElement))
			{
				if (ControlElement->Settings.bIsTransientControl)
				{
					bClearTransientControls = false;
				}
			}

			if(bClearTransientControls)
			{
				if(UControlRig* RigBeingDebugged = Cast<UControlRig>(GetObjectBeingDebugged()))
				{
					const FName TransientControlName = UControlRig::GetNameForTransientControl(InElement->GetKey());
					const FRigElementKey TransientControlKey(TransientControlName, ERigElementType::Control);
					if (const FRigControlElement* ControlElement = RigBeingDebugged->GetHierarchy()->Find<FRigControlElement>(TransientControlKey))
					{
						if (ControlElement->Settings.bIsTransientControl)
						{
							bClearTransientControls = false;
						}
					}
				}
			}

			if(bClearTransientControls)
			{
				ClearTransientControls();
			}
			break;
		}
		case ERigHierarchyNotification::ElementDeselected:
		{
			if (const FRigControlElement* ControlElement = Cast<FRigControlElement>(InElement))
			{
				if (ControlElement->Settings.bIsTransientControl)
				{
					ClearTransientControls();
				}
			}
			break;
		}
		default:
		{
			break;
		}
	}

	HierarchyModifiedEvent.Broadcast(InNotification, InHierarchy, InElement);
	
#endif
}

void IControlRigAssetInterface::HandleHierarchyElementKeyChanged(const FRigElementKey& InOldKey, const FRigElementKey& InNewKey)
{
	if(InOldKey == InNewKey)
	{
		return;
	}
	
	static UEnum* RigElementTypeEnum = StaticEnum<ERigElementType>();
	check(RigElementTypeEnum);

	const FString OldNameStr = InOldKey.Name.ToString();
	const FString NewNameStr = InNewKey.Name.ToString();
	const ERigElementType ElementType = InNewKey.Type; 

	// update all of the graphs with the new key
	TArray<UEdGraph*> EdGraphs;
	GetRigVMAssetInterface()->GetAllEdGraphs(EdGraphs);
	for (UEdGraph* Graph : EdGraphs)
	{
		URigVMEdGraph* RigGraph = Cast<URigVMEdGraph>(Graph);
		if (RigGraph == nullptr)
		{
			continue;
		}

		URigVMController* Controller = RigGraph->GetController();
		if(Controller == nullptr)
		{
			continue;
		}

		{
			FRigVMBlueprintCompileScope CompileScope(GetObject());
			for (UEdGraphNode* Node : RigGraph->Nodes)
			{
				if (URigVMEdGraphNode* RigNode = Cast<URigVMEdGraphNode>(Node))
				{
					if (URigVMNode* ModelNode = RigNode->GetModelNode())
					{
						TArray<URigVMPin*> ModelPins = ModelNode->GetAllPinsRecursively();
						for (URigVMPin * ModelPin : ModelPins)
						{
							if(ModelPin->GetCPPType() == RigVMTypeUtils::FNameType)
							{
								if ((ModelPin->GetCustomWidgetName() == TEXT("BoneName") && ElementType == ERigElementType::Bone) ||
									(ModelPin->GetCustomWidgetName() == TEXT("ControlName") && ElementType == ERigElementType::Control) ||
									(ModelPin->GetCustomWidgetName() == TEXT("SpaceName") && ElementType == ERigElementType::Null) ||
									(ModelPin->GetCustomWidgetName() == TEXT("CurveName") && ElementType == ERigElementType::Curve) ||
									(ModelPin->GetCustomWidgetName() == TEXT("ConnectorName") && ElementType == ERigElementType::Connector))
								{
									if (ModelPin->GetDefaultValue() == OldNameStr)
									{
										Controller->SetPinDefaultValue(ModelPin->GetPinPath(), NewNameStr, false);
									}
								}
							}
							else if (ModelPin->GetCPPTypeObject() == FRigElementKey::StaticStruct())
							{
								const FString OldDefaultValueString = ModelPin->GetDefaultValue();
								FRigElementKey OldDefaultKey;
								FRigElementKey::StaticStruct()->ImportText(*OldDefaultValueString, &OldDefaultKey, nullptr, EPropertyPortFlags::PPF_None, nullptr, FRigElementKey::StaticStruct()->GetName(), true);

								if(OldDefaultKey == InOldKey)
								{
									FString NewDefaultKeyString;
									FRigElementKey::StaticStruct()->ExportText(NewDefaultKeyString, &InNewKey, nullptr, nullptr, PPF_ExternalEditor, nullptr);
									Controller->SetPinDefaultValue(ModelPin->GetPinPath(), NewDefaultKeyString, false);
								}
							}
						}
					}
				}
			}
		}
	}

	// update all of the influences
	GetInfluences().OnKeyRenamed(InOldKey, InNewKey);
	if (IsControlRigModule() && InNewKey.Type == ERigElementType::Connector)
	{
		if (FRigElementKeyCollection* Targets = GetArrayConnectionMap().Find(InOldKey))
		{
			GetArrayConnectionMap().FindOrAdd(InNewKey, *Targets);
			GetArrayConnectionMap().Remove(InOldKey);
		}
	}
	
	PropagateHierarchyFromBPToInstances();
}

void IControlRigAssetInterface::HandleHierarchyComponentKeyChanged(const FRigComponentKey& InOldKey, const FRigComponentKey& InNewKey)
{
	if(InOldKey == InNewKey)
	{
		return;
	}
	
	// update all of the graphs with the new key
	TArray<UEdGraph*> EdGraphs;
	GetRigVMAssetInterface()->GetAllEdGraphs(EdGraphs);
	for (UEdGraph* Graph : EdGraphs)
	{
		URigVMEdGraph* RigGraph = Cast<URigVMEdGraph>(Graph);
		if (RigGraph == nullptr)
		{
			continue;
		}

		URigVMController* Controller = RigGraph->GetController();
		if(Controller == nullptr)
		{
			continue;
		}

		{
			FRigVMBlueprintCompileScope CompileScope(GetObject());
			for (UEdGraphNode* Node : RigGraph->Nodes)
			{
				if (URigVMEdGraphNode* RigNode = Cast<URigVMEdGraphNode>(Node))
				{
					if (URigVMNode* ModelNode = RigNode->GetModelNode())
					{
						TArray<URigVMPin*> ModelPins = ModelNode->GetAllPinsRecursively();
						for (URigVMPin * ModelPin : ModelPins)
						{
							if (ModelPin->GetCPPTypeObject() == FRigComponentKey::StaticStruct())
							{
								const FString OldDefaultValueString = ModelPin->GetDefaultValue();
								FRigComponentKey OldDefaultKey;
								FRigComponentKey::StaticStruct()->ImportText(*OldDefaultValueString, &OldDefaultKey, nullptr, EPropertyPortFlags::PPF_None, nullptr, FRigComponentKey::StaticStruct()->GetName(), true);

								if(OldDefaultKey == InOldKey)
								{
									FString NewDefaultKeyString;
									FRigComponentKey::StaticStruct()->ExportText(NewDefaultKeyString, &InNewKey, nullptr, nullptr, PPF_ExternalEditor, nullptr);
									Controller->SetPinDefaultValue(ModelPin->GetPinPath(), NewDefaultKeyString, false);
								}
							}
						}
					}
				}
			}
		}
	}

	PropagateHierarchyFromBPToInstances();
}

void IControlRigAssetInterface::HandleRigModulesModified(EModularRigNotification InNotification, const FRigModuleReference* InModule)
{
	bool bRecompile = true;
	switch (InNotification)
	{
		case EModularRigNotification::ModuleAdded:
		{
			if (InModule)
			{
				RefreshModuleConnectors(InModule);
				UpdateModularDependencyDelegates();
			}
			break;
		}
		case EModularRigNotification::ModuleRenamed:
		case EModularRigNotification::ModuleReparented:
		case EModularRigNotification::ModuleReordered:
		{
			if (InModule)
			{
				if (URigHierarchyController* Controller = GetHierarchyController())
				{
					if (UControlRig* CDO = GetControlRigClass()->GetDefaultObject<UControlRig>())
					{
						GetHierarchy()->Modify();
						
						struct ConnectionInfo
						{
							FString NewPath;
							FRigElementKeyCollection TargetConnections;
							FRigConnectorSettings Settings;
						};
						const FName OldModuleName = InModule->PreviousName;
						const FName NewModuleName = InModule->Name;
						
						TArray<FRigElementKey> Connectors = Controller->GetHierarchy()->GetKeysOfType<FRigConnectorElement>();
						TMap<FRigElementKey, ConnectionInfo> RenamedConnectors; // old key -> new key
						for (const FRigElementKey& Connector : Connectors)
						{
							const FRigHierarchyModulePath ConnectorModulePath(Connector.Name);
							if (ConnectorModulePath.HasModuleName(OldModuleName))
							{
								ConnectionInfo& Info = RenamedConnectors.FindOrAdd(Connector);
								Info.NewPath = ConnectorModulePath.ReplaceModuleName(NewModuleName);
								Info.Settings = CastChecked<FRigConnectorElement>(Controller->GetHierarchy()->FindChecked(Connector))->Settings;
								if (FRigElementKeyCollection* TargetKeys = GetArrayConnectionMap().Find(Connector))
								{
									Info.TargetConnections = *TargetKeys;
								}
							}
						}

						// Remove connectors
						for (TPair<FRigElementKey, ConnectionInfo>& Pair : RenamedConnectors)
						{
							Controller->RemoveElement(Pair.Key);
						}

						// Add connectors
						{
							FRigVMExtendedExecuteContext& Context = CDO->GetRigVMExtendedExecuteContext();
							FRigHierarchyExecuteContextBracket HierarchyContextGuard(Controller->GetHierarchy(), &Context);
							FControlRigExecuteContext& PublicContext = Context.GetPublicDataSafe<FControlRigExecuteContext>();
							for (TPair<FRigElementKey, ConnectionInfo>& Pair : RenamedConnectors)
							{
								const FName ConnectorName = FRigHierarchyModulePath(Pair.Value.NewPath).GetElementFName();
								const FString ModulePrefix = InModule->GetElementPrefix();
								const FString ParentModulePrefix = InModule->GetParentModule() ? InModule->GetParentModule()->GetElementPrefix() : ModulePrefix;
								const FString RootModulePrefix = InModule->GetRootModule() ? InModule->GetRootModule()->GetElementPrefix() : ModulePrefix;
								
								FControlRigExecuteContextRigModuleGuard RigModuleGuard(PublicContext, ModulePrefix, ParentModulePrefix, RootModulePrefix);
								const TGuardValue<bool> DisableErrors(Controller->bReportWarningsAndErrors, false);
								Controller->AddConnector(ConnectorName, Pair.Value.Settings);
							}
						}

						// update the target connections
						TMap<FRigElementKey, FRigElementKeyCollection> PreviousArrayConnectionMap;
						Swap(PreviousArrayConnectionMap, GetArrayConnectionMap());
						GetArrayConnectionMap().Reset();
						for(TPair<FRigElementKey, FRigElementKeyCollection>& Connection : PreviousArrayConnectionMap)
						{
							FRigElementKey ConnectorKey = Connection.Key;
							FRigElementKeyCollection& TargetKeys = Connection.Value;

							FRigHierarchyModulePath ConnectorPath(ConnectorKey.Name);
							if(ConnectorPath.ReplaceModuleNameInline(OldModuleName, NewModuleName))
							{
								ConnectorKey.Name = ConnectorPath.GetPathFName();
							}
							
							for(FRigElementKey& TargetKey : TargetKeys.Keys)
							{
								FRigHierarchyModulePath TargetPath(TargetKey.Name);
								if(TargetPath.ReplaceModuleNameInline(OldModuleName, NewModuleName))
								{
									TargetKey.Name = TargetPath.GetPathFName();
								}
							}
							GetArrayConnectionMap().Add(ConnectorKey, TargetKeys);
						}

						// update the previous module table
						for(TPair<FRigHierarchyModulePath,FName>& ModulePathToName : GetModularRigModel().PreviousModulePaths)
						{
							if(ModulePathToName.Value == OldModuleName)
							{
								Modify();
								ModulePathToName.Value = NewModuleName;
							}
						}

						UpdateConnectionMapFromModel();
						PropagateHierarchyFromBPToInstances();
					}
				}
			}
			break;
		}
		case EModularRigNotification::ModuleRemoved:
		{
			if (InModule)
			{
				RefreshModuleConnectors(InModule);
				UpdateConnectionMapFromModel();
				UpdateModularDependencyDelegates();
			}
			break;
		}
		case EModularRigNotification::ConnectionChanged:
		{
			GetHierarchy()->Modify();
			
			UpdateConnectionMapFromModel();
			HierarchyModifiedEvent.Broadcast(ERigHierarchyNotification::HierarchyReset, GetHierarchy(), {});
			break;
		}
		case EModularRigNotification::ModuleClassChanged:
		{
			if (InModule)
			{
				RefreshModuleConnectors(InModule);
				UpdateConnectionMapFromModel();
			}
			break;
		}
		case EModularRigNotification::ModuleShortNameChanged:
		{
			bRecompile = false;
			break;
		}
		case EModularRigNotification::ModuleConfigValueChanged:
		{
			bRecompile = false;
			PropagateModuleHierarchyFromBPToInstances();
			RequestConstructionOnAllModules();
			break;
		}
		case EModularRigNotification::InteractionBracketOpened:
		{
			ModulesRecompilationBracket++;
			break;
		}
		case EModularRigNotification::InteractionBracketClosed:
		case EModularRigNotification::InteractionBracketCanceled:
		{
			ModulesRecompilationBracket--;
			break;
		}
		case EModularRigNotification::ModuleSelected:
		case EModularRigNotification::ModuleDeselected:
		{
			// don't do anything during selection
			return;
		}
		default:
		{
			break;
		}
	}

	if (bRecompile && ModulesRecompilationBracket == 0)
	{
		RecompileModularRig();
	}
}

IControlRigAssetInterface::FControlValueScope::FControlValueScope(FControlRigAssetInterfacePtr InBlueprint)
: Blueprint(InBlueprint)
{
#if WITH_EDITOR
	check(Blueprint);

	if (UControlRig* CR = Cast<UControlRig>(Blueprint->GetObjectBeingDebugged()))
	{
		TArray<FRigControlElement*> Controls = CR->AvailableControls();
		for (FRigControlElement* ControlElement : Controls)
		{
			ControlValues.Add(ControlElement->GetFName(), CR->GetControlValue(ControlElement->GetFName()));
		}
	}
#endif
}

IControlRigAssetInterface::FControlValueScope::~FControlValueScope()
{
#if WITH_EDITOR
	check(Blueprint);

	if (UControlRig* CR = Cast<UControlRig>(Blueprint->GetObjectBeingDebugged()))
	{
		for (const TPair<FName, FRigControlValue>& Pair : ControlValues)
		{
			if (CR->FindControl(Pair.Key))
			{
				CR->SetControlValue(Pair.Key, Pair.Value);
			}
		}
	}
#endif
}

#undef LOCTEXT_NAMESPACE