629 lines
25 KiB
C#
629 lines
25 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using UnityEngine.U2D.Animation;
|
|
using UnityEngine.U2D.Common;
|
|
|
|
namespace UnityEditor.U2D.Animation.Upgrading
|
|
{
|
|
internal class AnimClipUpgrader : BaseUpgrader
|
|
{
|
|
static class Contents
|
|
{
|
|
public static readonly string ProgressBarTitle = L10n.Tr("Upgrading Animation Clips");
|
|
public static readonly string VerifyingSelection = L10n.Tr("Verifying the selection");
|
|
public static readonly string UpgradingSpriteKeys = L10n.Tr("Upgrading Sprite Keys");
|
|
public static readonly string UpgradingCategoryLabelHash = L10n.Tr("Upgrading Category and Label hashes");
|
|
}
|
|
|
|
enum HashType
|
|
{
|
|
Label,
|
|
Category,
|
|
SpriteKey,
|
|
SpriteHash
|
|
}
|
|
|
|
class BindingData
|
|
{
|
|
public string BindingPath;
|
|
public System.Type BindingType;
|
|
public List<KeyData> RawKeys;
|
|
public List<ConvertedKeyData> ConvertedKeys;
|
|
}
|
|
|
|
class KeyData
|
|
{
|
|
public HashType HashType;
|
|
public float Time;
|
|
public float Value;
|
|
}
|
|
|
|
class ConvertedKeyData
|
|
{
|
|
public float Time;
|
|
public float Value;
|
|
public string Category;
|
|
public string Label;
|
|
}
|
|
|
|
const string k_LabelHashId = "m_labelHash";
|
|
const string k_CategoryHashId = "m_CategoryHash";
|
|
const string k_SpriteKeyId = "m_SpriteKey";
|
|
const string k_SpriteHashId = "m_SpriteHash";
|
|
const string k_AnimClipTypeId = "t:AnimationClip";
|
|
|
|
static bool IsSpriteHashBinding(EditorCurveBinding b) =>
|
|
b.type == typeof(SpriteResolver)
|
|
&& !string.IsNullOrEmpty(b.propertyName)
|
|
&& b.propertyName == k_SpriteHashId;
|
|
|
|
static bool IsSpriteKeyBinding(EditorCurveBinding b) =>
|
|
b.type == typeof(SpriteResolver)
|
|
&& !string.IsNullOrEmpty(b.propertyName)
|
|
&& b.propertyName == k_SpriteKeyId;
|
|
|
|
static bool IsSpriteCategoryBinding(EditorCurveBinding b) =>
|
|
b.type == typeof(SpriteResolver)
|
|
&& !string.IsNullOrEmpty(b.propertyName)
|
|
&& b.propertyName == k_CategoryHashId;
|
|
|
|
static bool IsSpriteLabelBinding(EditorCurveBinding b) =>
|
|
b.type == typeof(SpriteResolver)
|
|
&& !string.IsNullOrEmpty(b.propertyName)
|
|
&& b.propertyName == k_LabelHashId;
|
|
|
|
static SpriteLibUpgrader s_SpriteLibUpgrader = new SpriteLibUpgrader(false, false);
|
|
|
|
internal override List<Object> GetUpgradableAssets()
|
|
{
|
|
var assets = AssetDatabase.FindAssets(k_AnimClipTypeId, new [] {"Assets"})
|
|
.Select(AssetDatabase.GUIDToAssetPath)
|
|
.Select(AssetDatabase.LoadAssetAtPath<Object>)
|
|
.ToArray();
|
|
|
|
var clips = assets
|
|
.Select(x => x as AnimationClip)
|
|
.Where(clip => clip != null)
|
|
.Where(clip =>
|
|
{
|
|
var bindings = AnimationUtility.GetCurveBindings(clip)
|
|
.Where(m => IsSpriteKeyBinding(m) || IsSpriteCategoryBinding(m) || IsSpriteLabelBinding(m))
|
|
.ToArray();
|
|
return bindings.Length > 0;
|
|
}).ToArray();
|
|
|
|
var assetList = new List<Object>(clips);
|
|
return assetList;
|
|
}
|
|
|
|
internal override UpgradeReport UpgradeSelection(List<ObjectIndexPair> objects)
|
|
{
|
|
var entries = new List<UpgradeEntry>();
|
|
|
|
AssetDatabase.StartAssetEditing();
|
|
|
|
string msg;
|
|
foreach (var obj in objects)
|
|
{
|
|
m_Logger.Add($"Verifying if the asset {obj.Target} is an AnimationClip.");
|
|
EditorUtility.DisplayProgressBar(
|
|
Contents.ProgressBarTitle,
|
|
Contents.VerifyingSelection,
|
|
GetUpgradeProgress(entries, objects));
|
|
|
|
if (obj.Target == null)
|
|
{
|
|
msg = "The upgrade failed. Invalid selection.";
|
|
m_Logger.Add(msg);
|
|
m_Logger.AddLineBreak();
|
|
entries.Add(new UpgradeEntry()
|
|
{
|
|
Result = UpgradeResult.Error,
|
|
Target = obj.Target,
|
|
Index = obj.Index,
|
|
Message = msg
|
|
});
|
|
continue;
|
|
}
|
|
|
|
var clip = obj.Target as AnimationClip;
|
|
if (clip == null)
|
|
{
|
|
msg = $"The upgrade failed. The asset {obj.Target.name} is not an AnimationClip.";
|
|
m_Logger.Add(msg);
|
|
m_Logger.AddLineBreak();
|
|
entries.Add(new UpgradeEntry()
|
|
{
|
|
Result = UpgradeResult.Error,
|
|
Target = obj.Target,
|
|
Index = obj.Index,
|
|
Message = msg
|
|
});
|
|
continue;
|
|
}
|
|
|
|
var extractedData = ExtractDataFromClip(clip);
|
|
ConvertData(ref extractedData);
|
|
|
|
var wasCleanupSuccessful = CleanupData(ref extractedData);
|
|
if (!wasCleanupSuccessful)
|
|
{
|
|
msg = $"The upgrade of the clip {obj.Target.name} failed. Some keyframes could not be converted in the animation clip.";
|
|
m_Logger.Add(msg);
|
|
m_Logger.AddLineBreak();
|
|
entries.Add(new UpgradeEntry()
|
|
{
|
|
Result = UpgradeResult.Error,
|
|
Target = obj.Target,
|
|
Index = obj.Index,
|
|
Message = msg
|
|
});
|
|
continue;
|
|
}
|
|
|
|
var isDataValid = ValidateConvertedData(extractedData, obj, entries);
|
|
if(!isDataValid)
|
|
continue;
|
|
|
|
UpdateClipWithConvertedData(clip, extractedData);
|
|
RemoveOldData(clip, extractedData);
|
|
|
|
msg = $"Upgrade successful. The clip {obj.Target.name} now uses the latest SpriteResolver data format.";
|
|
m_Logger.Add(msg);
|
|
m_Logger.AddLineBreak();
|
|
entries.Add(new UpgradeEntry()
|
|
{
|
|
Result = UpgradeResult.Successful,
|
|
Target = obj.Target,
|
|
Index = obj.Index,
|
|
Message = msg
|
|
});
|
|
}
|
|
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.StopAssetEditing();
|
|
|
|
EditorUtility.ClearProgressBar();
|
|
|
|
var report = new UpgradeReport()
|
|
{
|
|
UpgradeEntries = entries,
|
|
Log = m_Logger.GetLog()
|
|
};
|
|
|
|
m_Logger.Clear();
|
|
return report;
|
|
}
|
|
|
|
bool ValidateConvertedData(List<BindingData> extractedData, ObjectIndexPair upgradingObject, List<UpgradeEntry> entries)
|
|
{
|
|
var isDataValid = extractedData.All(data => data.ConvertedKeys.Count != 0);
|
|
if (!isDataValid)
|
|
{
|
|
var msg = $"The upgrade of the clip {upgradingObject.Target.name} failed. One or more bindings could not convert its keyframes to the latest data format.";
|
|
m_Logger.Add(msg);
|
|
m_Logger.AddLineBreak();
|
|
entries.Add(new UpgradeEntry()
|
|
{
|
|
Result = UpgradeResult.Error,
|
|
Target = upgradingObject.Target,
|
|
Index = upgradingObject.Index,
|
|
Message = msg
|
|
});
|
|
}
|
|
|
|
return isDataValid;
|
|
}
|
|
|
|
List<BindingData> ExtractDataFromClip(AnimationClip clip)
|
|
{
|
|
var spriteHashBindings = ExtractBindingsFromClip(clip, HashType.SpriteHash, IsSpriteHashBinding);
|
|
var spriteKeyBindings = ExtractBindingsFromClip(clip, HashType.SpriteKey, IsSpriteKeyBinding);
|
|
var categoryBindings = ExtractBindingsFromClip(clip, HashType.Category, IsSpriteCategoryBinding);
|
|
var labelBindings = ExtractBindingsFromClip(clip, HashType.Label, IsSpriteLabelBinding);
|
|
|
|
var bindings = new List<BindingData>();
|
|
bindings.AddRange(spriteHashBindings);
|
|
bindings.AddRange(spriteKeyBindings);
|
|
bindings.AddRange(categoryBindings);
|
|
bindings.AddRange(labelBindings);
|
|
|
|
bindings = MergeBindingData(bindings);
|
|
for (var i = 0; i < bindings.Count; ++i)
|
|
SortKeyData(bindings[i]);
|
|
return bindings;
|
|
}
|
|
|
|
BindingData[] ExtractBindingsFromClip(AnimationClip clip, HashType hashType, System.Func<EditorCurveBinding, bool> isBindingFunc)
|
|
{
|
|
var spriteHashBindings = AnimationUtility.GetCurveBindings(clip)
|
|
.Where(isBindingFunc.Invoke)
|
|
.ToArray();
|
|
|
|
var bindingData = new BindingData[spriteHashBindings.Length];
|
|
for (var i = 0; i < spriteHashBindings.Length; ++i)
|
|
bindingData[i] = ExtractKeyframesFromClip(clip, spriteHashBindings[i], hashType);
|
|
|
|
m_Logger.Add($"Extracting {hashType} bindings from clip. Found {bindingData.Length} bindings.");
|
|
|
|
return bindingData;
|
|
}
|
|
|
|
BindingData ExtractKeyframesFromClip(AnimationClip clip, EditorCurveBinding curveBinding, HashType hashType)
|
|
{
|
|
var bindingPath = curveBinding.path;
|
|
var bindingType = curveBinding.type;
|
|
|
|
var curves = AnimationUtility.GetEditorCurve(clip, curveBinding);
|
|
var keys = curves.keys;
|
|
var keyData = new List<KeyData>(keys.Length);
|
|
keyData.AddRange(keys
|
|
.Select(t => new KeyData() { Time = t.time, Value = t.value, HashType = hashType }));
|
|
|
|
var data = new BindingData()
|
|
{
|
|
BindingPath = bindingPath,
|
|
BindingType = bindingType,
|
|
RawKeys = keyData
|
|
};
|
|
|
|
m_Logger.Add($"Extracting {hashType} keyframes from clip. Found {keyData.Count} keyframes.");
|
|
|
|
return data;
|
|
}
|
|
|
|
List<BindingData> MergeBindingData(List<BindingData> bindingData)
|
|
{
|
|
var mergedData = new List<BindingData>();
|
|
for (var i = 0; i < bindingData.Count; i++)
|
|
{
|
|
var index = mergedData.FindIndex(x =>
|
|
x.BindingPath == bindingData[i].BindingPath &&
|
|
x.BindingType == bindingData[i].BindingType);
|
|
|
|
if (index != -1)
|
|
mergedData[index].RawKeys.AddRange(bindingData[i].RawKeys);
|
|
else
|
|
mergedData.Add(bindingData[i]);
|
|
}
|
|
|
|
m_Logger.Add($"Merging different types keyframes from the same bindings, into the same binding list. We now have {mergedData.Count} binding lists.");
|
|
|
|
return mergedData;
|
|
}
|
|
|
|
void SortKeyData(BindingData bindingData)
|
|
{
|
|
bindingData.RawKeys.Sort((a, b) => a.Time.CompareTo(b.Time));
|
|
m_Logger.Add($"Order the keyframe data in binding={bindingData.BindingPath} by time.");
|
|
}
|
|
|
|
void ConvertData(ref List<BindingData> bindingData)
|
|
{
|
|
for (var i = 0; i < bindingData.Count; ++i)
|
|
{
|
|
bindingData[i].ConvertedKeys = ConvertKeyData(bindingData[i]);
|
|
MergeKeyData(bindingData[i]);
|
|
RepairMissingKeyData(bindingData[i]);
|
|
}
|
|
}
|
|
|
|
List<ConvertedKeyData> ConvertKeyData(BindingData bindingData)
|
|
{
|
|
var keyData = bindingData.RawKeys;
|
|
var convertedData = new List<ConvertedKeyData>();
|
|
for (var i = 0; i < keyData.Count; ++i)
|
|
{
|
|
switch (keyData[i].HashType)
|
|
{
|
|
case HashType.SpriteHash:
|
|
convertedData.Add(ConvertSpriteHash(keyData[i]));
|
|
break;
|
|
case HashType.SpriteKey:
|
|
convertedData.Add(ConvertSpriteKey(keyData[i]));
|
|
break;
|
|
case HashType.Category:
|
|
convertedData.Add(ConvertSpriteCategory(keyData[i]));
|
|
break;
|
|
case HashType.Label:
|
|
convertedData.Add(ConvertSpriteLabel(keyData[i]));
|
|
break;
|
|
}
|
|
|
|
if(convertedData[i].Category == string.Empty && convertedData[i].Label == string.Empty)
|
|
m_Logger.Add($"Conversion of key={i} of type={keyData[i].HashType} for binding={bindingData.BindingPath} failed to resolve Category and Label values from the Sprite Libraries in the project.");
|
|
}
|
|
|
|
m_Logger.Add($"Converting keyframes into uniformed format for binding={bindingData.BindingPath}");
|
|
return convertedData;
|
|
}
|
|
|
|
static ConvertedKeyData ConvertSpriteHash(KeyData keyData)
|
|
{
|
|
var spriteHash = InternalEngineBridge.ConvertFloatToInt(keyData.Value);
|
|
SpriteHashToCategoryAndLabelName(spriteHash, out var categoryName, out var labelName);
|
|
var convertedData = new ConvertedKeyData()
|
|
{
|
|
Time = keyData.Time,
|
|
Value = keyData.Value,
|
|
Category = categoryName,
|
|
Label = labelName
|
|
};
|
|
return convertedData;
|
|
}
|
|
|
|
static ConvertedKeyData ConvertSpriteKey(KeyData keyData)
|
|
{
|
|
var newHash = InternalEngineBridge.ConvertFloatToInt(keyData.Value);
|
|
var spriteHash = SpriteLibraryUtility.Convert32BitTo30BitHash(newHash);
|
|
|
|
SpriteHashToCategoryAndLabelName(spriteHash, out var categoryName, out var labelName);
|
|
var convertedData = new ConvertedKeyData()
|
|
{
|
|
Time = keyData.Time,
|
|
Value = InternalEngineBridge.ConvertIntToFloat(spriteHash),
|
|
Category = categoryName,
|
|
Label = labelName
|
|
};
|
|
return convertedData;
|
|
}
|
|
|
|
static ConvertedKeyData ConvertSpriteCategory(KeyData keyData)
|
|
{
|
|
var newHash = InternalEngineBridge.ConvertFloatToInt(keyData.Value);
|
|
var categoryHash = SpriteLibraryUtility.Convert32BitTo30BitHash(newHash);
|
|
CategoryHashToCategoryName(categoryHash, out var categoryName);
|
|
|
|
var convertedData = new ConvertedKeyData()
|
|
{
|
|
Time = keyData.Time,
|
|
Value = 0f,
|
|
Category = categoryName,
|
|
Label = string.Empty
|
|
};
|
|
return convertedData;
|
|
}
|
|
|
|
static ConvertedKeyData ConvertSpriteLabel(KeyData keyData)
|
|
{
|
|
var newHash = InternalEngineBridge.ConvertFloatToInt(keyData.Value);
|
|
var labelHash = SpriteLibraryUtility.Convert32BitTo30BitHash(newHash);
|
|
LabelHashToLabelName(labelHash, out var labelName);
|
|
|
|
var convertedData = new ConvertedKeyData()
|
|
{
|
|
Time = keyData.Time,
|
|
Value = 0f,
|
|
Category = string.Empty,
|
|
Label = labelName
|
|
};
|
|
return convertedData;
|
|
}
|
|
|
|
static void SpriteHashToCategoryAndLabelName(int spriteHash, out string categoryName, out string labelName)
|
|
{
|
|
var spriteLibraryAssets = s_SpriteLibUpgrader.GetUpgradableAssets()
|
|
.Cast<SpriteLibraryAsset>().ToArray();
|
|
|
|
categoryName = string.Empty;
|
|
labelName = string.Empty;
|
|
|
|
foreach (var spriteLib in spriteLibraryAssets)
|
|
{
|
|
foreach (var category in spriteLib.categories)
|
|
{
|
|
foreach (var label in category.categoryList)
|
|
{
|
|
var combinedHash = SpriteLibrary.GetHashForCategoryAndEntry(category.name, label.name);
|
|
if (combinedHash == spriteHash)
|
|
{
|
|
categoryName = category.name;
|
|
labelName = label.name;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void CategoryHashToCategoryName(int categoryHash, out string categoryName)
|
|
{
|
|
var spriteLibraryAssets = s_SpriteLibUpgrader.GetUpgradableAssets()
|
|
.Cast<SpriteLibraryAsset>().ToArray();
|
|
|
|
categoryName = string.Empty;
|
|
|
|
foreach (var spriteLib in spriteLibraryAssets)
|
|
{
|
|
foreach (var category in spriteLib.categories)
|
|
{
|
|
if (category.hash == categoryHash)
|
|
{
|
|
categoryName = category.name;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void LabelHashToLabelName(int labelHash, out string labelName)
|
|
{
|
|
var spriteLibraryAssets = s_SpriteLibUpgrader.GetUpgradableAssets()
|
|
.Cast<SpriteLibraryAsset>().ToArray();
|
|
|
|
labelName = string.Empty;
|
|
|
|
foreach (var spriteLib in spriteLibraryAssets)
|
|
{
|
|
foreach (var category in spriteLib.categories)
|
|
{
|
|
foreach (var label in category.categoryList)
|
|
{
|
|
if (label.hash == labelHash)
|
|
{
|
|
labelName = label.name;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MergeKeyData(BindingData bindingData)
|
|
{
|
|
var keys = bindingData.ConvertedKeys;
|
|
for (var i = 0; i < keys.Count; ++i)
|
|
{
|
|
var categoryName = keys[i].Category;
|
|
|
|
if(categoryName == string.Empty)
|
|
continue;
|
|
|
|
var labelName = keys[i].Label;
|
|
if (labelName != string.Empty)
|
|
continue;
|
|
|
|
for (var m = 0; m < keys.Count; ++m)
|
|
{
|
|
labelName = keys[m].Label;
|
|
if(labelName == string.Empty)
|
|
continue;
|
|
if (Mathf.Abs(keys[i].Time - keys[m].Time) > Mathf.Epsilon)
|
|
continue;
|
|
|
|
keys[m].Category = categoryName;
|
|
keys[i].Label = labelName;
|
|
|
|
m_Logger.Add($"Merged Category={categoryName} and Label={labelName} at time={keys[i].Time} in binding={bindingData.BindingPath}.");
|
|
}
|
|
}
|
|
}
|
|
|
|
void RepairMissingKeyData(BindingData bindingData)
|
|
{
|
|
var keys = bindingData.ConvertedKeys;
|
|
var categoryName = string.Empty;
|
|
var labelName = string.Empty;
|
|
for (var i = 0; i < keys.Count; ++i)
|
|
{
|
|
if (keys[i].Category != string.Empty)
|
|
categoryName = keys[i].Category;
|
|
if (keys[i].Label != string.Empty)
|
|
labelName = keys[i].Label;
|
|
|
|
if (keys[i].Value == 0f && categoryName == string.Empty)
|
|
{
|
|
m_Logger.Add($"Cannot find a category for keyframe at time={keys[i].Time} in binding={bindingData.BindingPath}.");
|
|
continue;
|
|
}
|
|
if (keys[i].Value == 0f && labelName == string.Empty)
|
|
{
|
|
m_Logger.Add($"Cannot find a label for keyframe at time={keys[i].Time} in binding={bindingData.BindingPath}.");
|
|
continue;
|
|
}
|
|
|
|
if (keys[i].Value == 0f)
|
|
{
|
|
var spriteHash = SpriteLibrary.GetHashForCategoryAndEntry(categoryName, labelName);
|
|
keys[i].Value = InternalEngineBridge.ConvertIntToFloat(spriteHash);
|
|
|
|
if (keys[i].Value != 0f)
|
|
m_Logger.Add($"Combining categoryName={categoryName} labelName={labelName} into spriteHash={spriteHash}.");
|
|
else
|
|
m_Logger.Add($"Could not repair keyframe at time={keys[i].Time} for binding={bindingData.BindingPath}. The Sprite Library Asset might be missing.");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CleanupData(ref List<BindingData> bindingData)
|
|
{
|
|
foreach (var data in bindingData)
|
|
{
|
|
var keys = data.ConvertedKeys;
|
|
|
|
var keyTimes = new List<float>();
|
|
for (var i = 0; i < keys.Count; ++i)
|
|
{
|
|
var time = keys[i].Time;
|
|
if(i == 0 || (time - keyTimes[keyTimes.Count - 1]) > Mathf.Epsilon)
|
|
keyTimes.Add(time);
|
|
}
|
|
|
|
for (var m = keys.Count - 1; m >= 0; --m)
|
|
{
|
|
if(keys[m].Value == 0f)
|
|
keys.RemoveAt(m);
|
|
}
|
|
|
|
for (var m = keys.Count - 1; m > 0; --m)
|
|
{
|
|
if (Mathf.Abs(keys[m].Time - keys[m - 1].Time) < Mathf.Epsilon)
|
|
keys.RemoveAt(m);
|
|
}
|
|
|
|
if (keyTimes.Count == keys.Count)
|
|
m_Logger.Add($"Cleaned up keyframes for binding={data.BindingPath}. It now has {keys.Count} keyframes.");
|
|
else
|
|
{
|
|
m_Logger.Add($"Expected {keyTimes.Count} keyframes after cleanup for binding={data.BindingPath}, but ended up with {keys.Count}.");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void UpdateClipWithConvertedData(AnimationClip clip, List<BindingData> convertedBindings)
|
|
{
|
|
var destData = new EditorCurveBinding[convertedBindings.Count];
|
|
for (var i = 0; i < convertedBindings.Count; ++i)
|
|
destData[i] = EditorCurveBinding.DiscreteCurve(convertedBindings[i].BindingPath, convertedBindings[i].BindingType, k_SpriteHashId);
|
|
|
|
var curves = new AnimationCurve[destData.Length];
|
|
for (var i = 0; i < curves.Length; ++i)
|
|
{
|
|
var convertedKeys = convertedBindings[i].ConvertedKeys;
|
|
var keyFrames = new Keyframe[convertedKeys.Count];
|
|
for (var m = 0; m < keyFrames.Length; ++m)
|
|
{
|
|
keyFrames[m].inTangent = float.PositiveInfinity;
|
|
keyFrames[m].outTangent = float.PositiveInfinity;
|
|
keyFrames[m].time = convertedKeys[m].Time;
|
|
keyFrames[m].value = convertedKeys[m].Value;
|
|
}
|
|
|
|
curves[i] = new AnimationCurve(keyFrames);
|
|
}
|
|
|
|
AnimationUtility.SetEditorCurves(clip, destData, curves);
|
|
m_Logger.Add($"Injected updated bindings into AnimationClip={clip.name}.");
|
|
}
|
|
|
|
void RemoveOldData(AnimationClip clip, List<BindingData> bindingData)
|
|
{
|
|
var spriteKeyCurves = new EditorCurveBinding[bindingData.Count];
|
|
var spriteCategoryCurves = new EditorCurveBinding[bindingData.Count];
|
|
var spriteLabelCurves = new EditorCurveBinding[bindingData.Count];
|
|
|
|
for (var i = 0; i < bindingData.Count; ++i)
|
|
{
|
|
spriteKeyCurves[i] = EditorCurveBinding.DiscreteCurve(bindingData[i].BindingPath, bindingData[i].BindingType, k_SpriteKeyId);
|
|
spriteCategoryCurves[i] = EditorCurveBinding.DiscreteCurve(bindingData[i].BindingPath, bindingData[i].BindingType, k_CategoryHashId);
|
|
spriteLabelCurves[i] = EditorCurveBinding.DiscreteCurve(bindingData[i].BindingPath, bindingData[i].BindingType, k_LabelHashId);
|
|
}
|
|
|
|
AnimationUtility.SetEditorCurves(clip, spriteKeyCurves, new AnimationCurve[spriteKeyCurves.Length]);
|
|
AnimationUtility.SetEditorCurves(clip, spriteCategoryCurves, new AnimationCurve[spriteCategoryCurves.Length]);
|
|
AnimationUtility.SetEditorCurves(clip, spriteLabelCurves, new AnimationCurve[spriteLabelCurves.Length]);
|
|
|
|
m_Logger.Add($"Removed old bindings in AnimationClip={clip.name}.");
|
|
}
|
|
|
|
static float GetUpgradeProgress(List<UpgradeEntry> reports, List<ObjectIndexPair> totalNoOfObjects)
|
|
{
|
|
return reports.Count / (float)totalNoOfObjects.Count;
|
|
}
|
|
}
|
|
}
|