How to save and load animation curves recorded at runtime?

If you go to the definition of AnimationCurve (F12 in VS), you'll see that it is not marked [System.Serializable] and no amount of coaxing will change that.

When you change your code and go back to the editor, everything that was there is Unity.Serialized() (don't look for it; not a real thing) to native, the new managed code is loaded, and then the old values are Unity.Deserialized() back into the new data structure blindly. If you rename something, for example, the editor won't know to put the old data in the new place so, instead, it just throws away the old-data and creates new, new-data.

Your only recourse is to provide the methods needed to System.De/Serialize the non-serializable curves. You can do so by iterating each KeyFrame in the curve and manually exporting the data somewhere, some way. You'll also need to provide the method that converts that raw data back into an AnimationCurve that appears to be the same one as before.

ScriptableObject is not meant for persistent storage of run-time-generated data. They allow you to create design-time "assets" out of chunks of data that scripts can reference, rather than contain/copy. You are free to create new ScriptableObjects at run-time and you are able to permanently store them in the asset database. However (big but), this depends on the Editor namespace which doesn't exist in builds. If you use them just to help design the game, you're still required to provide the implementation to make them System.Serializable (they are also only Unity.Serializable). In case you consider doing so, you cannot simply add [System.Serializable] to a ScriptableObject because the base class (UnityEngine.Object) still won't be [System.Serializable].

Instead, the object that contains the curves can implement the ISerializationCallbackReceiver interface and use the corresponding methods to extract the KeyFrames into a serializable form. You can make a new SerializableKeyFrame class that contains the same names and types as the real KeyFrame class except they'll be stored as members, not as properties. The SerializableKeyFrame class will need to be marked [System.Serializable] to be eligible for serialization. As well, the for-serialization-only member within the curve-containing object (presumably a List<SerializableKeyFrame> will need to be public or marked [SerializeField]. You can leave it public and hide it with [HideInInspector]. You are free to use a struct instead of a class but are subject to the normal drawbacks (no default values for members) which may not really affect you.

Overview:

You:

1. Save code; go back to editor

Then, Unity:

2. Unity-serializes everything to native
   • (The callback) Deconstruct the AnimationCurve into the for-serialization-only member (composed only of System.Serializable types)
3. Load the new Managed assemblies
4. Unity-deserialize from native into new Managed
   • (The callback) Reconstruct the AnimationCurve's data using the data in the for-serialization-only member

You cant save complex types in PlayerPrefs. You can only save floats,ints and strings. I suggest you search online for a way to serialize the AnimationCurve object. Maybe you can use a binnary formatter like here. In one of my projects i used ProtoBuff to serialize my own classes and it works great on both android and iOS. Here is a nifty tutorial

You can do this by storing the AnimationCurve variable in a ScriptableObject. Unlike MonoBehaviours that are attached to GameObjects, ScriptableObjects are created as scene independent assets, so they're not reset when exiting playmode.

Creating Animation Data Scriptable Object

 using UnityEngine; [CreateAssetMenu(fileName = "new AnimationData",menuName = "Data/AnimationData")] public class AnimationData : ScriptableObject { public AnimationCurve animationCurve; public void AddKey(Keyframe keyframe) { animationCurve.AddKey(keyframe); } public float GetKeyAt(float time) { return animationCurve.Evaluate(time); } } 

Recording Animation

using UnityEngine; public class RecordAnimation : MonoBehaviour { [SerializeField] private Transform target; [SerializeField] private bool isRecording; [SerializeField] private AnimationData[] animationData; private void Update() { if (isRecording) { RecordPosition(); } else { LoadPosition(); } } private void RecordPosition() { var position = target.position; animationData[0].AddKey(new Keyframe(Time.time, position.x)); animationData[1].AddKey(new Keyframe(Time.time, position.y)); animationData[2].AddKey(new Keyframe(Time.time, position.z)); } private void LoadPosition() { target.position = new Vector3( animationData[0].GetKeyAt(Time.time), animationData[1].GetKeyAt(Time.time), animationData[2].GetKeyAt(Time.time) ); } } 

Source is Available on my Github

If you check "Runtime Curve Editor" on Unity Asset Store, not just that you can load/save an animation curve, but you can even edit it at runtime.

The simple way:

Enter Play Mode -> record the desired curve -> click the cogwheel on your script -> "copy component". Exit Play Mode -> "paste component values".

1. Save the preset (click settings on the AC->New).

2. Create the AnimationCurve variable in a separate script, for example GameManager. AC presets are stored across all gamobjects in your project, so once you've created the variable, simply select the saved preset therein.

3. Assign the AC keys on the relevant gameobject:

   gameObject.animationcurve.keys = GameManager.instance.acvariable.keys;