internal override void Apply()
{
ModelImporterRigEditor.MappingRelevantSettings[] relevantSettingsArray1 = new ModelImporterRigEditor.MappingRelevantSettings[this.targets.Length];
for (int index = 0; index < this.targets.Length; ++index)
{
SerializedObject serializedObject = new SerializedObject(this.targets[index]);
SerializedProperty property1 = serializedObject.FindProperty("m_AnimationType");
SerializedProperty property2 = serializedObject.FindProperty("m_CopyAvatar");
relevantSettingsArray1[index].humanoid = property1.intValue == 3;
relevantSettingsArray1[index].hasNoAnimation = property1.intValue == 0;
relevantSettingsArray1[index].copyAvatar = property2.boolValue;
}
ModelImporterRigEditor.MappingRelevantSettings[] relevantSettingsArray2 = new ModelImporterRigEditor.MappingRelevantSettings[this.targets.Length];
Array.Copy((Array)relevantSettingsArray1, (Array)relevantSettingsArray2, this.targets.Length);
for (int index = 0; index < this.targets.Length; ++index)
{
if (!this.m_AnimationType.hasMultipleDifferentValues)
{
relevantSettingsArray2[index].humanoid = this.m_AnimationType.intValue == 3;
}
if (!this.m_CopyAvatar.hasMultipleDifferentValues)
{
relevantSettingsArray2[index].copyAvatar = this.m_CopyAvatar.boolValue;
}
}
this.serializedObject.ApplyModifiedProperties();
for (int index = 0; index < this.targets.Length; ++index)
{
if (relevantSettingsArray1[index].usesOwnAvatar && !relevantSettingsArray2[index].usesOwnAvatar)
{
SerializedObject serializedObject = new SerializedObject(this.targets[index]);
AvatarSetupTool.ClearAll(serializedObject);
serializedObject.ApplyModifiedProperties();
}
if (!relevantSettingsArray1[index].usesOwnAvatar && relevantSettingsArray2[index].usesOwnAvatar)
{
ModelImporter target = this.targets[index] as ModelImporter;
if (relevantSettingsArray1[index].hasNoAnimation)
{
AssetDatabase.ImportAsset(target.assetPath);
}
SerializedObject modelImporterSerializedObject = new SerializedObject(this.targets[index]);
GameObject gameObject = AssetDatabase.LoadMainAssetAtPath(target.assetPath) as GameObject;
Animator component = gameObject.GetComponent <Animator>();
bool flag = (bool)((UnityEngine.Object)component) && !component.hasTransformHierarchy;
if (flag)
{
gameObject = UnityEngine.Object.Instantiate <GameObject>(gameObject);
AnimatorUtility.DeoptimizeTransformHierarchy(gameObject);
}
AvatarSetupTool.AutoSetupOnInstance(gameObject, modelImporterSerializedObject);
this.m_IsBiped = AvatarBipedMapper.IsBiped(gameObject.transform, this.m_BipedMappingReport);
if (flag)
{
UnityEngine.Object.DestroyImmediate((UnityEngine.Object)gameObject);
}
modelImporterSerializedObject.ApplyModifiedProperties();
}
}
}
static void OptimizeAnimatorHierarchyPrefab(GameObject prefabInstance, List <string> exposedBones)
{
var animatorGO = prefabInstance.GetComponentInChildren <Animator>().gameObject;
List <string> customBones = new List <string>();
customBones.AddRange(exposedBones);
var gameObjectParentPairDict = new Dictionary <GameObject, string>();
FindEmptyGameObjects(prefabInstance, gameObjectParentPairDict);
foreach (var customObject in gameObjectParentPairDict)
{
customBones.Add(customObject.Value);
customObject.Key.transform.parent = null;
}
// Optimise the bones:
AnimatorUtility.OptimizeTransformHierarchy(
animatorGO, customBones.ToArray());
foreach (var customObject in gameObjectParentPairDict)
{
//customObject.Key.transform.parent = prefabInstance.transform.FindInChildren(customObject.Value);
customObject.Key.transform.parent = prefabInstance.transform.Find(customObject.Value);
}
}
private static void CheckFishAnimation()
{
//魚FBXのパス一覧を取得
var fishFbxPathList = AssetDatabase
.FindAssets("t:GameObject", new string[] { "Assets/Sunchoi/AssetbundleResources/Resources/Models/Fish" })
.Select(guid => AssetDatabase.GUIDToAssetPath(guid))
.Where(path => Path.GetExtension(path).Equals(".fbx", StringComparison.OrdinalIgnoreCase))
.ToArray();
int errorCount = 0;
foreach (string path in fishFbxPathList)
{
var animatorController = AnimatorUtility.FindAnimatorController(Path.GetDirectoryName(path));
if (animatorController != null)
{
foreach (var childAnimatorState in animatorController.layers[0].stateMachine.states)
{
string stateName = childAnimatorState.state.name;
if (stateName != "oyogi" &&
stateName != "hirumi" &&
stateName != "hokakuseikou")
{
errorCount++;
Debug.LogWarningFormat("{0} : {1}", path, stateName);
}
}
}
}
Debug.LogFormat("魚のアニメーション名エラー数{0}件", errorCount);
}
void Init()
{
// Add hero list
var characterList = CharacterList.instance;
if (!characterList.squadCharacters.Any())
{
return;
}
foreach (var character in characterList.squadCharacters)
{
marathonRunner.AddToRunner(character);
heroPositions.AddToPosition(character);
// Active the animation layer by hero's job.
// This will be removed out because of temporary.
AnimatorUtility.ActiveLayer(character.animator, character.baseJob.label.ToString());
}
// Add monster list
var monsterList = MonsterList.instance;
if (!monsterList.monsters.Any())
{
return;
}
foreach (var monster in monsterList.monsters)
{
marathonRunner.AddToRunner(monster);
monsterPositions.AddToPosition(monster);
AnimatorUtility.ActiveLayer(monster.animator, monster.baseJob.label.ToString());
}
}
internal override void Apply()
{
MappingRelevantSettings[] sourceArray = new MappingRelevantSettings[base.targets.Length];
for (int i = 0; i < base.targets.Length; i++)
{
SerializedObject obj2 = new SerializedObject(base.targets[i]);
SerializedProperty property = obj2.FindProperty("m_AnimationType");
SerializedProperty property2 = obj2.FindProperty("m_CopyAvatar");
sourceArray[i].humanoid = property.intValue == 3;
sourceArray[i].hasNoAnimation = property.intValue == 0;
sourceArray[i].copyAvatar = property2.boolValue;
}
MappingRelevantSettings[] destinationArray = new MappingRelevantSettings[base.targets.Length];
Array.Copy(sourceArray, destinationArray, base.targets.Length);
for (int j = 0; j < base.targets.Length; j++)
{
if (!this.m_AnimationType.hasMultipleDifferentValues)
{
destinationArray[j].humanoid = this.m_AnimationType.intValue == 3;
}
if (!this.m_CopyAvatar.hasMultipleDifferentValues)
{
destinationArray[j].copyAvatar = this.m_CopyAvatar.boolValue;
}
}
base.serializedObject.ApplyModifiedProperties();
for (int k = 0; k < base.targets.Length; k++)
{
if (sourceArray[k].usesOwnAvatar && !destinationArray[k].usesOwnAvatar)
{
SerializedObject serializedObject = new SerializedObject(base.targets[k]);
AvatarSetupTool.ClearAll(serializedObject);
serializedObject.ApplyModifiedProperties();
}
if (!sourceArray[k].usesOwnAvatar && destinationArray[k].usesOwnAvatar)
{
ModelImporter importer = base.targets[k] as ModelImporter;
if (sourceArray[k].hasNoAnimation)
{
AssetDatabase.ImportAsset(importer.assetPath);
}
SerializedObject modelImporterSerializedObject = new SerializedObject(base.targets[k]);
GameObject original = AssetDatabase.LoadMainAssetAtPath(importer.assetPath) as GameObject;
Animator component = original.GetComponent <Animator>();
bool flag = (component != null) && !component.hasTransformHierarchy;
if (flag)
{
original = UnityEngine.Object.Instantiate <GameObject>(original);
AnimatorUtility.DeoptimizeTransformHierarchy(original);
}
AvatarSetupTool.AutoSetupOnInstance(original, modelImporterSerializedObject);
this.m_IsBiped = AvatarBipedMapper.IsBiped(original.transform);
if (flag)
{
UnityEngine.Object.DestroyImmediate(original);
}
modelImporterSerializedObject.ApplyModifiedProperties();
}
}
}
internal override void Apply()
{
ModelImporterRigEditor.MappingRelevantSettings[] array = new ModelImporterRigEditor.MappingRelevantSettings[base.targets.Length];
for (int i = 0; i < base.targets.Length; i++)
{
SerializedObject serializedObject = new SerializedObject(base.targets[i]);
SerializedProperty serializedProperty = serializedObject.FindProperty("m_AnimationType");
SerializedProperty serializedProperty2 = serializedObject.FindProperty("m_CopyAvatar");
array[i].humanoid = (serializedProperty.intValue == 3);
array[i].hasNoAnimation = (serializedProperty.intValue == 0);
array[i].copyAvatar = serializedProperty2.boolValue;
}
ModelImporterRigEditor.MappingRelevantSettings[] array2 = new ModelImporterRigEditor.MappingRelevantSettings[base.targets.Length];
Array.Copy(array, array2, base.targets.Length);
for (int j = 0; j < base.targets.Length; j++)
{
if (!this.m_AnimationType.hasMultipleDifferentValues)
{
array2[j].humanoid = (this.m_AnimationType.intValue == 3);
}
if (!this.m_CopyAvatar.hasMultipleDifferentValues)
{
array2[j].copyAvatar = this.m_CopyAvatar.boolValue;
}
}
base.serializedObject.ApplyModifiedProperties();
for (int k = 0; k < base.targets.Length; k++)
{
if (array[k].usesOwnAvatar && !array2[k].usesOwnAvatar)
{
SerializedObject serializedObject2 = new SerializedObject(base.targets[k]);
AvatarSetupTool.ClearAll(serializedObject2);
serializedObject2.ApplyModifiedProperties();
}
if (!array[k].usesOwnAvatar && array2[k].usesOwnAvatar)
{
ModelImporter modelImporter = base.targets[k] as ModelImporter;
if (array[k].hasNoAnimation)
{
AssetDatabase.ImportAsset(modelImporter.assetPath);
}
SerializedObject serializedObject3 = new SerializedObject(base.targets[k]);
GameObject gameObject = AssetDatabase.LoadMainAssetAtPath(modelImporter.assetPath) as GameObject;
Animator component = gameObject.GetComponent <Animator>();
bool flag = component && !component.hasTransformHierarchy;
if (flag)
{
gameObject = UnityEngine.Object.Instantiate <GameObject>(gameObject);
AnimatorUtility.DeoptimizeTransformHierarchy(gameObject);
}
AvatarSetupTool.AutoSetupOnInstance(gameObject, serializedObject3);
this.m_IsBiped = AvatarBipedMapper.IsBiped(gameObject.transform, this.m_BipedMappingReport);
if (flag)
{
UnityEngine.Object.DestroyImmediate(gameObject);
}
serializedObject3.ApplyModifiedProperties();
}
}
}
public void Optimize()
{
if (!IsCanOptmizeOrDeoptmize())
{
return;
}
//取出节点内部第一层的优化器
var nodeDict = TakeOutChildren();
//节点暴露列表
var exposeList = GetExposeBones(nodeDict); //父节点暴露出来,免得被优化
AnimatorUtility.OptimizeTransformHierarchy(gameObject, exposeList.ToArray());
var animator = gameObject.GetComponent <Animator>();
if (animator != null)
{
animator.Update(0.001f);
}
m_isOptimezed = true;
//取出所有含animator的节点到同级父节点去
PutBackChildren(nodeDict);
}
static int DeoptimizeTransformHierarchy(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
GameObject arg0 = LuaScriptMgr.GetNetObject <GameObject>(L, 1);
AnimatorUtility.DeoptimizeTransformHierarchy(arg0);
return(0);
}
public Transform[] GetBones(Renderer r)
{
if (r is SkinnedMeshRenderer)
{
Transform[] bone;
//check if I need to deoptimize
bool didDeoptimize = false;
Animator anim = r.GetComponentInParent <Animator>();
if (anim != null)
{
if (anim.hasTransformHierarchy)
{
//nothing to do
}
else if (anim.isOptimizable)
{
//Deoptimize
AnimatorUtility.DeoptimizeTransformHierarchy(anim.gameObject);
didDeoptimize = true;
}
else
{
Debug.LogError("Could not getBones. Bones optimized but could not create TransformHierarchy.");
return(null);
}
bone = ((SkinnedMeshRenderer)r).bones;
//can't deoptimize here because the transforms need to exist for the combined mesh
}
else
{
//no Animator component but check to see if bones were optimized on import
bone = ((SkinnedMeshRenderer)r).bones;
#if UNITY_EDITOR
if (bone.Length == 0)
{
Mesh m = ((SkinnedMeshRenderer)r).sharedMesh;
if (m.bindposes.Length != bone.Length)
{
Debug.LogError("SkinnedMesh (" + r.gameObject + ") in the list of objects to combine has no bones. Check that 'optimize game object' is not checked in the 'Rig' tab of the asset importer. Mesh Baker cannot combine optimized skinned meshes because the bones are not available.");
}
}
#endif
}
return(bone);
}
else if (r is MeshRenderer)
{
Transform[] bone = new Transform[1];
bone[0] = r.transform;
return(bone);
}
else
{
Debug.LogError("Could not getBones. Object is not a Renderer.");
return(null);
}
}
static int OptimizeTransformHierarchy(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
GameObject arg0 = LuaScriptMgr.GetNetObject <GameObject>(L, 1);
string[] objs1 = LuaScriptMgr.GetArrayString(L, 2);
AnimatorUtility.OptimizeTransformHierarchy(arg0, objs1);
return(0);
}
internal void SwitchToEditMode()
{
m_EditMode = EditMode.Starting;
// Lock inspector
ChangeInspectorLock(true);
// Store current setup in hierarchy
sceneSetup = EditorSceneManager.GetSceneManagerSetup();
// Load temp scene
Scene scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
scene.name = "Avatar Configuration";
// Instantiate character
m_GameObject = Instantiate(prefab) as GameObject;
if (serializedAssetImporter.FindProperty("m_OptimizeGameObjects").boolValue)
{
AnimatorUtility.DeoptimizeTransformHierarchy(m_GameObject);
}
// First get all available modelBones
Dictionary <Transform, bool> modelBones = AvatarSetupTool.GetModelBones(m_GameObject.transform, true, null);
AvatarSetupTool.BoneWrapper[] humanBones = AvatarSetupTool.GetHumanBones(serializedAssetImporter, modelBones);
m_ModelBones = AvatarSetupTool.GetModelBones(m_GameObject.transform, false, humanBones);
Selection.activeObject = m_GameObject;
// Unfold all nodes in hierarchy
// TODO@MECANIM: Only expand actual bones
foreach (SceneHierarchyWindow shw in Resources.FindObjectsOfTypeAll(typeof(SceneHierarchyWindow)))
{
shw.SetExpandedRecursive(m_GameObject.GetInstanceID(), true);
}
CreateEditor();
m_EditMode = EditMode.Editing;
// Frame in scene view
m_SceneStates = new List <SceneStateCache>();
foreach (SceneView s in SceneView.sceneViews)
{
m_SceneStates.Add(new SceneStateCache {
state = new SceneView.SceneViewState(s.sceneViewState), view = s
});
s.sceneViewState.showFlares = false;
s.sceneViewState.showMaterialUpdate = false;
s.sceneViewState.showFog = false;
s.sceneViewState.showSkybox = false;
s.sceneViewState.showImageEffects = false;
s.sceneViewState.showParticleSystems = false;
s.FrameSelected();
}
}
internal void SwitchToEditMode()
{
this.m_EditMode = AvatarEditor.EditMode.Starting;
this.ChangeInspectorLock(true);
this.sceneSetup = EditorSceneManager.GetSceneManagerSetup();
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects).name = "Avatar Configuration";
this.m_GameObject = UnityEngine.Object.Instantiate <GameObject>(this.prefab);
if (base.serializedObject.FindProperty("m_OptimizeGameObjects").boolValue)
{
AnimatorUtility.DeoptimizeTransformHierarchy(this.m_GameObject);
}
Dictionary <Transform, bool> modelBones = AvatarSetupTool.GetModelBones(this.m_GameObject.transform, true, null);
AvatarSetupTool.BoneWrapper[] humanBones = AvatarSetupTool.GetHumanBones(base.serializedObject, modelBones);
this.m_ModelBones = AvatarSetupTool.GetModelBones(this.m_GameObject.transform, false, humanBones);
Selection.activeObject = this.m_GameObject;
UnityEngine.Object[] array = Resources.FindObjectsOfTypeAll(typeof(SceneHierarchyWindow));
for (int i = 0; i < array.Length; i++)
{
SceneHierarchyWindow sceneHierarchyWindow = (SceneHierarchyWindow)array[i];
sceneHierarchyWindow.SetExpandedRecursive(this.m_GameObject.GetInstanceID(), true);
}
this.CreateEditor();
this.m_EditMode = AvatarEditor.EditMode.Editing;
this.m_SceneStates = new List <AvatarEditor.SceneStateCache>();
IEnumerator enumerator = SceneView.sceneViews.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
SceneView sceneView = (SceneView)enumerator.Current;
this.m_SceneStates.Add(new AvatarEditor.SceneStateCache
{
state = new SceneView.SceneViewState(sceneView.sceneViewState),
view = sceneView
});
sceneView.sceneViewState.showFlares = false;
sceneView.sceneViewState.showMaterialUpdate = false;
sceneView.sceneViewState.showFog = false;
sceneView.sceneViewState.showSkybox = false;
sceneView.sceneViewState.showImageEffects = false;
sceneView.sceneViewState.showParticleSystems = false;
sceneView.FrameSelected();
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
private void OnBodyChange()
{
int roleKey = PlayerData.roleType;
RoleKeyCfg roleKeyCfg = roleKeyCfgLoader.GetConfig(roleKey);
string skinName = roleKeyCfg.BornBody;
if (skinName == lastSkinName)
{
return;
}
lastSkinName = skinName;
if (skinnedMeshRenderer == null)
{
skinnedMeshRenderer = playerSkeleton.AddComponent <SkinnedMeshRenderer>();
}
else
{
DestroyImmediate(skinnedMeshRenderer);
skinnedMeshRenderer = playerSkeleton.AddComponent <SkinnedMeshRenderer>();
}
AnimatorUtility.DeoptimizeTransformHierarchy(playerSkeleton);
string resPath = string.Format("models/skin_{0}.bundle", skinName);
//添加个使用默认皮肤
SkinnedMeshData skinData = null;
skinData = AssetBundleManager.LoadAsset <SkinnedMeshData>(resPath, "skin_" + skinName);
Transform[] bones = new Transform[skinData.bones.Length];
Transform modelTrans = playerSkeleton.transform;
for (int i = 0; i < skinData.bones.Length; i++)
{
var bonePath = skinData.bones[i];
bones[i] = modelTrans.Find(bonePath);
if (bones[i] == null)
{
Debug.LogWarningFormat("Can not find bone {0} on {1}", bonePath, skinName);
}
}
skinnedMeshRenderer.bones = bones;
skinnedMeshRenderer.sharedMaterials = skinData.materials;
skinnedMeshRenderer.sharedMesh = skinData.mesh;
AnimatorUtility.OptimizeTransformHierarchy(playerSkeleton, skinData.extraTransformNames);
OnRendererChange();
}
void OptimizeHierarchy(Animator animator)
{
foreach (var animators in ObjectUtil.GetAll <Animator>(this))
{
var root = animator.gameObject;
var transforms = ObjectUtil.GetAll <Component>(root)
.Where(comp => !(comp is Transform))
.Select(comp => comp.name)
.Distinct()
.ToArray();
AnimatorUtility.OptimizeTransformHierarchy(root, transforms);
}
}
internal void SwitchToEditMode()
{
this.m_EditMode = AvatarEditor.EditMode.Starting;
this.ChangeInspectorLock(true);
this.sceneSetup = EditorSceneManager.GetSceneManagerSetup();
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects).name = "Avatar Configuration";
this.m_GameObject = UnityEngine.Object.Instantiate <GameObject>(this.prefab);
if (base.serializedObject.FindProperty("m_OptimizeGameObjects").boolValue)
{
AnimatorUtility.DeoptimizeTransformHierarchy(this.m_GameObject);
}
Animator component = this.m_GameObject.GetComponent <Animator>();
if (component != null && component.runtimeAnimatorController == null)
{
AnimatorController animatorController = new AnimatorController();
animatorController.hideFlags = HideFlags.DontSave;
animatorController.AddLayer("preview");
animatorController.layers[0].stateMachine.hideFlags = HideFlags.DontSave;
component.runtimeAnimatorController = animatorController;
}
Dictionary <Transform, bool> modelBones = AvatarSetupTool.GetModelBones(this.m_GameObject.transform, true, null);
AvatarSetupTool.BoneWrapper[] humanBones = AvatarSetupTool.GetHumanBones(base.serializedObject, modelBones);
this.m_ModelBones = AvatarSetupTool.GetModelBones(this.m_GameObject.transform, false, humanBones);
Selection.activeObject = this.m_GameObject;
UnityEngine.Object[] array = Resources.FindObjectsOfTypeAll(typeof(SceneHierarchyWindow));
for (int i = 0; i < array.Length; i++)
{
SceneHierarchyWindow sceneHierarchyWindow = (SceneHierarchyWindow)array[i];
sceneHierarchyWindow.SetExpandedRecursive(this.m_GameObject.GetInstanceID(), true);
}
this.CreateEditor();
this.m_EditMode = AvatarEditor.EditMode.Editing;
this.m_SceneStates = new List <AvatarEditor.SceneStateCache>();
foreach (SceneView sceneView in SceneView.sceneViews)
{
this.m_SceneStates.Add(new AvatarEditor.SceneStateCache
{
state = new SceneView.SceneViewState(sceneView.m_SceneViewState),
view = sceneView
});
sceneView.m_SceneViewState.showFlares = false;
sceneView.m_SceneViewState.showMaterialUpdate = false;
sceneView.m_SceneViewState.showFog = false;
sceneView.m_SceneViewState.showSkybox = false;
sceneView.m_SceneViewState.showImageEffects = false;
sceneView.FrameSelected();
}
}
void OptimizeHierarchy()
{
var animator = GetComponentInChildren <Animator>();
foreach (var animators in GetComponentsInChildren <Animator>())
{
var root = animator.gameObject;
var transforms = root.GetComponentsInChildren <Component>()
.Where(comp => !(comp is Transform))
.Select(comp => comp.name)
.Distinct()
.ToArray();
AnimatorUtility.OptimizeTransformHierarchy(root, transforms);
}
}
private void ToolsResetPose(GameObject activeGameObject, GameObject activePrefab)
{
var go = GameObject.Instantiate <GameObject>(activePrefab);
AnimatorUtility.DeoptimizeTransformHierarchy(go);
go.hideFlags |= HideFlags.HideAndDontSave;
{
Dictionary <string, Transform> srcList = new Dictionary <string, Transform>();
Dictionary <string, Transform> dstList = new Dictionary <string, Transform>();
{
Action <Dictionary <string, Transform>, Transform, Transform> SaveTransform = null;
SaveTransform = (transforms, t, root) =>
{
var path = AnimationUtility.CalculateTransformPath(t, root);
if (!transforms.ContainsKey(path))
{
transforms.Add(path, t);
}
for (int i = 0; i < t.childCount; i++)
{
SaveTransform(transforms, t.GetChild(i), root);
}
};
for (int i = 0; i < go.transform.childCount; i++)
{
SaveTransform(srcList, go.transform.GetChild(i), go.transform);
}
for (int i = 0; i < activeGameObject.transform.childCount; i++)
{
SaveTransform(dstList, activeGameObject.transform.GetChild(i), activeGameObject.transform);
}
}
foreach (var pair in dstList)
{
Transform srcT;
if (srcList.TryGetValue(pair.Key, out srcT))
{
var dstT = pair.Value;
Undo.RecordObject(dstT, "Reset Pose");
dstT.localPosition = srcT.localPosition;
dstT.localRotation = srcT.localRotation;
dstT.localScale = srcT.localScale;
}
}
}
GameObject.DestroyImmediate(go);
}
public static int constructor(IntPtr l)
{
int result;
try
{
AnimatorUtility o = new AnimatorUtility();
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, o);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
void Deoptimize()
{
if (prefabs == null || prefabs.Count == 0)
{
return;
}
foreach (var prefab in prefabs)
{
var inst = GameObject.Instantiate(prefab);
AnimatorUtility.DeoptimizeTransformHierarchy(inst);
PrefabUtility.ReplacePrefab(inst, prefab);
GameObject.DestroyImmediate(inst);
}
FindPrefabs();
}
static int _CreateAnimatorUtility(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 0)
{
AnimatorUtility obj = new AnimatorUtility();
LuaScriptMgr.PushObject(L, obj);
return(1);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: AnimatorUtility.New");
}
return(0);
}
public static float GetStateLength(Animator animator, string stateName)
{
UnityEditor.Animations.AnimatorState animState = AnimatorUtility.GetState(animator, stateName, 0);
if (animState == null)
{
return(0f);
}
if (animState.motion == null)
{
return(0f);
}
var clip = (AnimationClip)animState.motion;
return(clip.length);
}
public void CreateExtraValues()
{
{
prefabValues = new Dictionary <SkinnedMeshRenderer, SaveData>();
#if UNITY_2018_2_OR_NEWER
var prefab = PrefabUtility.GetCorrespondingObjectFromSource(rootObject) as GameObject;
#else
var prefab = PrefabUtility.GetPrefabParent(rootObject) as GameObject;
#endif
if (prefab != null)
{
var go = GameObject.Instantiate <GameObject>(prefab);
AnimatorUtility.DeoptimizeTransformHierarchy(go);
go.hideFlags |= HideFlags.HideAndDontSave;
{
foreach (var renderer in prefab.GetComponentsInChildren <SkinnedMeshRenderer>(true))
{
if (renderer == null || renderer.sharedMesh == null || renderer.sharedMesh.blendShapeCount == 0)
{
continue;
}
var save = new SaveData()
{
values = new Dictionary <string, float>(),
};
for (int i = 0; i < renderer.sharedMesh.blendShapeCount; i++)
{
var name = renderer.sharedMesh.GetBlendShapeName(i);
if (!save.values.ContainsKey(name))
{
save.values.Add(name, renderer.GetBlendShapeWeight(i));
}
}
var path = AnimationUtility.CalculateTransformPath(renderer.transform, prefab.transform);
SkinnedMeshRenderer originalRenderer;
if (renderers.TryGetValue(path, out originalRenderer))
{
prefabValues.Add(originalRenderer, save);
}
}
}
GameObject.DestroyImmediate(go);
}
}
}
/// <summary>
/// Optimizes the animator.
/// </summary>
/// <returns>The animator.</returns>
/// <param name="thiz">Thiz.</param>
public static GameObject OptimizeAnimator(this GameObject thiz)
{
var animators = thiz.GetComponentsInChildren <Animator>();
// Debug.LogError("animators--->" + animators.Length);
for (int i = 0; i < animators.Length; ++i)
{
var ani = animators[i];
if (ani != null && ani.isOptimizable)
{
// Debug.LogError("xxxxxxxxx");
ani.logWarnings = false;
AnimatorUtility.OptimizeTransformHierarchy(ani.gameObject, null);
}
}
return(thiz);
}
public static int DeoptimizeTransformHierarchy_s(IntPtr l)
{
int result;
try
{
GameObject go;
LuaObject.checkType <GameObject>(l, 1, out go);
AnimatorUtility.DeoptimizeTransformHierarchy(go);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
void InitAnimations()
{
animator = realTragetGo.GetComponentInChildren <Animator>();
animationClips = animator.runtimeAnimatorController.animationClips;
animationClipNames = new string[animationClips.Length];
for (int i = 0; i < animationClips.Length; i++)
{
animationClipNames[i] = animationClips[i].name;
}
//必须为挂载animator的骨骼
animationCtrl.SetOwnGo(animator.gameObject);
animationCtrl.SetClip(animationClips[0]);
if (animator.isOptimizable)
{
AnimatorUtility.DeoptimizeTransformHierarchy(animator.gameObject);
deoptimize = true;
}
}
public void BindBallToPlayer()
{
var go = GameObject.Instantiate(ball);
//AnimatorUtility.DeoptimizeTransformHierarchy(player);
AnimatorUtility.OptimizeTransformHierarchy(player, new string[] {});
Transform[] transforms = player.GetComponentsInChildren <Transform>(true);
for (int i = 0; i < transforms.Length; i++)
{
if (transforms[i].name.Equals(_bindName))
{
go.transform.SetParent(transforms[i], false);
go.transform.localPosition = Vector3.zero;
break;
}
}
}
public static int OptimizeTransformHierarchy_s(IntPtr l)
{
int result;
try
{
GameObject go;
LuaObject.checkType <GameObject>(l, 1, out go);
string[] exposedTransforms;
LuaObject.checkArray <string>(l, 2, out exposedTransforms);
AnimatorUtility.OptimizeTransformHierarchy(go, exposedTransforms);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
internal void SwitchToEditMode()
{
// Lock inspector
ChangeInspectorLock(true);
string assetPath = AssetDatabase.GetAssetPath(target);
AvatarConfigurationStage stage = AvatarConfigurationStage.CreateStage(assetPath, this);
StageUtility.GoToStage(stage, true);
m_EditMode = EditMode.Starting;
// Instantiate character
m_GameObject = stage.gameObject;
if (serializedAssetImporter.FindProperty("m_OptimizeGameObjects").boolValue)
{
AnimatorUtility.DeoptimizeTransformHierarchy(m_GameObject);
}
SerializedProperty humanBoneArray = serializedAssetImporter.FindProperty("m_HumanDescription.m_Human");
// First get all available modelBones
Dictionary <Transform, bool> modelBones = AvatarSetupTool.GetModelBones(m_GameObject.transform, true, null);
AvatarSetupTool.BoneWrapper[] humanBones = AvatarSetupTool.GetHumanBones(humanBoneArray, modelBones);
m_ModelBones = AvatarSetupTool.GetModelBones(m_GameObject.transform, false, humanBones);
// Unfold all nodes in hierarchy
// TODO@MECANIM: Only expand actual bones
foreach (SceneHierarchyWindow shw in Resources.FindObjectsOfTypeAll(typeof(SceneHierarchyWindow)))
{
shw.SetExpandedRecursive(m_GameObject.GetInstanceID(), true);
}
CreateEditor();
m_EditMode = EditMode.Editing;
}
public void Deoptimize()
{
if (!IsCanOptmizeOrDeoptmize())
{
return;
}
//取出节点内部第一层的优化器
var nodeDict = TakeOutChildren();
AnimatorUtility.DeoptimizeTransformHierarchy(gameObject);
var animator = gameObject.GetComponent <Animator>();
if (animator != null)
{
animator.Update(0.001f);
}
m_isOptimezed = false;
//复原所有含animator的节点回相应的地方去
PutBackChildren(nodeDict);
}
public void Save()
{
var go = this.Target;
this.Animator.enabled = true;
if (Tid.Contains("npc999"))
{
if (this.Animator.isOptimizable)
{
//AnimatorUtility.OptimizeTransformHierarchy(go, new string[] { });
}
}
if (cm.MainScene && this.Animator.isOptimizable)
{
AnimatorUtility.OptimizeTransformHierarchy(go, exposedBones);
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
}
var prefabPath = GetPrefabPath();
Directory.CreateDirectory(Path.GetDirectoryName(prefabPath));
var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(prefabPath);
if (prefab == null)
{
LogUtil.Debug("create prefab " + prefabPath);
PrefabUtility.CreatePrefab(prefabPath, go, ReplacePrefabOptions.ConnectToPrefab);
}
else
{
LogUtil.Debug("replace prefab " + prefabPath);
PrefabUtility.ReplacePrefab(go, prefab, ReplacePrefabOptions.ReplaceNameBased);
EditorUtility.SetDirty(prefab);
}
}
