static public GameObject FindBestFittingRenderableGameObjectFromModelAsset(Object asset,
ModelImporterAnimationType animationType)
{
if (asset == null)
{
return(null);
}
ModelImporter importer = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(asset)) as ModelImporter;
if (importer == null)
{
return(null);
}
string assetPath = ReflectionHelper.Instance.ModelImporter.CalculateBestFittingPreviewGameObject();
GameObject tempGO = AssetDatabase.LoadMainAssetAtPath(assetPath) as GameObject;
// We should also check for isHumanClip matching the animationclip requiremenets...
if (IsValidPreviewGameObject(tempGO, ModelImporterAnimationType.None))
{
return(tempGO);
}
else
{
return(null);
}
}
private void DrawRig()
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Animation Type");
m_animationType = (ModelImporterAnimationType)EditorGUILayout.EnumPopup(m_animationType);
EditorGUILayout.EndHorizontal();
}
void CheckAvatar(Avatar sourceAvatar)
{
if (sourceAvatar != null)
{
if (sourceAvatar.isHuman && (animationType != ModelImporterAnimationType.Human))
{
if (EditorUtility.DisplayDialog("Assigning a Humanoid Avatar on a Generic Rig",
"Do you want to change Animation Type to Humanoid ?", "Yes", "No"))
{
animationType = ModelImporterAnimationType.Human;
}
else
{
m_AvatarSource.objectReferenceValue = null;
}
}
else if (!sourceAvatar.isHuman && (animationType != ModelImporterAnimationType.Generic))
{
if (EditorUtility.DisplayDialog("Assigning a Generic Avatar on a Humanoid Rig",
"Do you want to change Animation Type to Generic ?", "Yes", "No"))
{
animationType = ModelImporterAnimationType.Generic;
}
else
{
m_AvatarSource.objectReferenceValue = null;
}
}
}
}
/// <summary>
/// 导出一个模型的所有动画
/// </summary>
/// <param name="modelImport">模型</param>
/// <param name="animationType">导出的动画类型，如果为None，则用模型自己的动画类型</param>
/// <returns>导出的动画</returns>
private void ExportAnimations(ModelImporter modelImport, ModelImporterAnimationType animationType, float scal)
{
if (null == modelImport)
{
//路径非模型，返回//
return;
}
if (!modelImport.importAnimation)
{
//没有动画，也返回//
return;
}
string folderPath = CreateAnimationClipsFolder(modelImport);
if (null == folderPath)
{
return;
}
DirectoryInfo info = new DirectoryInfo(folderPath);
if (!info.Exists)
{
info.Create();
}
//先把模型的动画类型保存//
ModelImporterAnimationType modelAnimationType = modelImport.animationType;
//转为Legacy，这样模型对应的import object才会有animations//
modelImport.animationType = ModelImporterAnimationType.Legacy;
modelImport.globalScale = scal;
//Apply//
AssetDatabase.ImportAsset(modelImport.assetPath, ImportAssetOptions.ImportRecursive);
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
//取到对应的import object//
GameObject importObject = AssetDatabase.LoadMainAssetAtPath(modelImport.assetPath) as GameObject;
if (null != importObject)
{
AnimationClip[] clips = AnimationUtility.GetAnimationClips(importObject);
for (int i = 0; i < clips.Length; ++i)
{
AnimationClip dstClip = CopyClip(clips[i], folderPath);
if (null != dstClip)
{
#if UNITY_5
//DO NOTHING
#else
AnimationUtility.SetAnimationType(dstClip, animationType);
#endif
}
}
}
//还原//
modelImport.animationType = modelAnimationType;
//Apply//
AssetDatabase.ImportAsset(modelImport.assetPath, ImportAssetOptions.ForceSynchronousImport);
}
private static GameObject CalculatePreviewGameObject(UnityEngine.Animator selectedAnimator, Motion motion, ModelImporterAnimationType animationType)
{
AnimationClip firstAnimationClipFromMotion = GetFirstAnimationClipFromMotion(motion);
GameObject preview = AvatarPreviewSelection.GetPreview(animationType);
if (IsValidPreviewGameObject(preview, ModelImporterAnimationType.None))
{
return preview;
}
if ((selectedAnimator != null) && IsValidPreviewGameObject(selectedAnimator.gameObject, animationType))
{
return selectedAnimator.gameObject;
}
preview = FindBestFittingRenderableGameObjectFromModelAsset(firstAnimationClipFromMotion, animationType);
if (preview != null)
{
return preview;
}
if (animationType == ModelImporterAnimationType.Human)
{
return GetHumanoidFallback();
}
if (animationType == ModelImporterAnimationType.Generic)
{
return GetGenericAnimationFallback();
}
return null;
}
public ModelFolderRule(ProjectImportSettings.ModelFolderRule rule)
{
maxVertices = rule.maxVertices;
shouldBatch = rule.shouldBatch;
m_MeshCompression = rule.m_MeshCompression;
m_IsReadable = rule.m_IsReadable;
optimizeMeshForGPU = rule.optimizeMeshForGPU;
m_ImportBlendShapes = rule.m_ImportBlendShapes;
m_AddColliders = rule.m_AddColliders;
keepQuads = rule.keepQuads;
weldVertices = rule.weldVertices;
m_ImportVisibility = rule.m_ImportVisibility;
m_ImportCameras = rule.m_ImportCameras;
m_ImportLights = rule.m_ImportLights;
swapUVChannels = rule.swapUVChannels;
generateSecondaryUV = rule.generateSecondaryUV;
normalImportMode = rule.normalImportMode;
tangentImportMode = rule.tangentImportMode;
m_AnimationType = rule.m_AnimationType;
m_LegacyGenerateAnimations = rule.m_LegacyGenerateAnimations;
importAnimation = rule.importAnimation;
m_AnimationCompression = rule.m_AnimationCompression;
m_OptimizeGameObjects = rule.m_OptimizeGameObjects;
importMaterials = rule.importMaterials;
maxBones = rule.maxBones;
maxBoneWeights = rule.maxBoneWeights;
}
public override void ApplyDefaults()
{
this.RuleName = "New Model Rule";
SuffixFilter = ".FBX";
meshCompression = ModelImporterMeshCompression.Off;
isReadable = false;
importBlendShapes = false;
optimizeMeshForGPU = true;
generateColliders = false;
keepQuads = false;
weldVertices = true;
swapUVChannels = false;
generateSecondaryUV = false;
normalImportMode = ModelImporterNormals.None;
tangentImportMode = ModelImporterTangents.CalculateMikk;
importMaterials = true;
materialName = ModelImporterMaterialName.BasedOnTextureName;
materialSearch = ModelImporterMaterialSearch.Everywhere;
animationType = ModelImporterAnimationType.None;
importAnimation = false;
animCompression = ModelImporterAnimationCompression.Off;
}
/// <summary>
/// 模型的动画类型设置
/// </summary>
/// <param name="modelImporter"></param>
/// <param name="animationType"></param>
private void ModelAnimationTypeSetting(ModelImporter modelImporter, ModelImporterAnimationType animationType)
{
if (modelImporter.animationType != animationType)
{
modelImporter.animationType = animationType;
}
}
public override bool DoCheck(string asset)
{
ModelImporterAnimationType modelImporterAnimationType;
if (Regex.IsMatch(asset, "Assets/Res/Character/[3-4]{1}[0-9]{4}/.*?\\.(FBX|fbx)$"))
{
modelImporterAnimationType = ModelImporterAnimationType.Generic;
}
else
{
modelImporterAnimationType = ModelImporterAnimationType.Human;
}
ModelImporter modelImporter = AssetImporter.GetAtPath(asset) as ModelImporter;
if (modelImporter != null)
{
ModelImporterAnimationType animationType = modelImporter.animationType;
if (animationType == null)
{
return(true);
}
if (modelImporterAnimationType != animationType)
{
this.resultInfo.Add(asset, "May be " + modelImporterAnimationType.ToString() + " ||| now " + modelImporter.animationType.ToString());
return(false);
}
}
return(true);
}
public void SetPreview(ModelImporterAnimationType type, GameObject go)
{
if (null != _methodInfo)
{
_methodInfo.Invoke(null, new object[] { type, go });
}
}
void OnGUI()
{
m_Animator = (Animator)EditorGUILayout.ObjectField("Animator", m_Animator, typeof(Animator), true);
m_AnimType = (ModelImporterAnimationType)EditorGUILayout.EnumPopup("AnimType", m_AnimType);
if (m_AnimType != ModelImporterAnimationType.Legacy)
{
m_AnimType = ModelImporterAnimationType.Generic;
}
bool bSet = (m_Animator != null);
EUtil.PushGUIEnable(bSet);
if (EUtil.Button("Convert Animation!", bSet ? Color.green : Color.red))
{
if (!m_Animator.isHuman)
{
EUtil.ShowNotification("The model is not in Humanoid rig!");
return;
}
// save xforms recursively
m_SavedPose = EUtil.CacheXformData(m_Animator.transform);
m_Animator.Update(0);
#if !U5
var ainfos = m_Animator.GetCurrentAnimationClipState(0); //only effect after Update is called
#else
var ainfos = m_Animator.GetCurrentAnimatorClipInfo(0); //only effect after Update is called
#endif
if (ainfos.Length == 0)
{
EUtil.ShowNotification("No clip in AnimationController!");
}
else
{
AnimationClip clip = ainfos[0].clip;
string oldClipAssetPath = AssetDatabase.GetAssetPath(clip);
string newClipAssetPath = PathUtil.StripExtension(oldClipAssetPath) + NEW_CLIP_POSTFIX + m_AnimType + ".anim";
string filePath = EditorUtility.SaveFilePanel("Select export file path",
Path.GetDirectoryName(newClipAssetPath),
Path.GetFileNameWithoutExtension(newClipAssetPath),
"anim");
if (filePath.Length > 0)
{
filePath = PathUtil.FullPath2ProjectPath(filePath);
_ConvertAnim(filePath);
}
else
{
EUtil.ShowNotification("Conversion Cancelled...");
}
}
//apply the original pose back
EUtil.ApplyXformData(m_Animator.transform, m_SavedPose);
}
EUtil.PopGUIEnable();
}
public static void SetPreview(ModelImporterAnimationType type, GameObject go)
{
if (Enum.IsDefined(typeof(ModelImporterAnimationType), type) && (ScriptableSingleton <AvatarPreviewSelection> .instance.m_PreviewModels[(int)type] != go))
{
ScriptableSingleton <AvatarPreviewSelection> .instance.m_PreviewModels[(int)type] = go;
ScriptableSingleton <AvatarPreviewSelection> .instance.Save(false);
}
}
public static GameObject GetPreview(ModelImporterAnimationType type)
{
if (!Enum.IsDefined(typeof(ModelImporterAnimationType), (object)type))
{
return((GameObject)null);
}
return(ScriptableSingleton <AvatarPreviewSelection> .instance.m_PreviewModels[(int)type]);
}
public static bool IsValidPreviewGameObject(GameObject target, ModelImporterAnimationType requiredClipType)
{
if (target != null && !target.activeSelf)
{
Debug.LogWarning("Can't preview inactive object, using fallback object");
}
return(target != null && target.activeSelf && GameObjectInspector.HasRenderableParts(target) && (requiredClipType == ModelImporterAnimationType.None || AvatarPreview.GetAnimationType(target) == requiredClipType));
}
private void DisplaySettings()
{
float w = 85f;
float w2 = 22f;
float w3 = 40f;
GUILayout.BeginHorizontal();
GUILayout.Label("Set RotError", GUILayout.Width(w));
doRot = EditorGUILayout.Toggle(doRot, GUILayout.Width(w2));
rotVal = EditorGUILayout.FloatField(rotVal, GUILayout.Width(w3));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Set RotError", GUILayout.Width(w));
doPos = EditorGUILayout.Toggle(doPos, GUILayout.Width(w2));
posVal = EditorGUILayout.FloatField(posVal, GUILayout.Width(w3));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Set ScaleError", GUILayout.Width(w));
doScale = EditorGUILayout.Toggle(doScale, GUILayout.Width(w2));
scaleVal = EditorGUILayout.FloatField(scaleVal, GUILayout.Width(w3));
GUILayout.EndHorizontal();
GUILayout.Space(10f);
GUILayout.BeginHorizontal();
GUILayout.Label("Set Animation Type", GUILayout.Width(w + 15f));
doImportType = EditorGUILayout.Toggle(doImportType, GUILayout.Width(w2));
currImportType = (ModelImporterAnimationType)EditorGUILayout.EnumPopup(currImportType, GUILayout.Width(w));
GUILayout.EndHorizontal();
GUILayout.Space(10f);
GUILayout.BeginHorizontal();
GUILayout.Label("Set Bones", GUILayout.Width(w - 15f));
doBones = EditorGUILayout.Toggle(doBones, GUILayout.Width(w2));
GUILayout.Label("SkinWeight Type", GUILayout.Width(w + 25f));
// currSkinWeightsType = (ModelImporterSkinWeights)EditorGUILayout.EnumPopup(currSkinWeightsType, GUILayout.Width(w));
GUILayout.EndHorizontal();
/*
* if (currSkinWeightsType == ModelImporterSkinWeights.Custom)
* {
* GUILayout.BeginHorizontal();
* GUILayout.Label("Bone Count", GUILayout.Width(w));
* boneCount = EditorGUILayout.IntSlider(boneCount, 1, 32);
* GUILayout.EndHorizontal();
* GUILayout.BeginHorizontal();
* GUILayout.Label("Bone MinWeight", GUILayout.Width(w + 15f));
* currMinBoneWeight = EditorGUILayout.Slider(currMinBoneWeight, 0.001f, 0.5f);
* GUILayout.EndHorizontal();
* GUILayout.Space(10f);
* }
*/
GUILayout.BeginHorizontal();
GUILayout.Label("Dupliate anim out of fbx", GUILayout.Width(w + 55f));
duplicateOutAnim = EditorGUILayout.Toggle(duplicateOutAnim, GUILayout.Width(w2));
GUILayout.Label("Experimental ImportAsset", GUILayout.Width(w + 66f));
experimentalApplyImportSettFirst = EditorGUILayout.Toggle(experimentalApplyImportSettFirst, GUILayout.Width(w2));
GUILayout.EndHorizontal();
GUILayout.Space(10f);
}
public static void SetPreview(ModelImporterAnimationType type, GameObject go)
{
if (!Enum.IsDefined(typeof(ModelImporterAnimationType), (object)type) || !((UnityEngine.Object)ScriptableSingleton <AvatarPreviewSelection> .instance.m_PreviewModels[(int)type] != (UnityEngine.Object)go))
{
return;
}
ScriptableSingleton <AvatarPreviewSelection> .instance.m_PreviewModels[(int)type] = go;
ScriptableSingleton <AvatarPreviewSelection> .instance.Save(false);
}
static public GameObject GetPreview(ModelImporterAnimationType type)
{
if (!System.Enum.IsDefined(typeof(ModelImporterAnimationType), type))
{
return(null);
}
return(instance.m_PreviewModels[(int)type]);
}
private void FBXSetting()
{
EditorGUILayout.BeginVertical(GUILayout.MaxWidth(600));
{
GUILayout.Space(15);
GUILayout.Label("Basic Setting", XXToolsEdGui.Head2Style);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical(XXToolsEdGui.BoxStyle, GUILayout.MaxWidth(300));
{
GUILayout.Label("PostProcess", XXToolsEdGui.Head4Style);
ModelImporterAnimationType selectType = (ModelImporterAnimationType)EditorGUILayout.EnumPopup("Animation Type", ed.db.animType);
if (selectType == ModelImporterAnimationType.Generic || selectType == ModelImporterAnimationType.Legacy)
{
ed.db.animType = selectType;
}
if (ed.db.animType == ModelImporterAnimationType.Generic)
{
ed.db.optiomaize = GUILayout.Toggle(ed.db.optiomaize, "Optiomaize");
}
}
EditorGUILayout.EndVertical();
GUILayout.Space(15);
GUILayout.Label("Actor Component", XXToolsEdGui.Head2Style);
EditorGUILayout.BeginVertical(XXToolsEdGui.BoxStyle, GUILayout.MaxWidth(300));
{
EditorGUILayout.BeginHorizontal();
{
GUILayout.Label("AC List", XXToolsEdGui.Head3Style);
GUILayout.Space(20);
if (XXToolsEdGui.IconButton("Refresh", XXToolsEdGui.Icon_Refresh, GUILayout.Width(100)))
{
LoadAC();
}
GUILayout.FlexibleSpace();
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(20);
scroll[1] = XXToolsEdGui.BeginScrollView(scroll[1], XXToolsEdGui.ScrollViewNoTLMarginStyle, GUILayout.Height(275));
{
foreach (GameObject go in ed.db.actorComponesPrefabs)
{
EditorGUILayout.SelectableLabel(go.name, GUILayout.Height(30));
}
}
XXToolsEdGui.EndScrollView();
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndVertical();
}
public static bool IsValidPreviewGameObject(GameObject target, ModelImporterAnimationType requiredClipType)
{
if ((Object)target != (Object)null && !target.activeSelf)
{
Debug.LogWarning((object)"Can't preview inactive object, using fallback object");
}
if ((Object)target != (Object)null && target.activeSelf && GameObjectInspector.HasRenderablePartsRecurse(target))
{
return((requiredClipType == ModelImporterAnimationType.None ? 0 : (AvatarPreview.GetAnimationType(target) != requiredClipType ? 1 : 0)) == 0);
}
return(false);
}
public void ApplyDefaults()
{
readWriteEnabled = false;
optimiseMesh = true;
ImportBlendShapes = false;
normalImportMode = ModelImporterNormals.Import;
animationType = ModelImporterAnimationType.None;
meshCompression = ModelImporterMeshCompression.Off;
importMaterials = true;
importTangents = ModelImporterTangents.None;
changeReadableSettings = false;
}
public override void CopyData(ImportData data)
{
AnimationImportData tData = data as AnimationImportData;
if (tData == null)
{
return;
}
base.CopyData(data);
AnimationType = tData.AnimationType;
AnimationCompression = tData.AnimationCompression;
}
static public void SetPreview(ModelImporterAnimationType type, GameObject go)
{
if (!System.Enum.IsDefined(typeof(ModelImporterAnimationType), type))
{
return;
}
if (instance.m_PreviewModels[(int)type] != go)
{
instance.m_PreviewModels[(int)type] = go;
instance.Save(false);
}
}
private void DrawRigGUI()
{
animationType = (ModelImporterAnimationType)EditorGUILayout.EnumPopup(AssetImportStyles.Model.AnimationType, animationType);
if (animationType == ModelImporterAnimationType.Generic ||
animationType == ModelImporterAnimationType.Human)
{
isOptimizeObject = true;
}
else
{
isOptimizeObject = false;
}
}
public static GameObject GetPreview(ModelImporterAnimationType type)
{
GameObject result;
if (!Enum.IsDefined(typeof(ModelImporterAnimationType), type))
{
result = null;
}
else
{
result = ScriptableSingleton <AvatarPreviewSelection> .instance.m_PreviewModels[(int)type];
}
return(result);
}
void OnWizardCreate()
{
string atlasPath = getAtlasFilePath(path);
string directory = Path.GetDirectoryName(atlasPath);
string name = Path.GetFileNameWithoutExtension(path);
SpritesByName spriteByName;
Dictionary <string, GameObject> boneGOByName;
Dictionary <string, Slot> slotByName;
List <Skin> skins;
AttachmentGOByNameBySlot attachmentGOByNameBySlot;
if (File.Exists(path))
{
try{
SpineMultiatlas spineMultiAtlas = SpineMultiatlas.deserializeFromFile(atlasPath);
SpineData spineData = SpineData.deserializeFromFile(path);
SpineUtil.updateImporters(spineMultiAtlas, directory, pixelsPerUnit, out spriteByName);
GameObject rootGO = SpineUtil.buildSceleton(name, spineData, pixelsPerUnit, out boneGOByName, out slotByName);
rootGO.name = name;
SpineUtil.addAllAttahcmentsSlots(spineData, spriteByName, slotByName, zStep, pixelsPerUnit, out skins, out attachmentGOByNameBySlot);
SkinController sk = SpineUtil.addSkinController(rootGO, spineData, skins, slotByName);
if (animationImportType == AnimationImportType.MECANIM)
{
Animator animator = SpineUtil.addAnimator(rootGO);
if (buildAvatarMask)
{
SpineUtil.builAvatarMask(rootGO, spineData, animator, directory, name);
}
}
ModelImporterAnimationType modelImporterAnimationType = getModelImporterAnimationType();
if (spineData.animations != null && spineData.animations.Count > 0)
{
SpineUtil.addAnimation(rootGO, directory, spineData, boneGOByName, attachmentGOByNameBySlot,
pixelsPerUnit, modelImporterAnimationType, updateResources);
}
sk.showDefaulSlots();
SpineUtil.buildPrefab(rootGO, directory, name);
GameObject.DestroyImmediate(rootGO);
} catch (SpineMultiatlasCreationException e) {
Debug.LogException(e);
} catch (SpineDatatCreationException e) {
Debug.LogException(e);
} catch (AtlasImageDuplicateSpriteName e) {
Debug.LogException(e);
}
}
}
private string GetAvatarName(ModelImporterAnimationType type, Avatar avatar)
{
if (type == ModelImporterAnimationType.None || type == ModelImporterAnimationType.Legacy)
{
return("No Avatar");
}
if (avatar == null)
{
return("Create From This Model");
}
StringBuilder sb = new StringBuilder(avatar.name.Length + 32);
sb.Append(avatar.name).Append("(").Append(avatar.GetInstanceID()).Append(")");
return(sb.ToString());
}
ModelImporterAnimationType getModelImporterAnimationType()
{
ModelImporterAnimationType result = ModelImporterAnimationType.Generic;
switch (animationImportType)
{
case AnimationImportType.LEGACY:
result = ModelImporterAnimationType.Legacy;
break;
case AnimationImportType.MECANIM:
result = ModelImporterAnimationType.Generic;
break;
}
return(result);
}
public void ApplyDefaults()
{
m_MeshCompression = ModelImporterMeshCompression.Off;
m_IsReadable = false;
m_ImportBlendShapes = false;
m_AddColliders = false;
keepQuads = false;
m_weldVertices = true;
swapUVChannels = false;
generateSecondaryUV = false;
normalImportMode = ModelImporterNormals.None;
tangentImportMode = ModelImporterTangents.None;
m_ImportMaterials = true;
m_MaterialName = ModelImporterMaterialName.BasedOnMaterialName;
m_MaterialSearch = ModelImporterMaterialSearch.Everywhere;
AnimationType = ModelImporterAnimationType.None;
ImportAnimation = false;
}
static GameObject CalculatePreviewGameObject(Animator selectedAnimator, Motion motion,
ModelImporterAnimationType animationType)
{
AnimationClip sourceClip = GetFirstAnimationClipFromMotion(motion);
// Use selected preview
GameObject selected = EditorHelper.InstantiateGoByPrefab(selectedAnimator.gameObject, null);
selected.tag = Constants.PREVIRE_TAG;
InitInstantiatedPreviewRecursive(selected);
if (IsValidPreviewGameObject(selected, ModelImporterAnimationType.None))
{
return(selected);
}
if (selectedAnimator != null && IsValidPreviewGameObject(selectedAnimator.gameObject, animationType))
{
return(selectedAnimator.gameObject);
}
// Find the best fitting preview game object for the asset we are viewing (Handles @ convention, will pick base path for you)
selected = FindBestFittingRenderableGameObjectFromModelAsset(sourceClip, animationType);
if (selected != null)
{
return(selected);
}
if (animationType == ModelImporterAnimationType.Human)
{
return(GetHumanoidFallback());
}
else if (animationType == ModelImporterAnimationType.Generic)
{
return(GetGenericAnimationFallback());
}
return(null);
}
bool IsAvatarValid(Avatar newAvatar)
{
if (newAvatar != null)
{
if (newAvatar.isHuman && (animationType != ModelImporterAnimationType.Human))
{
if (EditorUtility.DisplayDialog("Assigning a Humanoid Avatar on a Generic Rig",
"Do you want to change Animation Type to Humanoid ?", "Yes", "No"))
{
animationType = ModelImporterAnimationType.Human;
return(true);
}
else
{
//New Avatar is invalid
return(false);
}
}
else if (!newAvatar.isHuman && (animationType != ModelImporterAnimationType.Generic))
{
if (EditorUtility.DisplayDialog("Assigning a Generic Avatar on a Humanoid Rig",
"Do you want to change Animation Type to Generic ?", "Yes", "No"))
{
animationType = ModelImporterAnimationType.Generic;
return(true);
}
else
{
//New Avatar is invalid
return(false);
}
}
}
return(true);
}
public static bool IsValidPreviewGameObject(GameObject target, ModelImporterAnimationType requiredClipType)
{
if ((Object) target != (Object) null && !target.activeSelf)
Debug.LogWarning((object) "Can't preview inactive object, using fallback object");
if ((Object) target != (Object) null && target.activeSelf && GameObjectInspector.HasRenderablePartsRecurse(target))
return (requiredClipType == ModelImporterAnimationType.None ? 0 : (AvatarPreview.GetAnimationType(target) != requiredClipType ? 1 : 0)) == 0;
return false;
}
static GameObject CalculatePreviewGameObject(Animator selectedAnimator, Motion motion, ModelImporterAnimationType animationType)
{
AnimationClip sourceClip = GetFirstAnimationClipFromMotion(motion);
// Use selected preview
GameObject selected = AvatarPreviewSelection.GetPreview(animationType);
if (IsValidPreviewGameObject(selected, ModelImporterAnimationType.None))
{
return(selected);
}
if (selectedAnimator != null && IsValidPreviewGameObject(selectedAnimator.gameObject, animationType))
{
return(selectedAnimator.gameObject);
}
// Find the best fitting preview game object for the asset we are viewing (Handles @ convention, will pick base path for you)
selected = FindBestFittingRenderableGameObjectFromModelAsset(sourceClip, animationType);
if (selected != null)
{
return(selected);
}
if (animationType == ModelImporterAnimationType.Human)
{
return(GetHumanoidFallback());
}
else if (animationType == ModelImporterAnimationType.Generic)
{
return(GetGenericAnimationFallback());
}
return(null);
}
public static GameObject FindBestFittingRenderableGameObjectFromModelAsset(Object asset, ModelImporterAnimationType animationType)
{
if (asset == (Object) null)
return (GameObject) null;
ModelImporter atPath = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(asset)) as ModelImporter;
if ((Object) atPath == (Object) null)
return (GameObject) null;
GameObject target = AssetDatabase.LoadMainAssetAtPath(atPath.CalculateBestFittingPreviewGameObject()) as GameObject;
if (AvatarPreview.IsValidPreviewGameObject(target, animationType))
return target;
return (GameObject) null;
}
public static void SetAnimationType(AnimationClip clip, ModelImporterAnimationType type)
{
}
public static GameObject FindBestFittingRenderableGameObjectFromModelAsset(UnityEngine.Object asset, ModelImporterAnimationType animationType)
{
if (asset == null)
{
return null;
}
ModelImporter modelImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(asset)) as ModelImporter;
if (modelImporter == null)
{
return null;
}
string assetPath = modelImporter.CalculateBestFittingPreviewGameObject();
GameObject gameObject = AssetDatabase.LoadMainAssetAtPath(assetPath) as GameObject;
if (AvatarPreview.IsValidPreviewGameObject(gameObject, animationType))
{
return gameObject;
}
return null;
}
public static bool IsValidPreviewGameObject(GameObject target, ModelImporterAnimationType requiredClipType)
{
if ((target != null) && !target.activeSelf)
{
Debug.LogWarning("Can't preview inactive object, using fallback object");
}
return ((((target != null) && target.activeSelf) && GameObjectInspector.HasRenderablePartsRecurse(target)) && ((requiredClipType == ModelImporterAnimationType.None) || (GetAnimationType(target) == requiredClipType)));
}
public static GameObject FindBestFittingRenderableGameObjectFromModelAsset(UnityEngine.Object asset, ModelImporterAnimationType animationType)
{
if (asset != null)
{
ModelImporter atPath = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(asset)) as ModelImporter;
if (atPath == null)
{
return null;
}
GameObject target = AssetDatabase.LoadMainAssetAtPath(atPath.CalculateBestFittingPreviewGameObject()) as GameObject;
if (IsValidPreviewGameObject(target, animationType))
{
return target;
}
}
return null;
}
public static void addAnimation(GameObject rootGO,
string rootDirectory,
SpineData spineData,
Dictionary<string, GameObject> boneGOByName,
Dictionary<string, Slot> slotByName,
AttachmentGOByNameBySlot attachmentGOByNameBySlot,
List<Skin> skinList,
int pixelsPerUnit,
float zStep,
ModelImporterAnimationType modelImporterAnimationType,
bool updateResources)
{
float ratio = 1.0f / (float)pixelsPerUnit;
foreach(KeyValuePair<string,SpineAnimation> kvp in spineData.animations){
string animationName = kvp.Key;
string animationFolder = rootDirectory+"/"+ANIMATION_FOLDER;
string assetPath = animationFolder + "/" + animationName+".anim";
SpineAnimation spineAnimation = kvp.Value;
AnimationClip animationClip = new AnimationClip();
bool updateCurve = false;
if (File.Exists(assetPath)){
AnimationClip oldClip = AssetDatabase.LoadAssetAtPath(assetPath, typeof(AnimationClip)) as AnimationClip;
if (oldClip != null){
animationClip = oldClip;
animationClip.ClearCurves();
updateCurve = true;
}
}
AnimationUtility.SetAnimationType(animationClip, modelImporterAnimationType);
if (spineAnimation.bones!=null)
addBoneAnimationToClip(animationClip,spineAnimation.bones, spineData, boneGOByName, ratio);
if (spineAnimation.slots!=null)
addSlotAnimationToClip(animationClip, spineAnimation.slots, spineData, skinList, attachmentGOByNameBySlot);
if ( spineAnimation.events != null )
AddEvents( animationClip, spineAnimation.events, animationName );
if (spineAnimation.draworder!=null)
addDrawOrderAnimation( animationClip, spineAnimation.draworder, spineData, zStep, animationName, slotByName );
if (updateCurve){
EditorUtility.SetDirty(animationClip);
AssetDatabase.SaveAssets();
} else {
animationClip.frameRate = 30;
createFolderIfNoExists(rootDirectory, ANIMATION_FOLDER);
AssetDatabase.CreateAsset(animationClip, assetPath);
AssetDatabase.SaveAssets();
if (modelImporterAnimationType == ModelImporterAnimationType.Generic)
AddClipToAnimatorComponent(rootGO,animationClip);
else
AddClipToLegacyAnimationComponent(rootGO, animationClip);
}
}
}
private static GameObject CalculatePreviewGameObject(Animator selectedAnimator, Motion motion, ModelImporterAnimationType animationType)
{
AnimationClip animationClipFromMotion = AvatarPreview.GetFirstAnimationClipFromMotion(motion);
GameObject preview = AvatarPreviewSelection.GetPreview(animationType);
if (AvatarPreview.IsValidPreviewGameObject(preview, ModelImporterAnimationType.None))
return preview;
if ((Object) selectedAnimator != (Object) null && AvatarPreview.IsValidPreviewGameObject(selectedAnimator.gameObject, animationType))
return selectedAnimator.gameObject;
GameObject objectFromModelAsset = AvatarPreview.FindBestFittingRenderableGameObjectFromModelAsset((Object) animationClipFromMotion, animationType);
if ((Object) objectFromModelAsset != (Object) null)
return objectFromModelAsset;
if (animationType == ModelImporterAnimationType.Human)
return AvatarPreview.GetHumanoidFallback();
if (animationType == ModelImporterAnimationType.Generic)
return AvatarPreview.GetGenericAnimationFallback();
return (GameObject) null;
}
private static GameObject CalculatePreviewGameObject(Animator selectedAnimator, Motion motion, ModelImporterAnimationType animationType)
{
AnimationClip firstAnimationClipFromMotion = AvatarPreview.GetFirstAnimationClipFromMotion(motion);
GameObject gameObject = AvatarPreviewSelection.GetPreview(animationType);
if (AvatarPreview.IsValidPreviewGameObject(gameObject, ModelImporterAnimationType.None))
{
return gameObject;
}
if (selectedAnimator != null && AvatarPreview.IsValidPreviewGameObject(selectedAnimator.gameObject, animationType))
{
return selectedAnimator.gameObject;
}
gameObject = AvatarPreview.FindBestFittingRenderableGameObjectFromModelAsset(firstAnimationClipFromMotion, animationType);
if (gameObject != null)
{
return gameObject;
}
if (animationType == ModelImporterAnimationType.Human)
{
return AvatarPreview.GetHumanoidFallback();
}
if (animationType == ModelImporterAnimationType.Generic)
{
return AvatarPreview.GetGenericAnimationFallback();
}
return null;
}
