using System.Collections.Generic;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.SceneManagement;
namespace Unity.AI.Navigation.Updater
{
#pragma warning disable 618
internal static class OffMeshLinkUpdaterUtility
{
/// <summary>
/// A structure holding the information of failed conversions.
/// </summary>
public struct FailedConversion
{
public int itemIndex;
public string failureMessage;
}
/// <summary>
/// Find all prefabs and scenes that contain OffMeshLink components.
/// This method also finds Prefab Variants which has removed OffMeshLink components.
/// </summary>
/// <param name="searchInFolders">Folders to search for prefabs and scenes. If null, the whole project is searched.</param>
/// <returns>List of asset GUIDs to convert.</returns>
public static List<string> FindObjectsToConvert(string[] searchInFolders = null)
{
var prefabGuids = AssetDatabase.FindAssets("t:Prefab", searchInFolders);
var objectsToConvert = new HashSet<string>();
foreach (var guid in prefabGuids)
{
var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(AssetDatabase.GUIDToAssetPath(guid));
if (prefab.GetComponentsInChildren<OffMeshLink>(true).Length > 0)
objectsToConvert.Add(guid);
var isPrefabVariant = PrefabUtility.IsPartOfVariantPrefab(prefab);
if (isPrefabVariant)
{
var removedComponents = PrefabUtility.GetRemovedComponents(prefab);
foreach (var removedComponent in removedComponents)
{
if (removedComponent.assetComponent is OffMeshLink)
{
objectsToConvert.Add(guid);
break;
}
}
}
}
var sceneGuids = AssetDatabase.FindAssets("t:Scene", searchInFolders);
foreach (var guid in sceneGuids)
{
var scenePath = AssetDatabase.GUIDToAssetPath(guid);
var scene = EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Additive);
var rootGameObjects = scene.GetRootGameObjects();
foreach (var rootGameObject in rootGameObjects)
{
var offMeshLinksInHierarchy = rootGameObject.GetComponentsInChildren<OffMeshLink>(true);
if (offMeshLinksInHierarchy.Length == 0)
continue;
var offMeshLinks = FindAllOffMeshLinksInHierarchy(rootGameObject);
if (offMeshLinks.Count > 0)
{
objectsToConvert.Add(guid);
break;
}
}
CloseScene(scene);
}
var returnList = new List<string>(objectsToConvert);
return returnList;
}
static void CloseScene(Scene scene)
{
// EditorSceneManager does not support closing the last scene, so we open a new empty scene instead.
if (EditorSceneManager.loadedSceneCount == 1)
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
else
EditorSceneManager.CloseScene(scene, true);
}
/// <summary>
/// Convert all objects in the list to use NavMeshLink instead of OffMeshLink.
/// </summary>
/// <param name="objectsToConvert">List of asset GUIDs to convert.</param>
/// <param name="failedConversions">List of failed conversions.</param>
public static void Convert(List<string> objectsToConvert, out List<FailedConversion> failedConversions)
{
failedConversions = new List<FailedConversion>();
var offMeshLinkToNavMeshLink = new Dictionary<OffMeshLink, NavMeshLink>();
var failedToConvert = new HashSet<string>();
// Initial sorting of objects to convert.
// We want to deal with source prefabs first, then their variants, so that the NavMeshLink components are created in the correct order.
SortAssetsToConvert(objectsToConvert);
// First convert, create NavMeshLink with OffMeshLink values
foreach (var guid in objectsToConvert)
{
var pathToObject = AssetDatabase.GUIDToAssetPath(guid);
if (!DoesAssetExistOnDisk(pathToObject))
{
failedToConvert.Add(guid);
failedConversions.Add(new FailedConversion
{
itemIndex = objectsToConvert.IndexOf(guid),
failureMessage =
$"Cannot find the asset at path {pathToObject}. Please make sure the file exists."
});
continue;
}
if (!CanWriteToAsset(pathToObject))
{
failedToConvert.Add(guid);
failedConversions.Add(new FailedConversion
{
itemIndex = objectsToConvert.IndexOf(guid),
failureMessage =
$"Cannot write to the asset at path {pathToObject}. Please make sure the file is not read-only."
});
continue;
}
if (TryGetPrefabFromPath(pathToObject, out var prefab))
ConvertPrefab(prefab, offMeshLinkToNavMeshLink);
else if (TryGetSceneFromPath(pathToObject, out var scene))
{
ConvertScene(scene, ref offMeshLinkToNavMeshLink);
CloseScene(scene);
}
}
// Remove failed conversions
foreach (var guid in failedToConvert)
objectsToConvert.Remove(guid);
// Second convert, apply prefab overrides to NavMeshLink
foreach (var guid in objectsToConvert)
{
var pathToObject = AssetDatabase.GUIDToAssetPath(guid);
if (TryGetPrefabFromPath(pathToObject, out var prefab))
{
ApplyOverrideDataToPrefab(prefab, offMeshLinkToNavMeshLink);
SyncOverriddenRemovalsOfComponents(prefab, offMeshLinkToNavMeshLink);
}
else if (TryGetSceneFromPath(pathToObject, out var scene))
{
ApplyOverrideDataToScene(scene, offMeshLinkToNavMeshLink);
CloseScene(scene);
}
}
// Remove OffMeshLinks from the objects
foreach (var guid in objectsToConvert)
{
var pathToObject = AssetDatabase.GUIDToAssetPath(guid);
if (TryGetPrefabFromPath(pathToObject, out var prefab))
{
var offMeshLinks = prefab.GetComponentsInChildren<OffMeshLink>(true);
foreach (var offMeshLink in offMeshLinks)
Object.DestroyImmediate(offMeshLink, true);
// Since we are removing components in source prefabs, we have to "revert removed components"
// on prefab instances, so that we don't store the removal data in the meta files.
if (PrefabUtility.IsAnyPrefabInstanceRoot(prefab))
RevertRemovedComponent(prefab);
PrefabUtility.SavePrefabAsset(prefab);
}
else if (TryGetSceneFromPath(pathToObject, out var scene))
{
var rootGameObjects = scene.GetRootGameObjects();
foreach (var rootGameObject in rootGameObjects)
{
var offMeshLinks = rootGameObject.GetComponentsInChildren<OffMeshLink>(true);
foreach (var offMeshLink in offMeshLinks)
Object.DestroyImmediate(offMeshLink, true);
}
EditorSceneManager.SaveScene(scene);
CloseScene(scene);
}
}
}
/// <summary>
/// Sorts the list of objects to convert so that source prefabs are first.
/// </summary>
/// <param name="objectsToConvert">List of asset GUIDs to convert.</param>
static void SortAssetsToConvert(List<string> objectsToConvert)
{
var sortedAssetGuids = new List<string>(objectsToConvert.Count);
for (var i = 0; i < objectsToConvert.Count; i++)
{
var assetGuid = objectsToConvert[i];
if (sortedAssetGuids.Contains(assetGuid))
continue;
var prefabGameObject =
AssetDatabase.LoadAssetAtPath<GameObject>(AssetDatabase.GUIDToAssetPath(assetGuid));
if (prefabGameObject == null)
sortedAssetGuids.Add(assetGuid);
else
SortPrefabsToConvert(sortedAssetGuids, prefabGameObject, assetGuid);
}
objectsToConvert.Clear();
objectsToConvert.AddRange(sortedAssetGuids);
}
static void SortPrefabsToConvert(List<string> objectsToConvert, GameObject prefabRoot, string prefabRootGuid)
{
if (objectsToConvert.Contains(prefabRootGuid))
return;
var source = PrefabUtility.GetCorrespondingObjectFromSource(prefabRoot);
if (source == null)
{
objectsToConvert.Add(prefabRootGuid);
return;
}
var sourceGuid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(source));
SortPrefabsToConvert(objectsToConvert, source, sourceGuid);
objectsToConvert.Add(prefabRootGuid);
}
static void RevertRemovedComponent(GameObject prefab)
{
var removedComponents = PrefabUtility.GetRemovedComponents(prefab);
if (removedComponents == null)
return;
foreach (var removedComponent in removedComponents)
{
if (removedComponent.assetComponent is OffMeshLink)
PrefabUtility.RevertRemovedComponent(prefab, removedComponent.assetComponent,
InteractionMode.AutomatedAction);
}
}
static bool TryGetPrefabFromPath(string path, out GameObject prefab)
{
prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
return prefab != null && PrefabUtility.IsPartOfPrefabAsset(prefab);
}
static bool TryGetSceneFromPath(string path, out Scene scene)
{
var sceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(path);
if (sceneAsset != null)
{
scene = EditorSceneManager.OpenScene(path, OpenSceneMode.Additive);
return true;
}
scene = default;
return false;
}
static List<OffMeshLink> FindAllOffMeshLinksInHierarchy(GameObject rootGameObject)
{
var arr = rootGameObject.GetComponentsInChildren<OffMeshLink>(true);
var offMeshLinks = new List<OffMeshLink>(arr);
for (var i = offMeshLinks.Count - 1; i >= 0; i--)
{
var gameObject = offMeshLinks[i].gameObject;
if (PrefabUtility.IsAnyPrefabInstanceRoot(gameObject) && gameObject != rootGameObject)
offMeshLinks.RemoveAt(i);
}
return offMeshLinks;
}
static void ConvertPrefab(GameObject prefabRoot, Dictionary<OffMeshLink, NavMeshLink> offMeshLinkToNavMeshLink)
{
var offMeshLinks = FindAllOffMeshLinksInHierarchy(prefabRoot);
var updatedPrefab = false;
foreach (var offMeshLink in offMeshLinks)
{
var gameObject = offMeshLink.gameObject;
var isPrefabVariant = PrefabUtility.IsPartOfVariantPrefab(gameObject);
// If the prefab is a variant and the OffMeshLink is not an override,
// only store the variant's OffMeshLink and NavMeshLink pair, and skip the rest of the conversion.
if (isPrefabVariant && !PrefabUtility.IsAddedComponentOverride(offMeshLink))
{
var sourceOml = PrefabUtility.GetCorrespondingObjectFromSource(offMeshLink);
var sourceNML = offMeshLinkToNavMeshLink[sourceOml];
var variantNML = GetCorrespondingVariantComponent(sourceNML, prefabRoot);
offMeshLinkToNavMeshLink.Add(offMeshLink, variantNML);
continue;
}
var navMeshLink = gameObject.AddComponent<NavMeshLink>();
offMeshLinkToNavMeshLink.Add(offMeshLink, navMeshLink);
// If the OffMeshLink is an override (created by a Prefab Variant), record the new NavMeshLink as an override.
if (isPrefabVariant)
PrefabUtility.RecordPrefabInstancePropertyModifications(gameObject);
CopyValues(offMeshLink, navMeshLink);
updatedPrefab = true;
}
if (updatedPrefab)
PrefabUtility.SavePrefabAsset(prefabRoot);
}
static void ConvertScene(Scene scene, ref Dictionary<OffMeshLink, NavMeshLink> offMeshLinkToNavMeshLink)
{
var rootGameObjects = scene.GetRootGameObjects();
foreach (var rootGameObject in rootGameObjects)
{
// Skip prefab instances, they are taken care of in the ConvertPrefab method.
if (PrefabUtility.IsAnyPrefabInstanceRoot(rootGameObject))
continue;
var offMeshLinks = FindAllOffMeshLinksInHierarchy(rootGameObject);
foreach (var offMeshLink in offMeshLinks)
{
var navMeshLink = offMeshLink.gameObject.AddComponent<NavMeshLink>();
offMeshLinkToNavMeshLink.Add(offMeshLink, navMeshLink);
CopyValues(offMeshLink, navMeshLink);
}
}
EditorSceneManager.SaveScene(scene);
}
static bool CanWriteToAsset(string filePath)
{
var fileInfo = new System.IO.FileInfo(filePath);
return !fileInfo.Attributes.HasFlag(System.IO.FileAttributes.ReadOnly);
}
static bool DoesAssetExistOnDisk(string filePath)
{
return !string.IsNullOrEmpty(filePath) && System.IO.File.Exists(filePath);
}
static void CopyValues(OffMeshLink offMeshLink, NavMeshLink navMeshLink)
{
navMeshLink.activated = offMeshLink.activated;
navMeshLink.autoUpdate = offMeshLink.autoUpdatePositions;
navMeshLink.bidirectional = offMeshLink.biDirectional;
navMeshLink.costModifier = offMeshLink.costOverride;
navMeshLink.startTransform = offMeshLink.startTransform;
navMeshLink.endTransform = offMeshLink.endTransform;
}
/// <summary>
/// Transfers any existing override data from OffMeshLink components to NavMeshLink components.
/// </summary>
/// <param name="outerPrefabRoot">The out-most prefab root</param>
/// <param name="offMeshLinkToNavMeshLink">Dictionary storing the OffMeshLink and NavMeshLink pairs</param>
static void ApplyOverrideDataToPrefab(GameObject outerPrefabRoot,
Dictionary<OffMeshLink, NavMeshLink> offMeshLinkToNavMeshLink)
{
var didUpdate = false;
var updatedRoots = new HashSet<GameObject>();
var offMeshLinks = outerPrefabRoot.GetComponentsInChildren<OffMeshLink>(true);
foreach (var offMeshLink in offMeshLinks)
{
// Find the prefab root and check if we have already updated it.
// A null root means that the root is the outerPrefabRoot.
var rootGameObject = PrefabUtility.GetNearestPrefabInstanceRoot(offMeshLink.gameObject);
rootGameObject = rootGameObject == null ? offMeshLink.gameObject : rootGameObject;
if (updatedRoots.Contains(rootGameObject))
continue;
var propertyModifications = PrefabUtility.GetPropertyModifications(rootGameObject);
if (propertyModifications == null)
continue;
UpdatePropertyModifications(ref propertyModifications, offMeshLinkToNavMeshLink);
PrefabUtility.SetPropertyModifications(rootGameObject, propertyModifications);
updatedRoots.Add(rootGameObject);
didUpdate = true;
}
if (didUpdate)
PrefabUtility.SavePrefabAsset(outerPrefabRoot);
}
/// <summary>
/// Removes the NavMeshLink components that correspond to OffMeshLink components that were removed from the variant prefab.
/// </summary>
static void SyncOverriddenRemovalsOfComponents(GameObject prefabRoot,
IReadOnlyDictionary<OffMeshLink, NavMeshLink> offMeshLinkToNavMeshLink)
{
var isPrefabVariant = PrefabUtility.IsPartOfVariantPrefab(prefabRoot);
if (!isPrefabVariant)
return;
var removedComponents = PrefabUtility.GetRemovedComponents(prefabRoot);
var variantNavMeshLinks = prefabRoot.GetComponents<NavMeshLink>();
foreach (var removedComponent in removedComponents)
{
if (removedComponent.assetComponent is not OffMeshLink removedOffMeshLink)
continue;
var sourceNavMeshLink = offMeshLinkToNavMeshLink[removedOffMeshLink];
foreach (var variantComponent in variantNavMeshLinks)
{
var correspondingComponent = PrefabUtility.GetCorrespondingObjectFromSource(variantComponent);
if (correspondingComponent == sourceNavMeshLink)
{
Object.DestroyImmediate(variantComponent, true);
break;
}
}
}
PrefabUtility.RecordPrefabInstancePropertyModifications(prefabRoot);
PrefabUtility.SavePrefabAsset(prefabRoot);
}
static void ApplyOverrideDataToScene(Scene scene, Dictionary<OffMeshLink, NavMeshLink> offMeshLinkToNavMeshLink)
{
var rootGameObjects = scene.GetRootGameObjects();
var updatedRoots = new HashSet<GameObject>();
foreach (var rootGameObject in rootGameObjects)
{
var offMeshLinks = rootGameObject.GetComponentsInChildren<OffMeshLink>();
foreach (var offMeshLink in offMeshLinks)
{
// Non-prefab instances cannot have overrides, so continue.
if (!PrefabUtility.IsPartOfAnyPrefab(offMeshLink))
continue;
// Find the prefab root and check if it contains any overrides
var prefabRoot = PrefabUtility.GetNearestPrefabInstanceRoot(offMeshLink.gameObject);
if (!PrefabUtility.HasPrefabInstanceAnyOverrides(prefabRoot, false) &&
!updatedRoots.Contains(prefabRoot))
continue;
var propertyModifications = PrefabUtility.GetPropertyModifications(prefabRoot);
UpdatePropertyModifications(ref propertyModifications, offMeshLinkToNavMeshLink);
PrefabUtility.SetPropertyModifications(prefabRoot, propertyModifications);
updatedRoots.Add(prefabRoot);
}
}
EditorSceneManager.SaveScene(scene);
}
static void UpdatePropertyModifications(ref PropertyModification[] propertyModifications,
Dictionary<OffMeshLink, NavMeshLink> offMeshLinkToNavMeshLink)
{
var updatedModifications = new List<PropertyModification>(propertyModifications);
for (var i = 0; i < propertyModifications.Length; ++i)
{
var modification = propertyModifications[i];
// Skip if the target is not an OffMeshLink
if (modification.target is not OffMeshLink oml)
{
updatedModifications.Add(modification);
continue;
}
// Get the NavMeshLink that corresponds to the OffMeshLink.
var navMeshLink = offMeshLinkToNavMeshLink[oml];
var newMod = new PropertyModification
{
target = navMeshLink,
value = modification.value
};
switch (modification.propertyPath)
{
case "m_AutoUpdatePositions":
newMod.propertyPath = "m_AutoUpdatePosition";
break;
case "m_CostOverride":
newMod.propertyPath = "m_CostModifier";
if (float.TryParse(newMod.value, out var floatVal))
{
if (floatVal > 0)
{
var overrideMod = new PropertyModification()
{
target = navMeshLink,
propertyPath = "m_IsOverridingCost",
value = "1"
};
updatedModifications.Add(overrideMod);
}
}
break;
case "m_BiDirectional":
newMod.propertyPath = "m_Bidirectional";
break;
case "m_Start":
newMod.propertyPath = "m_StartTransform";
break;
case "m_End":
newMod.propertyPath = "m_EndTransform";
break;
case "m_Activated":
newMod.propertyPath = modification.propertyPath;
break;
}
updatedModifications.Add(newMod);
}
propertyModifications = updatedModifications.ToArray();
}
/// <summary>
/// Get the corresponding variant component of a source prefab component.
/// </summary>
/// <param name="component">The source prefab component</param>
/// <param name="variantPrefab">The variant prefab</param>
/// <typeparam name="TComponent">The type of component to search for</typeparam>
/// <returns>Returns the corresponding component on the variant of the source prefab component, if found, or null.</returns>
static TComponent GetCorrespondingVariantComponent<TComponent>(TComponent component, GameObject variantPrefab)
where TComponent : Component
{
var variantComponents = variantPrefab.GetComponents(component.GetType());
foreach (var variantComponent in variantComponents)
{
var correspondingComponent = PrefabUtility.GetCorrespondingObjectFromSource(variantComponent);
if (correspondingComponent == component)
return variantComponent as TComponent;
}
return null;
}
}
#pragma warning restore 618
}