Merge branch 'stabilization/2106' into mbalfour/gitflow_210622

# Conflicts:
#	Code/Framework/AzQtComponents/AzQtComponents/Components/Style.cpp
#	Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h
#	Gems/AWSCore/Code/Source/Editor/UI/AWSCoreEditorMenu.cpp

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp

@@ -524,8 +524,6 @@ namespace AzToolsFramework
                                 rootSpawnableIndex = m_playInEditorData.m_assets.size();
                             }
 
-                            LoadReferencedAssets(product.GetReferencedAssets());
-
                             AZ::Data::AssetInfo info;
                             info.m_assetId = product.GetAsset().GetId();
                             info.m_assetType = product.GetAssetType();
@@ -534,6 +532,19 @@ namespace AzToolsFramework
                             AZ::Data::AssetCatalogRequestBus::Broadcast(
                                 &AZ::Data::AssetCatalogRequestBus::Events::RegisterAsset, info.m_assetId, info);
                             m_playInEditorData.m_assets.emplace_back(product.ReleaseAsset().release(), AZ::Data::AssetLoadBehavior::Default);
+
+                            // Ensure the product asset is registered with the AssetManager
+                            // Hold on to the returned asset to keep ref count alive until we assign it the latest data
+                            AZ::Data::Asset<AZ::Data::AssetData> asset =
+                                AZ::Data::AssetManager::Instance().FindOrCreateAsset(info.m_assetId, info.m_assetType, AZ::Data::AssetLoadBehavior::Default);
+
+                            // Update the asset registered in the AssetManager with the data of our product from the Prefab Processor
+                            AZ::Data::AssetManager::Instance().AssignAssetData(m_playInEditorData.m_assets.back());
+                        }
+
+                        for (auto& product : context.GetProcessedObjects())
+                        {
+                            LoadReferencedAssets(product.GetReferencedAssets());
                         }
 
                         // make sure that PRE_NOTIFY assets get their notify before we activate, so that we can preserve the order of 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/Instance.cpp

@@ -326,6 +326,16 @@ namespace AzToolsFramework
             return *(m_nestedInstances[newInstanceAlias] = std::move(instance));
         }
 
+        void Instance::DetachNestedInstances(const AZStd::function<void(AZStd::unique_ptr<Instance>)>& callback)
+        {
+            for (auto&& [instanceAlias, instance] : m_nestedInstances)
+            {
+                instance->m_parent = nullptr;
+                callback(AZStd::move(instance));
+            }
+            m_nestedInstances.clear();
+        }
+
         AZStd::unique_ptr<Instance> Instance::DetachNestedInstance(const InstanceAlias& instanceAlias)
         {
             AZStd::unique_ptr<Instance> removedNestedInstance;

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/Instance.h

@@ -103,6 +103,7 @@ namespace AzToolsFramework
             Instance& AddInstance(AZStd::unique_ptr<Instance> instance);
             Instance& AddInstance(AZStd::unique_ptr<Instance> instance, InstanceAlias instanceAlias);
             AZStd::unique_ptr<Instance> DetachNestedInstance(const InstanceAlias& instanceAlias);
+            void DetachNestedInstances(const AZStd::function<void(AZStd::unique_ptr<Instance>)>& callback);
 
             /**
             * Gets the aliases for the entities in the Instance DOM.

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabLoader.cpp

@@ -151,6 +151,10 @@ namespace AzToolsFramework
                 return InvalidTemplateId;
             }
 
+            // Add or replace the Source parameter in the dom
+            PrefabDomPath sourcePath = PrefabDomPath((AZStd::string("/") + PrefabDomUtils::SourceName).c_str());
+            sourcePath.Set(readPrefabFileResult.GetValue(), relativePath.Native().c_str());
+
             // Create new Template with the Prefab DOM.
             TemplateId newTemplateId = m_prefabSystemComponentInterface->AddTemplate(relativePath, readPrefabFileResult.TakeValue());
             if (newTemplateId == InvalidTemplateId)

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp

@@ -922,8 +922,8 @@ namespace AzToolsFramework
                 return AZ::Failure(AZStd::string("Failed to duplicate : Couldn't get a valid owning instance for the common root entity of the entities provided."));
             }
 
-            // If the first entity id is a container entity id, then we need to mark its parent as the common owning instance because you
-            // cannot duplicate an instance from itself.
+            // If the first entity id is a container entity id, then we need to mark its parent as the common owning instance
+            // This is because containers, despite representing the nested instance in the parent, are owned by the child.
             if (commonOwningInstance->get().GetContainerEntityId() == firstEntityIdToDuplicate)
             {
                 commonOwningInstance = commonOwningInstance->get().GetParentInstance();
@@ -967,17 +967,18 @@ namespace AzToolsFramework
 
                 // Duplicate any nested entities and instances as requested
                 AZStd::unordered_map<InstanceAlias, Instance*> newInstanceAliasToOldInstanceMap;
+                AZStd::unordered_map<EntityAlias, EntityAlias> duplicateEntityAliasMap;
                 DuplicateNestedEntitiesInInstance(commonOwningInstance->get(),
-                    entities, instanceDomAfter, duplicatedEntityAndInstanceIds);
-                DuplicateNestedInstancesInInstance(commonOwningInstance->get(),
-                    instances, instanceDomAfter, duplicatedEntityAndInstanceIds,
-                    newInstanceAliasToOldInstanceMap);
+                    entities, instanceDomAfter, duplicatedEntityAndInstanceIds, duplicateEntityAliasMap);
 
                 PrefabUndoInstance* command = aznew PrefabUndoInstance("Entity/Instance duplication");
                 command->SetParent(undoBatch.GetUndoBatch());
                 command->Capture(instanceDomBefore, instanceDomAfter, commonOwningInstance->get().GetTemplateId());
                 command->Redo();
 
+                DuplicateNestedInstancesInInstance(commonOwningInstance->get(),
+                    instances, instanceDomAfter, duplicatedEntityAndInstanceIds, newInstanceAliasToOldInstanceMap);
+
                 // Create links for our duplicated instances (if any were duplicated)
                 for (auto [newInstanceAlias, oldInstance] : newInstanceAliasToOldInstanceMap)
                 {
@@ -995,8 +996,35 @@ namespace AzToolsFramework
                     PrefabDom linkPatchesCopy;
                     linkPatchesCopy.CopyFrom(linkPatches->get(), linkPatchesCopy.GetAllocator());
 
-                    m_prefabSystemComponentInterface->CreateLink(
-                        commonOwningInstance->get().GetTemplateId(), oldInstance->GetTemplateId(), newInstanceAlias, linkPatchesCopy);
+                    // If the instance was duplicated as part of an ancestor's nested hierarchy, the container's parent patch
+                    // will need to be refreshed to point to the new duplicated parent entity
+                    auto oldInstanceContainerEntityId = oldInstance->GetContainerEntityId();
+                    AZ_Assert(oldInstanceContainerEntityId.IsValid(), "Instance returned invalid Container Entity Id");
+
+                    AZ::EntityId previousParentEntityId;
+                    AZ::TransformBus::EventResult(previousParentEntityId, oldInstanceContainerEntityId, &AZ::TransformBus::Events::GetParentId);
+
+                    if (previousParentEntityId.IsValid() && AZStd::find(duplicatedEntityAndInstanceIds.begin(), duplicatedEntityAndInstanceIds.end(), previousParentEntityId))
+                    {
+                        auto oldParentAlias = commonOwningInstance->get().GetEntityAlias(previousParentEntityId);
+                        if (oldParentAlias.has_value() && duplicateEntityAliasMap.contains(oldParentAlias->get()))
+                        {
+                            // Get the dom into a QString for search/replace purposes
+                            rapidjson::StringBuffer buffer;
+                            rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+                            linkPatchesCopy.Accept(writer);
+
+                            QString linkPatchesString(buffer.GetString());
+
+                            ReplaceOldAliases(linkPatchesString, oldParentAlias->get(), duplicateEntityAliasMap[oldParentAlias->get()]);
+
+                            linkPatchesCopy.Parse(linkPatchesString.toUtf8().constData());
+                        }
+                    }
+
+                    PrefabUndoHelpers::CreateLink(
+                        oldInstance->GetTemplateId(), commonOwningInstance->get().GetTemplateId(),
+                        AZStd::move(linkPatchesCopy), newInstanceAlias, undoBatch.GetUndoBatch());
                 }
 
                 // Select the duplicated entities/instances
@@ -1211,25 +1239,23 @@ namespace AzToolsFramework
 
                     const auto instanceTemplateId = instancePtr->GetTemplateId();
                     auto parentContainerEntityId = parentInstance.GetContainerEntityId();
-                    instancePtr->GetNestedInstances(
-                        [&](AZStd::unique_ptr<Instance>& nestedInstancePtr)
+
+                    instancePtr->DetachNestedInstances(
+                        [&](AZStd::unique_ptr<Instance> detachedNestedInstance)
                     {
-                        //get previous link patch
-                        auto linkRef = m_prefabSystemComponentInterface->FindLink(nestedInstancePtr->GetLinkId());
-                        PrefabDomValueReference linkPatches = linkRef->get().GetLinkPatches();
-                        AZ_Assert(
-                            linkPatches.has_value(), "Unable to get patches on link with id '%llu' during prefab creation.",
-                            nestedInstancePtr->GetLinkId());
+                        PrefabDom& nestedInstanceTemplateDom =
+                            m_prefabSystemComponentInterface->FindTemplateDom(detachedNestedInstance->GetTemplateId());
 
-                        PrefabDom linkPatchesCopy;
-                        linkPatchesCopy.CopyFrom(linkPatches->get(), linkPatchesCopy.GetAllocator());
-
-                        RemoveLink(nestedInstancePtr, instanceTemplateId, undoBatch.GetUndoBatch());
-
-                        UpdateLinkPatchesWithNewEntityAliases(linkPatchesCopy, oldEntityAliases, parentInstance);
+                        Instance& nestedInstanceUnderNewParent = parentInstance.AddInstance(AZStd::move(detachedNestedInstance));
                         
-                        CreateLink(*nestedInstancePtr, parentTemplateId, undoBatch.GetUndoBatch(),
-                            AZStd::move(linkPatchesCopy), true);
+                        PrefabDom nestedInstanceDomUnderNewParent;
+                        m_instanceToTemplateInterface->GenerateDomForInstance(
+                            nestedInstanceDomUnderNewParent, nestedInstanceUnderNewParent);
+                        PrefabDom reparentPatch;
+                        m_instanceToTemplateInterface->GeneratePatch(
+                            reparentPatch, nestedInstanceTemplateDom, nestedInstanceDomUnderNewParent);
+                        
+                        CreateLink(nestedInstanceUnderNewParent, parentTemplateId, undoBatch.GetUndoBatch(), AZStd::move(reparentPatch), true);
                     });
                 }
 
@@ -1509,14 +1535,13 @@ namespace AzToolsFramework
 
         void PrefabPublicHandler::DuplicateNestedEntitiesInInstance(Instance& commonOwningInstance,
             const AZStd::vector<AZ::Entity*>& entities, PrefabDom& domToAddDuplicatedEntitiesUnder,
-            EntityIdList& duplicatedEntityIds)
+            EntityIdList& duplicatedEntityIds, AZStd::unordered_map<EntityAlias, EntityAlias>& oldAliasToNewAliasMap)
         {
             if (entities.empty())
             {
                 return;
             }
 
-            AZStd::unordered_map<EntityAlias, EntityAlias> oldAliasToNewAliasMap;
             AZStd::unordered_map<EntityAlias, QString> aliasToEntityDomMap;
 
             for (AZ::Entity* entity : entities)

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h

@@ -87,7 +87,7 @@ namespace AzToolsFramework
              */
             void DuplicateNestedEntitiesInInstance(Instance& commonOwningInstance,
                 const AZStd::vector<AZ::Entity*>& entities, PrefabDom& domToAddDuplicatedEntitiesUnder,
-                EntityIdList& duplicatedEntityIds);
+                EntityIdList& duplicatedEntityIds, AZStd::unordered_map<EntityAlias, EntityAlias>& oldAliasToNewAliasMap);
             /**
              * Duplicate a list of instances owned by a common owning instance by directly
              * copying/modifying their entries in the instance DOM

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Template/Template.cpp

@@ -207,6 +207,10 @@ namespace AzToolsFramework
                 instanceValue->CopyFrom(linkDom, m_prefabDom.GetAllocator());
             }
 
+            // Remove Source parameter from the dom. It will be added on file load, and should not be stored to disk.
+            PrefabDomPath sourcePath = PrefabDomPath((AZStd::string("/") + PrefabDomUtils::SourceName).c_str());
+            sourcePath.Erase(output);
+
             return true;
         }
 

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorNonUniformScaleComponent.cpp

@@ -13,6 +13,7 @@
 #include <AzCore/Math/ToString.h>
 #include <AzCore/Math/Transform.h>
 #include <AzCore/Serialization/EditContext.h>
+#include <AzCore/RTTI/BehaviorContext.h>
 #include <AzFramework/Components/NonUniformScaleComponent.h>
 #include <AzToolsFramework/ToolsComponents/EditorNonUniformScaleComponent.h>
 
@@ -57,6 +58,13 @@ namespace AzToolsFramework
                         ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly);
                 }
             }
+
+            if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+            {
+                behaviorContext->ConstantProperty("EditorNonUniformScaleComponentTypeId", BehaviorConstant(EditorNonUniformScaleComponent::RTTI_Type()))
+                    ->Attribute(AZ::Script::Attributes::Module, "editor")
+                    ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Automation);
+            }
         }
 
         void EditorNonUniformScaleComponent::GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent)

Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h

@@ -214,7 +214,11 @@ namespace AzToolsFramework
         class ViewportSettingNotifications
         {
         public:
-            virtual void OnGridSnappingChanged(bool enabled) = 0;
+            virtual void OnGridSnappingChanged([[maybe_unused]] bool enabled) {}
+            virtual void OnDrawHelpersChanged([[maybe_unused]] bool enabled) {}
+
+        protected:
+            ViewportSettingNotifications() = default;
         };
 
         using ViewportSettingsNotificationBus = AZ::EBus<ViewportSettingNotifications, ViewportEBusTraits>;