How can I play an animation only using C#, without animation controller, or create an animation controller at runtime entirely from script?

Question

I've been looking around for a while trying to figure out how to play simple animations with Unity via ONLY C# script, with no drag-and-drop involved. So far I've found various tutorials explaining how to manually set up a animation controller for each object, then manually select each animation state and manually create a transition then manually set the transition length to the most minimum possible etc...

I was wondering if there's a simple way to just do something like...

gameObject.playAnimation(
    "stand still /* which would be the name of the action state created in blender or other animation software*/", 
    "loop");

...WITHOUT creating an animation controller manually at all, I haven't been able to find any resource to do this simple thing yet.

Answer 1

Have a look at different approach on Animation using "SimpleAnimation" via new Unity's Playable system.

Introducing the Simple Animation Component (Unity Blog)

Under the hood it hacks the way using animator to play animation while controlling clip and state name from Playables, using new API set UnityEngine.Playables.AnimationPlayableUtilities

But now you can add states easier by script since you are dealing with playables not RuntimeAnimatorController and their messy state system. This is how it looks like when you use it on your end:

// Assumes following variables
SimpleAnimation m_CustomAnimationPlayable; // Via inspector or added on runtime
AnimationClip clip, clip2; // Via inspector or other mean

// Example on creating
m_CustomAnimationPlayable.AddState( clip, "run" );
m_CustomAnimationPlayable.AddState( clip2, "attack" );

// Example on playing
m_CustomAnimationPlayable.Play( "run" );
m_CustomAnimationPlayable.PlayQueued( "run", QueueMode );
m_CustomAnimationPlayable.CrossFade( "run", 1.0f ); // crossfade length

It need quite a bit of initial setup but this official github will provide most boilerplate code for you:

Official Unity Git Hub for SimpleAnimation

Here is outline of setting up

• You still need pre-constructed Animator in Unity editor but it could be almost blank or most simple one. This allows you to set other useful field in Animator such as avatar setup.
• Add "SimpleAnimation" component to the game object that has animator installed.
• Call SimpleAnimation.AddState( clip, name ) to add your own state. You don't have to even define transition. Of course, you need your own way to provide list of AnimationClip to use, it could be drag n drop field in your component or ScriptableObject contains animation database of some kind. Or if you want totally "no-drag-drop", your solution would limit to Resources API and alike. (Refer to @Phillips answer)
• Play any state or crossfade using SimpleAnimationPlay( statename );

Key point VS legacy Animation component

• ⌾ Not require marking AnimationClip as Legacy.
• ⌾ You can use Animator (Mechanim) important features such as Avatar (bone re-targetting), and possibly (I'm not sure) root motion.
• △ Code amount to setup is around the same as using Legacy Animation.

Be discreet on Resources folder (!!)

• Resources API has been a good accessible way for loading thing on runtime.
• BUT Resource folder incurs memory and build performance. For best practice, use it with discreet. Do not dump everything there.
• Further in-depth read: Asset Bundles vs. Resources: A Memory Showdown
• Further in-depth read: Assets, Resources and AssetBundles
• What is worse than Unity's own best practice explicitly said Don't use it.?

---

There is also AnimatorOverrideController

Keep in mind that there is also another approach AnimatorOverrideController, which is also possible to do on script runtime level. But this is leaning more toward scenario such as having several actors with exactly same state machine but with different AnimationClip override for each state.

Answer 2

Without using the Animation Controller, you can use Animation Type to Legacy.

Then All you need to attach the script to animation object.

 public Animation animates;

    void Start()
    {
       animates = GetComponenet<Animation>();
    }

    public void Plays()
    {
        animates["ClipName"].normalizedTime = 0.0f;
        animates["ClipName"].speed = 1.0f;
        animates.Play();   
    }

Answer 3

I would recommend using an animation controller if you will ever need to blend animations or do any kind of complicated state. If you don't want transitions, you don't have to add them, just call Animator.Play("state_name").

But, if you just want a simple way to play single animation clips, you might be interested in this blog. Unity created that exact component, and you can grab it from GitHub.

Answer 4

Although it is considered obsolete in favor of the much more powerful AnimationController, the good old Animation component still exists.

It provides you with a very simple way to play an animation clip: GetComponent<Animation>().Play(clipName, mode);

However, before you can play an animation clip by name, you first have to add the animation clip asset to the animator via inspector or using GetComponent<Animation>().AddClip(animationClipAsset, clipName);.

That means you will still need a way to get a reference to the animation clip asset. The easiest way would be to assign it to some inspector variable. But you specifically said "no drag and drop involved", so you might want to get them through Resources (also no longer recommended) or through the new Addressable Asset System.

Answer 5

To play animation during runtime you need to following things:

1. Animator component (on runtime)
2. Avatar of Character
3. Animator Controller

public class SM : MonoBehaviour
{
    [MenuItem("MyMenu/Create Controller")]
    static void CreateController()
    {
        // Creates the controller
        var controller = UnityEditor.Animations.AnimatorController.CreateAnimatorControllerAtPath("Assets/Mecanim/StateMachineTransitions.controller");

        // Add parameters
        controller.AddParameter("TransitionNow", AnimatorControllerParameterType.Trigger);
        controller.AddParameter("Reset", AnimatorControllerParameterType.Trigger);
        controller.AddParameter("GotoB1", AnimatorControllerParameterType.Trigger);
        controller.AddParameter("GotoC", AnimatorControllerParameterType.Trigger);

        // Add StateMachines
        var rootStateMachine = controller.layers[0].stateMachine;
        var stateMachineA = rootStateMachine.AddStateMachine("smA");
        var stateMachineB = rootStateMachine.AddStateMachine("smB");
        var stateMachineC = stateMachineB.AddStateMachine("smC");

        // Add States
        var stateA1 = stateMachineA.AddState("stateA1");
        var stateB1 = stateMachineB.AddState("stateB1");
        var stateB2 = stateMachineB.AddState("stateB2");
        stateMachineC.AddState("stateC1");
        var stateC2 = stateMachineC.AddState("stateC2"); // don’t add an entry transition, should entry to state by default

        // Add Transitions
        var exitTransition = stateA1.AddExitTransition();
        exitTransition.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "TransitionNow");
        exitTransition.duration = 0;

        var resetTransition = rootStateMachine.AddAnyStateTransition(stateA1);
        resetTransition.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "Reset");
        resetTransition.duration = 0;

        var transitionB1 = stateMachineB.AddEntryTransition(stateB1);
        transitionB1.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "GotoB1");
        stateMachineB.AddEntryTransition(stateB2);
        stateMachineC.defaultState = stateC2;
        var exitTransitionC2 = stateC2.AddExitTransition();
        exitTransitionC2.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "TransitionNow");
        exitTransitionC2.duration = 0;

        var stateMachineTransition = rootStateMachine.AddStateMachineTransition(stateMachineA, stateMachineC);
        stateMachineTransition.AddCondition(UnityEditor.Animations.AnimatorConditionMode.If, 0, "GotoC");
        rootStateMachine.AddStateMachineTransition(stateMachineA, stateMachineB);
    }
}
```