public void Perform(AssetList list, BaseObject source = null, BaseObject target = null)
{
switch (_mode)
{
case Mode.Source:
if (source != null)
{
if (_operator == Operator.Add)
{
list.Add(source);
}
else
{
list.Remove(source);
}
}
break;
case Mode.Target:
if (target != null)
{
if (_operator == Operator.Add)
{
list.Add(target);
}
else
{
list.Remove(target);
}
}
break;
case Mode.AssetList:
if (_assetList != null)
{
if (_operator == Operator.Add)
{
list.AddRange(_assetList);
}
else
{
list.RemoveRange(_assetList);
}
}
break;
}
}
internal static bool CheckoutAndValidateVCSFiles(IEnumerable <string> files)
{
// We're only interested in files that would be under VCS, i.e. project
// assets or local packages. Incoming paths might use backward slashes; replace with
// forward ones as that's what Unity/VCS functions operate on.
files = files.Select(f => f.Replace('\\', '/')).Where(Provider.PathIsVersioned).ToArray();
var assetList = new AssetList();
assetList.AddRange(files.Select(Provider.GetAssetByPath));
// Verify that all the files are also in assetList
// This is required to ensure the copy temp files to destination loop is only working on version controlled files
// Provider.GetAssetByPath() can fail i.e. the asset database GUID can not be found for the input asset path
foreach (var assetPath in files)
{
var foundAsset = assetList.Where(asset => (asset?.path == assetPath));
if (!foundAsset.Any())
{
Debug.LogErrorFormat("[API Updater] Files cannot be updated (failed to add file to list): {0}", assetPath);
APIUpdaterManager.ReportExpectedUpdateFailure();
return(false);
}
}
var checkoutTask = Provider.Checkout(assetList, CheckoutMode.Exact);
checkoutTask.Wait();
// Verify that all the files we need to operate on are now editable according to version control
// One of these states:
// 1) UnderVersionControl & CheckedOutLocal
// 2) UnderVersionControl & AddedLocal
// 3) !UnderVersionControl
var notEditable = assetList.Where(asset => asset.IsUnderVersionControl && !asset.IsState(Asset.States.CheckedOutLocal) && !asset.IsState(Asset.States.AddedLocal));
if (!checkoutTask.success || notEditable.Any())
{
Debug.LogErrorFormat("[API Updater] Files cannot be updated (failed to check out): {0}", notEditable.Select(a => a.fullName + " (" + a.state + ")").Aggregate((acc, curr) => acc + Environment.NewLine + "\t" + curr));
APIUpdaterManager.ReportExpectedUpdateFailure();
return(false);
}
return(true);
}
static AssetList GetStatusForceUpdate(List <string> fromPaths)
{
var task = Provider.Status(fromPaths.ToArray());
task.Wait();
if (!task.success)
{
return(null);
}
// Status task might return more items in the list (e.g. meta files),
// and return them out of order too. Make sure to return proper sized
// and in-order list back.
var taskResultList = task.assetList;
var result = new AssetList {
Capacity = fromPaths.Count
};
result.AddRange(fromPaths.Select(path => taskResultList.SingleOrDefault(a => a.path == path)));
return(result);
}
void UpgradeMaterials()
{
// upgrade material template assets
var assetList = new AssetList();
assetList.AddRange(
AssetDatabase.FindAssets($"t:{nameof(PhysicsMaterialTemplate)}")
.Select(guid => AssetDatabase.GUIDToAssetPath(guid))
.Select(path => new Asset(path))
);
if (assetList.Count > 0)
{
if (IsEditable(assetList, m_Failures))
{
foreach (var asset in assetList)
{
if (!IsEditable(asset, m_Failures))
{
continue;
}
// material templates are upgraded in OnEnable(), so it should be sufficient to merely load them
var materialTemplate = AssetDatabase.LoadAssetAtPath <PhysicsMaterialTemplate>(asset.path);
EditorUtility.SetDirty(materialTemplate);
m_Successes.AddEntry(asset.path, string.Empty);
}
}
}
// upgrade prefabs
assetList.Clear();
foreach (var guid in AssetDatabase.FindAssets("t:Prefab"))
{
var prefabAssetPath = AssetDatabase.GUIDToAssetPath(guid);
var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(prefabAssetPath);
var shapeComponents = prefab.GetComponentsInChildren <PhysicsShapeAuthoring>(true);
if (shapeComponents.Length == 0)
{
continue;
}
var asset = new Asset(prefabAssetPath);
if (!IsEditable(asset, m_Failures))
{
continue;
}
assetList.Add(asset);
}
if (assetList.Count > 0)
{
if (IsEditable(assetList, m_Failures))
{
var upgradedAssets = new HashSet <Asset>();
foreach (var asset in assetList)
{
UpgradePrefabAsset(asset, assetList, upgradedAssets, m_Successes, m_Failures);
}
}
}
// update scene objects
EditorSceneManager.SetActiveScene(EditorSceneManager.NewScene(NewSceneSetup.EmptyScene));
foreach (var guid in AssetDatabase.FindAssets("t:Scene"))
{
var scenePath = AssetDatabase.GUIDToAssetPath(guid);
var asset = new Asset(scenePath);
if (!IsEditable(asset, m_Failures))
{
continue;
}
Scene scene;
try { scene = EditorSceneManager.OpenScene(scenePath); }
catch (Exception e)
{
m_Failures.AddEntry(asset.path, $"{e.Message}\n\n{e.StackTrace}");
continue;
}
EditorSceneManager.SetActiveScene(scene);
var succcess = true;
if (IsEditable(new AssetList {
new Asset(scenePath)
}, m_Failures))
{
var upgradedAny = false;
foreach (
var sceneObject in scene.GetRootGameObjects()
.Where(go => go.GetComponentsInChildren <PhysicsShapeAuthoring>(true).Any())
)
{
try
{
UpgradePrefabInstance(sceneObject);
upgradedAny = true;
}
catch (Exception e)
{
succcess = false;
m_Failures.AddEntry(
$"{scenePath}::{AnimationUtility.CalculateTransformPath(sceneObject.transform, sceneObject.transform.root)}",
$"{e.Message}\n\n{e.StackTrace}"
);
}
}
if (upgradedAny)
{
EditorSceneManager.SaveScene(scene);
}
}
if (succcess)
{
m_Successes.AddEntry(scenePath, string.Empty);
}
EditorSceneManager.SetActiveScene(EditorSceneManager.NewScene(NewSceneSetup.EmptyScene));
EditorSceneManager.CloseScene(scene, true);
}
}
private QueryResult ParseAssetListQueryResult(XmlElement element, Query query) {
var list = new AssetList();
var total = int.Parse(element.GetAttribute("total"));
var assetnodes = element.SelectNodes("Asset");
list.AddRange(from XmlElement assetnode in assetnodes select ParseAssetNode(assetnode));
if(query.ParentRelation != null) {
list = TreeAssetListByAttribute(list, query.ParentRelation);
}
return new QueryResult(list, total, query);
}
