private void CreateStateMachine()
{
if (avatarPreview == null || avatarPreview.Animator == null)
{
return;
}
if (controller == null)
{
controller = new UnityEditor.Animations.AnimatorController();
controller.AddLayer("preview");
controller.hideFlags = HideFlags.DontSave;
//stateMachine = controller.GetLayer(0).stateMachine;
CreateParameters();
state = stateMachine.AddState("preview");
state.SetMotion(previewedMotion);
state.iKOnFeet = avatarPreview.IKOnFeet;
state.hideFlags = HideFlags.DontSave;
UnityEditor.Animations.AnimatorController.SetAnimatorController(avatarPreview.Animator, controller);
}
//if (UnityEditor.Animations.AnimatorController.GetEffectiveAnimatorController(avatarPreview.Animator) != this.controller)
//{
// UnityEditor.Animations.AnimatorController.SetAnimatorController(avatarPreview.Animator, this.controller);
//}
}
public static GameObject InstantiateWithAnimation(GameObject go, AnimationClip animClip) //Used after the user has selected a GameObject and an AnimationClip to edit; instantiates the GameObject into the scene and sets it up appropriately.
{
ForceLoop(animClip);
GameObject newGo = GameObject.Instantiate(go);
if (newGo.GetComponent <Animator> () != null)
{
//We don't like Animator for our purposes; ergo, we get rid of it
//TODO: Maybe add support for Animator??
//Object.Destroy(newGo.GetComponent<Animator>());
}
/*if (newGo.GetComponent<Animation> () != null) {
* newGo.GetComponent<Animation> ().clip = animClip;
* } else {
* newGo.AddComponent<Animation> ();
* newGo.GetComponent<Animation> ().clip = animClip;
* }
*
* newGo.GetComponent<Animation> ().AddClip (animClip, "default");
*/
if (newGo.GetComponent <Animator> () != null)
{
UnityEditor.Animations.AnimatorController ac = new UnityEditor.Animations.AnimatorController();
ac.AddLayer("default");
ac.AddMotion(animClip);
newGo.GetComponent <Animator> ().runtimeAnimatorController = ac;
}
return(newGo);
//TODO: May have to tell an Editor class somewhere that our current object being edited is this newly instantiated GameObject
}
public static void FuncCreateShowHideAnim()
{
var type = typeof(Animator);
string path = GetActiveFolderPath();// AssetDatabase.GetAssetPath(Selection.activeObject);
string assetPath = path + $"/NewShowHide.controller";
var duplicated_index = 1;
while (System.IO.File.Exists(assetPath))
{
assetPath = path + $"/NewShowHide {duplicated_index}.controller";
duplicated_index++;
}
var controller = new UnityEditor.Animations.AnimatorController();
AssetDatabase.CreateAsset(controller, assetPath);
Undo.RegisterCreatedObjectUndo(controller, "Generate new controller");
controller.AddLayer("default");
var clip1 = CreateAnimatorClip("Show", controller);
var clip2 = CreateAnimatorClip("Hide", controller);
AssetDatabase.AddObjectToAsset(clip1, controller);
AssetDatabase.AddObjectToAsset(clip2, controller);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
Selection.activeObject = controller;
}
public void Initialize(GameObject sourceObject)
{
Release();
this.sourceObject = sourceObject;
gameObject = sourceObject != null?GameObject.Instantiate <GameObject>(sourceObject) : new GameObject();
gameObject.hideFlags |= HideFlags.HideAndDontSave | HideFlags.HideInInspector;
gameObject.name = sourceObject.name;
EditorCommon.DisableOtherBehaviors(gameObject);
gameObjectTransform = gameObject.transform;
animator = gameObject.GetComponent <Animator>();
if (animator != null)
{
animator.fireEvents = false;
animator.applyRootMotion = false;
animator.updateMode = AnimatorUpdateMode.Normal;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
if (animator.runtimeAnimatorController == null) //In case of Null, AnimationClip.SampleAnimation does not work, so create it.
{
tmpAnimatorController = new UnityEditor.Animations.AnimatorController();
tmpAnimatorController.name = "Very Animation Temporary Controller";
tmpAnimatorController.hideFlags |= HideFlags.HideAndDontSave;
tmpAnimatorController.AddLayer("Very Animation Layer");
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, tmpAnimatorController);
}
}
animation = gameObject.GetComponent <Animation>();
UpdateBones();
#region rendererDictionary
{
rendererDictionary = new Dictionary <Renderer, Renderer>();
var sourceRenderers = sourceObject.GetComponentsInChildren <Renderer>(true);
var objectRenderers = gameObject.GetComponentsInChildren <Renderer>(true);
foreach (var sr in sourceRenderers)
{
if (sr == null)
{
continue;
}
var spath = AnimationUtility.CalculateTransformPath(sr.transform, sourceObject.transform);
var index = ArrayUtility.FindIndex(objectRenderers, (x) => AnimationUtility.CalculateTransformPath(x.transform, gameObject.transform) == spath);
Assert.IsTrue(index >= 0);
if (index >= 0 && !rendererDictionary.ContainsKey(objectRenderers[index]))
{
rendererDictionary.Add(objectRenderers[index], sr);
}
}
}
#endregion
UpdateState();
}
public static AnimatorController CreateAnimatorControllerAtPath(string path)
{
AnimatorController animatorController = new AnimatorController();
animatorController.name = Path.GetFileName(path);
AssetDatabase.CreateAsset(animatorController, path);
animatorController.pushUndo = false;
animatorController.AddLayer("Base Layer");
animatorController.pushUndo = true;
return(animatorController);
}
public static AnimatorController CreateAnimatorControllerAtPath(string path)
{
AnimatorController asset = new AnimatorController {
name = Path.GetFileName(path)
};
AssetDatabase.CreateAsset(asset, path);
asset.pushUndo = false;
asset.AddLayer("Base Layer");
asset.pushUndo = true;
return(asset);
}
void test02()
{
AnimatorController controller =
AnimatorController.CreateAnimatorControllerAtPath("Assets/animation.controller");
// Add parameters
//controller.AddLayer("hahaha");
AnimatorState mstate = new AnimatorState();
mstate.name = "myState";
Motion mmotion = Resources.Load <AnimationClip>("animation/playerClip") as Motion;
mmotion.name = "myMotion";
AnimatorControllerLayer myLayer = new AnimatorControllerLayer();
myLayer.name = "hahaha";
//myLayer.SetOverrideBehaviours(mstate,;
myLayer.SetOverrideMotion(mstate, mmotion);
controller.AddLayer(myLayer);
}
private void CreateLayer(int index, AnimatorController controller)
{
Debug.Log($"Creating layer: {AvaCryptKeyNames[index]}");
string controllerPath = AssetDatabase.GetAssetPath(controller);
AnimatorControllerLayer layer = new AnimatorControllerLayer
{
name = AvaCryptKeyNames[index],
defaultWeight = 1,
stateMachine = new AnimatorStateMachine(),
};
layer.stateMachine.name = string.Format(StateMachineName, index);
controller.AddLayer(layer);
AssetDatabase.AddObjectToAsset(layer.stateMachine, controllerPath);
AssetDatabase.SaveAssets();
AddBlendTree(index, layer, controller);
}
private void InitController()
{
gameObject = dg_get_PreviewObject();
if (gameObject == null)
{
return;
}
var originalGameObject = uAvatarPreviewSelection.GetPreview(dg_get_animationClipType());
animator = dg_get_Animator();
animation = gameObject.GetComponent <Animation>();
if (originalGameObject != null)
{
transformPoseSave = new TransformPoseSave(originalGameObject);
transformPoseSave.SetRootTransform(originalGameObject.transform.position, originalGameObject.transform.rotation, originalGameObject.transform.lossyScale);
transformPoseSave.ChangeTransforms(gameObject);
}
else
{
transformPoseSave = new TransformPoseSave(gameObject);
}
blendShapeWeightSave = new BlendShapeWeightSave(gameObject);
var clip = dg_get_m_SourcePreviewMotion(instance);
if (clip.legacy || instance == null || !((UnityEngine.Object)animator != (UnityEngine.Object)null))
{
if (animation != null)
{
animation.enabled = false; //If vaw.animation.enabled, it is not updated during execution. bug?
}
}
else
{
if (m_Controller == null)
{
m_Controller = new UnityEditor.Animations.AnimatorController();
m_Controller.name = "Avatar Preview AnimatorController";
m_Controller.hideFlags |= HideFlags.HideAndDontSave;
uAnimatorController.SetPushUndo(m_Controller, false);
m_Controller.AddLayer("preview");
m_StateMachine = m_Controller.layers[0].stateMachine;
uAnimatorStateMachine.SetPushUndo(m_StateMachine, false);
m_StateMachine.hideFlags |= HideFlags.HideAndDontSave;
}
if (m_State == null)
{
m_State = m_StateMachine.AddState("preview");
uAnimatorState.SetPushUndo(m_State, false);
m_State.motion = (Motion)clip;
m_State.iKOnFeet = dg_get_ShowIKOnFeetButton() && dg_get_IKOnFeet();
m_State.hideFlags |= HideFlags.HideAndDontSave;
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, this.m_Controller);
animator.fireEvents = false;
animator.applyRootMotion = EditorPrefs.GetBool(EditorPrefsApplyRootMotion, false);
}
dg_set_ShowIKOnFeetButton(animator != null && animator.isHuman && clip.isHumanMotion);
#if !UNITY_2017_3_OR_NEWER
mode2D = EditorPrefs.GetBool(EditorPrefs2D, false);
#endif
SetTime(uTimeControl.currentTime);
ForceUpdate();
}
private void ViewPrefab()
{
EditorUtility.DisplayProgressBar("Prefab Viewer", "Preparing for preview", 0);
var _scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
var _inst = PrefabUtility.InstantiatePrefab(m_Prefab) as GameObject;
Camera _cam = null;
foreach (var _rootObj in _scene.GetRootGameObjects())
{
_cam = _rootObj.GetComponent <Camera>();
if (_cam)
{
break;
}
}
Light _light = null;
foreach (var _rootObj in _scene.GetRootGameObjects())
{
_light = _rootObj.GetComponent <Light>();
if (_light)
{
break;
}
}
GameObject _target = null;
List <Vector3> _lightProbes = new List <Vector3>();
// Zoom extends
if (_cam)
{
Bounds _bounds;
if (Geometry.GetBounds(_inst, out _bounds))
{
Log.I("zoom extends {0}", _bounds);
var _ext = _bounds.extents.magnitude;
_target = new GameObject("Camera Target");
_target.transform.position = _bounds.center + new Vector3(0, 0, 0);
_cam.transform.position = _bounds.center + new Vector3(0, 0, _ext * 2);
_cam.transform.LookAt(_bounds.center);
_cam.nearClipPlane = _ext / 256.0f;
_cam.farClipPlane = Mathf.Max(_ext * 5, 2.0f);
var _min = _bounds.min;
var _max = _bounds.max;
_lightProbes.Add(new Vector3(_min.x, _min.y, _min.z));
_lightProbes.Add(new Vector3(_min.x, _min.y, _max.z));
_lightProbes.Add(new Vector3(_min.x, _max.y, _min.z));
_lightProbes.Add(new Vector3(_min.x, _max.y, _max.z));
_lightProbes.Add(new Vector3(_max.x, _min.y, _min.z));
_lightProbes.Add(new Vector3(_max.x, _min.y, _max.z));
_lightProbes.Add(new Vector3(_max.x, _max.y, _min.z));
_lightProbes.Add(new Vector3(_max.x, _max.y, _max.z));
}
}
// Add 3rd person control
if (_target)
{
var _control = _cam.gameObject.AddComponent <ControlWithInput>();
_control.target = _target.transform;
_control.style = ControlWithInput.ControlStyles.ThirdPerson;
}
// Set current state
Animation _anim = _inst.GetComponent <Animation>();
Animator _anim2 = _inst.GetComponent <Animator>();
bool _indexValid = m_SelectedState >= 0 && m_SelectedState < m_StateNames.Count;
if ((_anim || _anim2) && _indexValid)
{
var _selectedName = m_StateNames[m_SelectedState];
if (_anim)
{
_anim.wrapMode = WrapMode.Loop;
_anim.clip = _anim.GetClip(_selectedName);
}
else if (_anim2)
{
var _controller = new UnityEditor.Animations.AnimatorController();
_controller.name = "PREVIEW";
var _layer = new UnityEditor.Animations.AnimatorControllerLayer();
_layer.stateMachine = new UnityEditor.Animations.AnimatorStateMachine();
var _state = _layer.stateMachine.AddState(_selectedName);
_state.motion = (AnimationClip)m_StateObjects[m_SelectedState];
_controller.AddLayer(_layer);
_anim2.runtimeAnimatorController = _controller;
}
Time.timeScale = m_TimeScale;
}
if (m_Skybox)
{
RenderSettings.skybox = m_Skybox;
}
// Setup Lighting
if (_light)
{
_light.transform.eulerAngles = new Vector3(50, 180, 0);
}
if (_lightProbes.Count > 0)
{
var _lightProbesGroup = new GameObject("LightProbes").AddComponent <LightProbeGroup>();
_lightProbesGroup.probePositions = _lightProbes.ToArray();
}
RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox;
RenderSettings.ambientIntensity = 1.5f;
RenderSettings.ambientSkyColor = Color.white;
RenderSettings.defaultReflectionResolution = 256;
LightmapEditorSettings.realtimeResolution = 0.2f;
Lightmapping.bakedGI = false;
Lightmapping.realtimeGI = true;
Lightmapping.completed += () =>
{
EditorUtility.ClearProgressBar();
EditorApplication.isPlaying = true;
};
}
private void Change(bool change)
{
var t = gameObject.transform;
var localPosition = t.localPosition;
var localRotation = t.localRotation;
var localScale = t.localScale;
Undo.RecordObject(this, "Change Animator Controller");
Undo.RecordObject(animatorCache, "Change Animator Controller");
if (change)
{
Assert.IsFalse(changed);
animatorCache.hideFlags |= HideFlags.NotEditable;
originalAnimatorApplyRootMotion = animatorCache.applyRootMotion;
originalAnimatorUpdateMode = animatorCache.updateMode;
originalAnimatorCullingMode = animatorCache.cullingMode;
animatorCache.applyRootMotion = false;
animatorCache.updateMode = AnimatorUpdateMode.Normal;
animatorCache.cullingMode = AnimatorCullingMode.AlwaysAnimate;
#region AnimatorController
{
originalRuntimeAnimatorController = animatorCache.runtimeAnimatorController;
tmpAnimatorController = new UnityEditor.Animations.AnimatorController();
tmpAnimatorController.name = "Very Animation Temporary Controller";
tmpAnimatorController.hideFlags |= HideFlags.HideAndDontSave;
{
tmpAnimatorController.AddLayer("Very Animation Layer");
layers = tmpAnimatorController.layers;
foreach (var layer in layers)
{
layer.iKPass = true;
var stateMachine = layer.stateMachine;
stateMachine.hideFlags |= HideFlags.HideAndDontSave;
{
state = stateMachine.AddState("Animation");
state.hideFlags |= HideFlags.HideAndDontSave;
stateNameHash = state.nameHash;
}
layer.stateMachine = stateMachine;
}
tmpAnimatorController.layers = layers;
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animatorCache, tmpAnimatorController);
}
#endregion
changed = true;
}
else
{
Assert.IsTrue(changed);
animatorCache.hideFlags &= ~HideFlags.NotEditable;
animatorCache.applyRootMotion = originalAnimatorApplyRootMotion;
animatorCache.updateMode = originalAnimatorUpdateMode;
animatorCache.cullingMode = originalAnimatorCullingMode;
#region AnimatorController
{
{
var layerCount = tmpAnimatorController.layers.Length;
for (int i = 0; i < layerCount; i++)
{
tmpAnimatorController.RemoveLayer(0);
}
}
DestroyImmediate(tmpAnimatorController);
tmpAnimatorController = null;
animatorCache.runtimeAnimatorController = originalRuntimeAnimatorController;
}
#endregion
originalRuntimeAnimatorController = null;
changed = false;
}
//Cause unknown. It does not allow initialization.
{
t.localPosition = localPosition;
t.localRotation = localRotation;
t.localScale = localScale;
}
}
private void InitController()
{
gameObject = dg_get_PreviewObject();
if (gameObject == null)
{
return;
}
originalGameObject = uAvatarPreviewSelection.GetPreview(dg_get_animationClipType());
animator = dg_get_Animator();
animation = gameObject.GetComponent <Animation>();
if (originalGameObject != null)
{
transformPoseSave = new TransformPoseSave(originalGameObject);
transformPoseSave.ChangeStartTransform();
transformPoseSave.ChangeTransformReference(gameObject);
}
else
{
transformPoseSave = new TransformPoseSave(gameObject);
}
blendShapeWeightSave = new BlendShapeWeightSave(gameObject);
var clip = dg_get_m_SourcePreviewMotion(instance);
if (clip.legacy || instance == null || !((UnityEngine.Object)animator != (UnityEngine.Object)null))
{
if (animation != null)
{
animation.enabled = false; //If vaw.animation.enabled, it is not updated during execution. bug?
}
}
else
{
animator.fireEvents = false;
animator.applyRootMotion = EditorPrefs.GetBool(EditorPrefsApplyRootMotion, false);
#if UNITY_2019_1_OR_NEWER
animator.enabled = true;
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, null);
m_PlayableGraph = PlayableGraph.Create("Avatar Preview PlayableGraph");
m_PlayableGraph.SetTimeUpdateMode(DirectorUpdateMode.Manual);
m_AnimationClipPlayable = AnimationClipPlayable.Create(m_PlayableGraph, clip);
m_AnimationClipPlayable.SetApplyPlayableIK(false);
m_AnimationClipPlayable.SetApplyFootIK(isIKOnFeet);
if (m_UAnimationClipPlayable == null)
{
m_UAnimationClipPlayable = new UAnimationClipPlayable();
}
m_UAnimationClipPlayable.SetRemoveStartOffset(m_AnimationClipPlayable, true);
m_UAnimationClipPlayable.SetOverrideLoopTime(m_AnimationClipPlayable, true);
m_UAnimationClipPlayable.SetLoopTime(m_AnimationClipPlayable, true);
Playable rootPlayable = m_AnimationClipPlayable;
#if VERYANIMATION_ANIMATIONRIGGING
m_VARigBuilder = gameObject.GetComponent <VeryAnimationRigBuilder>();
if (m_VARigBuilder != null)
{
RigBuilder.DestroyImmediate(m_VARigBuilder);
m_VARigBuilder = null;
}
m_RigBuilder = gameObject.GetComponent <RigBuilder>();
if (m_RigBuilder != null)
{
RigBuilder.DestroyImmediate(m_RigBuilder);
m_RigBuilder = null;
}
if (originalGameObject != null)
{
var rigBuilder = originalGameObject.GetComponent <RigBuilder>();
if (rigBuilder != null && rigBuilder.isActiveAndEnabled && rigBuilder.enabled)
{
var layers = new List <GameObject>();
foreach (var layer in rigBuilder.layers)
{
if (layer.rig == null || !layer.active)
{
continue;
}
var originalRig = layer.rig.GetComponent <Rig>();
if (originalRig == null)
{
continue;
}
Func <Transform, Transform> GetPreviewTransform = (t) =>
{
if (t == null)
{
return(null);
}
var path = AnimationUtility.CalculateTransformPath(t, originalGameObject.transform);
return(gameObject.transform.Find(path));
};
var previewT = GetPreviewTransform(originalRig.transform);
if (previewT == null)
{
continue;
}
var newRig = GameObject.Instantiate <GameObject>(originalRig.gameObject, previewT.parent);
newRig.name = previewT.name;
GameObject.DestroyImmediate(previewT.gameObject);
AnimationRigging.ReplaceConstraintTransformReference(gameObject, newRig.GetComponent <Rig>(), originalGameObject, originalRig);
layers.Add(newRig);
}
if (layers.Count > 0)
{
m_VARigBuilder = gameObject.AddComponent <VeryAnimationRigBuilder>();
m_RigBuilder = gameObject.GetComponent <RigBuilder>();
foreach (var layer in layers)
{
var rig = layer.GetComponent <Rig>();
#region RemoveEffector
{
var effectors = rig.effectors as List <RigEffectorData>;
effectors.Clear();
}
#endregion
#if UNITY_2020_1_OR_NEWER
var rigLayer = new RigLayer(rig); //version 0.3.2
#else
var rigLayer = new RigBuilder.RigLayer(rig); //version 0.2.5
#endif
m_RigBuilder.layers.Add(rigLayer);
}
}
}
if (m_VARigBuilder != null && m_RigBuilder != null)
{
m_VARigBuilder.enabled = m_RigBuilder.enabled = EditorPrefs.GetBool(EditorPrefsARConstraint);
if (m_RigBuilder.enabled)
{
m_VARigBuilder.StartPreview();
m_RigBuilder.StartPreview();
rootPlayable = m_VARigBuilder.BuildPreviewGraph(m_PlayableGraph, rootPlayable);
rootPlayable = m_RigBuilder.BuildPreviewGraph(m_PlayableGraph, rootPlayable);
}
}
}
#endif
if (animator.applyRootMotion)
{
bool hasRootMotionBone = false;
if (animator.isHuman)
{
hasRootMotionBone = true;
}
else
{
UAvatar uAvatar = new UAvatar();
var genericRootMotionBonePath = uAvatar.GetGenericRootMotionBonePath(animator.avatar);
hasRootMotionBone = !string.IsNullOrEmpty(genericRootMotionBonePath);
}
if (hasRootMotionBone)
{
if (m_UAnimationOffsetPlayable == null)
{
m_UAnimationOffsetPlayable = new UAnimationOffsetPlayable();
}
m_AnimationOffsetPlayable = m_UAnimationOffsetPlayable.Create(m_PlayableGraph, transformPoseSave.startLocalPosition, transformPoseSave.startLocalRotation, 1);
m_AnimationOffsetPlayable.SetInputWeight(0, 1f);
m_PlayableGraph.Connect(rootPlayable, 0, m_AnimationOffsetPlayable, 0);
rootPlayable = m_AnimationOffsetPlayable;
}
{
if (m_UAnimationMotionXToDeltaPlayable == null)
{
m_UAnimationMotionXToDeltaPlayable = new UAnimationMotionXToDeltaPlayable();
}
m_AnimationMotionXToDeltaPlayable = m_UAnimationMotionXToDeltaPlayable.Create(m_PlayableGraph);
m_UAnimationMotionXToDeltaPlayable.SetAbsoluteMotion(m_AnimationMotionXToDeltaPlayable, true);
m_AnimationMotionXToDeltaPlayable.SetInputWeight(0, 1f);
m_PlayableGraph.Connect(rootPlayable, 0, m_AnimationMotionXToDeltaPlayable, 0);
rootPlayable = m_AnimationMotionXToDeltaPlayable;
}
}
var playableOutput = AnimationPlayableOutput.Create(m_PlayableGraph, "Animation", animator);
playableOutput.SetSourcePlayable(rootPlayable);
#else
if (m_Controller == null)
{
m_Controller = new UnityEditor.Animations.AnimatorController();
m_Controller.name = "Avatar Preview AnimatorController";
m_Controller.hideFlags |= HideFlags.HideAndDontSave;
uAnimatorController.SetPushUndo(m_Controller, false);
m_Controller.AddLayer("preview");
m_StateMachine = m_Controller.layers[0].stateMachine;
uAnimatorStateMachine.SetPushUndo(m_StateMachine, false);
m_StateMachine.hideFlags |= HideFlags.HideAndDontSave;
}
if (m_State == null)
{
m_State = m_StateMachine.AddState("preview");
uAnimatorState.SetPushUndo(m_State, false);
m_State.motion = (Motion)clip;
m_State.iKOnFeet = isIKOnFeet;
m_State.hideFlags |= HideFlags.HideAndDontSave;
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, m_Controller);
#endif
}
dg_set_ShowIKOnFeetButton(animator != null && animator.isHuman && clip.isHumanMotion);
ForceUpdate();
}
