Remove animation 3D transform track, replace by loc/rot/scale tracks.

* `Animation.TYPE_TRANSFORM3D` track is gone.
* Added POSITION_3D, ROTATION_3D, SCALE_3D tracks.
* GLTF2, Collada, FBX importers will only import the track types found.
* Skeleton3D bone poses are now Pos/Rot/Scale, pose matrix removed.
* AnimationPlayer and AnimationTree animate these tracks separately, only when found.
* Removed BakeReset code, is useless with these changes.

This is the first in a series of commits designed to make the animation system in Godot more useful, which includes:

* Better compatibility with Autodesk products
* Better reusability of animations across models (including retargeting).
* Proper animation compression.
* etc.

*Note* GLTF2 animation saving went broken with this PR, needs to be fixed in a subsequent one.

2 files changed, 673 insertions, 378 deletions

diff --git a/scene/resources/animation.cpp b/scene/resources/animation.cpp
index b4eec2530b..6612c5ff3c 100644
--- a/scene/resources/animation.cpp
+++ b/scene/resources/animation.cpp
@@ -43,8 +43,12 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 		if (tracks.size() == track && what == "type") {
 			String type = p_value;
 
-			if (type == "transform" || type == "transform3d") {
-				add_track(TYPE_TRANSFORM3D);
+			if (type == "position_3d") {
+				add_track(TYPE_POSITION_3D);
+			} else if (type == "rotation_3d") {
+				add_track(TYPE_ROTATION_3D);
+			} else if (type == "scale_3d") {
+				add_track(TYPE_SCALE_3D);
 			} else if (type == "value") {
 				add_track(TYPE_VALUE);
 			} else if (type == "method") {
@@ -75,35 +79,72 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 		} else if (what == "enabled") {
 			track_set_enabled(track, p_value);
 		} else if (what == "keys" || what == "key_values") {
-			if (track_get_type(track) == TYPE_TRANSFORM3D) {
-				TransformTrack *tt = static_cast<TransformTrack *>(tracks[track]);
+			if (track_get_type(track) == TYPE_POSITION_3D) {
+				PositionTrack *tt = static_cast<PositionTrack *>(tracks[track]);
 				Vector<real_t> values = p_value;
 				int vcount = values.size();
-				ERR_FAIL_COND_V(vcount % TRANSFORM_TRACK_SIZE, false);
+				ERR_FAIL_COND_V(vcount % POSITION_TRACK_SIZE, false);
 
 				const real_t *r = values.ptr();
 
-				int64_t count = vcount / TRANSFORM_TRACK_SIZE;
-				tt->transforms.resize(count);
+				int64_t count = vcount / POSITION_TRACK_SIZE;
+				tt->positions.resize(count);
 
+				TKey<Vector3> *tw = tt->positions.ptrw();
 				for (int i = 0; i < count; i++) {
-					TKey<TransformKey> &tk = tt->transforms.write[i];
-					const real_t *ofs = &r[i * TRANSFORM_TRACK_SIZE];
+					TKey<Vector3> &tk = tw[i];
+					const real_t *ofs = &r[i * POSITION_TRACK_SIZE];
 					tk.time = ofs[0];
 					tk.transition = ofs[1];
 
-					tk.value.loc.x = ofs[2];
-					tk.value.loc.y = ofs[3];
-					tk.value.loc.z = ofs[4];
+					tk.value.x = ofs[2];
+					tk.value.y = ofs[3];
+					tk.value.z = ofs[4];
+				}
+			} else if (track_get_type(track) == TYPE_ROTATION_3D) {
+				RotationTrack *rt = static_cast<RotationTrack *>(tracks[track]);
+				Vector<real_t> values = p_value;
+				int vcount = values.size();
+				ERR_FAIL_COND_V(vcount % ROTATION_TRACK_SIZE, false);
+
+				const real_t *r = values.ptr();
+
+				int64_t count = vcount / ROTATION_TRACK_SIZE;
+				rt->rotations.resize(count);
+
+				TKey<Quaternion> *rw = rt->rotations.ptrw();
+				for (int i = 0; i < count; i++) {
+					TKey<Quaternion> &rk = rw[i];
+					const real_t *ofs = &r[i * ROTATION_TRACK_SIZE];
+					rk.time = ofs[0];
+					rk.transition = ofs[1];
+
+					rk.value.x = ofs[2];
+					rk.value.y = ofs[3];
+					rk.value.z = ofs[4];
+					rk.value.w = ofs[5];
+				}
+			} else if (track_get_type(track) == TYPE_SCALE_3D) {
+				ScaleTrack *st = static_cast<ScaleTrack *>(tracks[track]);
+				Vector<real_t> values = p_value;
+				int vcount = values.size();
+				ERR_FAIL_COND_V(vcount % SCALE_TRACK_SIZE, false);
 
-					tk.value.rot.x = ofs[5];
-					tk.value.rot.y = ofs[6];
-					tk.value.rot.z = ofs[7];
-					tk.value.rot.w = ofs[8];
+				const real_t *r = values.ptr();
+
+				int64_t count = vcount / SCALE_TRACK_SIZE;
+				st->scales.resize(count);
 
-					tk.value.scale.x = ofs[9];
-					tk.value.scale.y = ofs[10];
-					tk.value.scale.z = ofs[11];
+				TKey<Vector3> *sw = st->scales.ptrw();
+				for (int i = 0; i < count; i++) {
+					TKey<Vector3> &sk = sw[i];
+					const real_t *ofs = &r[i * SCALE_TRACK_SIZE];
+					sk.time = ofs[0];
+					sk.transition = ofs[1];
+
+					sk.value.x = ofs[2];
+					sk.value.y = ofs[3];
+					sk.value.z = ofs[4];
 				}
 
 			} else if (track_get_type(track) == TYPE_VALUE) {
@@ -319,8 +360,14 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 		ERR_FAIL_INDEX_V(track, tracks.size(), false);
 		if (what == "type") {
 			switch (track_get_type(track)) {
-				case TYPE_TRANSFORM3D:
-					r_ret = "transform";
+				case TYPE_POSITION_3D:
+					r_ret = "position_3d";
+					break;
+				case TYPE_ROTATION_3D:
+					r_ret = "rotation_3d";
+					break;
+				case TYPE_SCALE_3D:
+					r_ret = "scale_3d";
 					break;
 				case TYPE_VALUE:
 					r_ret = "value";
@@ -352,31 +399,64 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 		} else if (what == "enabled") {
 			r_ret = track_is_enabled(track);
 		} else if (what == "keys") {
-			if (track_get_type(track) == TYPE_TRANSFORM3D) {
+			if (track_get_type(track) == TYPE_POSITION_3D) {
 				Vector<real_t> keys;
 				int kk = track_get_key_count(track);
-				keys.resize(kk * TRANSFORM_TRACK_SIZE);
+				keys.resize(kk * POSITION_TRACK_SIZE);
 
 				real_t *w = keys.ptrw();
 
 				int idx = 0;
 				for (int i = 0; i < track_get_key_count(track); i++) {
 					Vector3 loc;
-					Quaternion rot;
-					Vector3 scale;
-					transform_track_get_key(track, i, &loc, &rot, &scale);
+					position_track_get_key(track, i, &loc);
 
 					w[idx++] = track_get_key_time(track, i);
 					w[idx++] = track_get_key_transition(track, i);
 					w[idx++] = loc.x;
 					w[idx++] = loc.y;
 					w[idx++] = loc.z;
+				}
 
+				r_ret = keys;
+				return true;
+			} else if (track_get_type(track) == TYPE_ROTATION_3D) {
+				Vector<real_t> keys;
+				int kk = track_get_key_count(track);
+				keys.resize(kk * ROTATION_TRACK_SIZE);
+
+				real_t *w = keys.ptrw();
+
+				int idx = 0;
+				for (int i = 0; i < track_get_key_count(track); i++) {
+					Quaternion rot;
+					rotation_track_get_key(track, i, &rot);
+
+					w[idx++] = track_get_key_time(track, i);
+					w[idx++] = track_get_key_transition(track, i);
 					w[idx++] = rot.x;
 					w[idx++] = rot.y;
 					w[idx++] = rot.z;
 					w[idx++] = rot.w;
+				}
 
+				r_ret = keys;
+				return true;
+
+			} else if (track_get_type(track) == TYPE_SCALE_3D) {
+				Vector<real_t> keys;
+				int kk = track_get_key_count(track);
+				keys.resize(kk * SCALE_TRACK_SIZE);
+
+				real_t *w = keys.ptrw();
+
+				int idx = 0;
+				for (int i = 0; i < track_get_key_count(track); i++) {
+					Vector3 scale;
+					scale_track_get_key(track, i, &scale);
+
+					w[idx++] = track_get_key_time(track, i);
+					w[idx++] = track_get_key_transition(track, i);
 					w[idx++] = scale.x;
 					w[idx++] = scale.y;
 					w[idx++] = scale.z;
@@ -384,7 +464,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 				r_ret = keys;
 				return true;
-
 			} else if (track_get_type(track) == TYPE_VALUE) {
 				const ValueTrack *vt = static_cast<const ValueTrack *>(tracks[track]);
 
@@ -591,10 +670,18 @@ int Animation::add_track(TrackType p_type, int p_at_pos) {
 	}
 
 	switch (p_type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = memnew(TransformTrack);
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = memnew(PositionTrack);
 			tracks.insert(p_at_pos, tt);
 		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = memnew(RotationTrack);
+			tracks.insert(p_at_pos, rt);
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = memnew(ScaleTrack);
+			tracks.insert(p_at_pos, st);
+		} break;
 		case TYPE_VALUE: {
 			tracks.insert(p_at_pos, memnew(ValueTrack));
 
@@ -629,9 +716,19 @@ void Animation::remove_track(int p_track) {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			_clear(tt->transforms);
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			_clear(tt->positions);
+
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			_clear(rt->rotations);
+
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			_clear(st->scales);
 
 		} break;
 		case TYPE_VALUE: {
@@ -672,7 +769,7 @@ int Animation::get_track_count() const {
 }
 
 Animation::TrackType Animation::track_get_type(int p_track) const {
-	ERR_FAIL_INDEX_V(p_track, tracks.size(), TYPE_TRANSFORM3D);
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), TYPE_VALUE);
 	return tracks[p_track]->type;
 }
 
@@ -720,31 +817,6 @@ bool Animation::track_get_interpolation_loop_wrap(int p_track) const {
 	return tracks[p_track]->loop_wrap;
 }
 
-// transform
-/*
-template<class T>
-int Animation::_insert_pos(double p_time, T& p_keys) {
-	// simple, linear time inset that should be fast enough in reality.
-
-	int idx=p_keys.size();
-
-	while(true) {
-
-
-		if (idx==0 || p_keys[idx-1].time < p_time) {
-			//condition for insertion.
-			p_keys.insert(idx,T());
-			return idx;
-		} else if (p_keys[idx-1].time == p_time) {
-			// condition for replacing.
-			return idx-1;
-		}
-
-		idx--;
-	}
-}
-
-*/
 template <class T, class V>
 int Animation::_insert(double p_time, T &p_keys, const V &p_value) {
 	int idx = p_keys.size();
@@ -774,45 +846,153 @@ void Animation::_clear(T &p_keys) {
 	p_keys.clear();
 }
 
-Error Animation::transform_track_get_key(int p_track, int p_key, Vector3 *r_loc, Quaternion *r_rot, Vector3 *r_scale) const {
+////
+
+int Animation::position_track_insert_key(int p_track, double p_time, const Vector3 &p_position) {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_POSITION_3D, -1);
+
+	PositionTrack *tt = static_cast<PositionTrack *>(t);
+
+	TKey<Vector3> tkey;
+	tkey.time = p_time;
+	tkey.value = p_position;
+
+	int ret = _insert(p_time, tt->positions, tkey);
+	emit_changed();
+	return ret;
+}
+
+Error Animation::position_track_get_key(int p_track, int p_key, Vector3 *r_position) const {
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
 	Track *t = tracks[p_track];
 
-	TransformTrack *tt = static_cast<TransformTrack *>(t);
-	ERR_FAIL_COND_V(t->type != TYPE_TRANSFORM3D, ERR_INVALID_PARAMETER);
-	ERR_FAIL_INDEX_V(p_key, tt->transforms.size(), ERR_INVALID_PARAMETER);
+	PositionTrack *tt = static_cast<PositionTrack *>(t);
+	ERR_FAIL_COND_V(t->type != TYPE_POSITION_3D, ERR_INVALID_PARAMETER);
+	ERR_FAIL_INDEX_V(p_key, tt->positions.size(), ERR_INVALID_PARAMETER);
 
-	if (r_loc) {
-		*r_loc = tt->transforms[p_key].value.loc;
-	}
-	if (r_rot) {
-		*r_rot = tt->transforms[p_key].value.rot;
-	}
-	if (r_scale) {
-		*r_scale = tt->transforms[p_key].value.scale;
+	*r_position = tt->positions[p_key].value;
+
+	return OK;
+}
+
+Error Animation::position_track_interpolate(int p_track, double p_time, Vector3 *r_interpolation) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_POSITION_3D, ERR_INVALID_PARAMETER);
+
+	PositionTrack *tt = static_cast<PositionTrack *>(t);
+
+	bool ok = false;
+
+	Vector3 tk = _interpolate(tt->positions, p_time, tt->interpolation, tt->loop_wrap, &ok);
+
+	if (!ok) {
+		return ERR_UNAVAILABLE;
 	}
+	*r_interpolation = tk;
+	return OK;
+}
+
+////
+
+int Animation::rotation_track_insert_key(int p_track, double p_time, const Quaternion &p_rotation) {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_ROTATION_3D, -1);
+
+	RotationTrack *rt = static_cast<RotationTrack *>(t);
+
+	TKey<Quaternion> tkey;
+	tkey.time = p_time;
+	tkey.value = p_rotation;
+
+	int ret = _insert(p_time, rt->rotations, tkey);
+	emit_changed();
+	return ret;
+}
+
+Error Animation::rotation_track_get_key(int p_track, int p_key, Quaternion *r_rotation) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
+	Track *t = tracks[p_track];
+
+	RotationTrack *rt = static_cast<RotationTrack *>(t);
+	ERR_FAIL_COND_V(t->type != TYPE_ROTATION_3D, ERR_INVALID_PARAMETER);
+	ERR_FAIL_INDEX_V(p_key, rt->rotations.size(), ERR_INVALID_PARAMETER);
+
+	*r_rotation = rt->rotations[p_key].value;
 
 	return OK;
 }
 
-int Animation::transform_track_insert_key(int p_track, double p_time, const Vector3 &p_loc, const Quaternion &p_rot, const Vector3 &p_scale) {
+Error Animation::rotation_track_interpolate(int p_track, double p_time, Quaternion *r_interpolation) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_ROTATION_3D, ERR_INVALID_PARAMETER);
+
+	RotationTrack *rt = static_cast<RotationTrack *>(t);
+
+	bool ok = false;
+
+	Quaternion tk = _interpolate(rt->rotations, p_time, rt->interpolation, rt->loop_wrap, &ok);
+
+	if (!ok) {
+		return ERR_UNAVAILABLE;
+	}
+	*r_interpolation = tk;
+	return OK;
+}
+
+////
+
+int Animation::scale_track_insert_key(int p_track, double p_time, const Vector3 &p_scale) {
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
-	ERR_FAIL_COND_V(t->type != TYPE_TRANSFORM3D, -1);
+	ERR_FAIL_COND_V(t->type != TYPE_SCALE_3D, -1);
 
-	TransformTrack *tt = static_cast<TransformTrack *>(t);
+	ScaleTrack *st = static_cast<ScaleTrack *>(t);
 
-	TKey<TransformKey> tkey;
+	TKey<Vector3> tkey;
 	tkey.time = p_time;
-	tkey.value.loc = p_loc;
-	tkey.value.rot = p_rot;
-	tkey.value.scale = p_scale;
+	tkey.value = p_scale;
 
-	int ret = _insert(p_time, tt->transforms, tkey);
+	int ret = _insert(p_time, st->scales, tkey);
 	emit_changed();
 	return ret;
 }
 
+Error Animation::scale_track_get_key(int p_track, int p_key, Vector3 *r_scale) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
+	Track *t = tracks[p_track];
+
+	ScaleTrack *st = static_cast<ScaleTrack *>(t);
+	ERR_FAIL_COND_V(t->type != TYPE_SCALE_3D, ERR_INVALID_PARAMETER);
+	ERR_FAIL_INDEX_V(p_key, st->scales.size(), ERR_INVALID_PARAMETER);
+
+	*r_scale = st->scales[p_key].value;
+
+	return OK;
+}
+
+Error Animation::scale_track_interpolate(int p_track, double p_time, Vector3 *r_interpolation) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_SCALE_3D, ERR_INVALID_PARAMETER);
+
+	ScaleTrack *st = static_cast<ScaleTrack *>(t);
+
+	bool ok = false;
+
+	Vector3 tk = _interpolate(st->scales, p_time, st->interpolation, st->loop_wrap, &ok);
+
+	if (!ok) {
+		return ERR_UNAVAILABLE;
+	}
+	*r_interpolation = tk;
+	return OK;
+}
+
 void Animation::track_remove_key_at_time(int p_track, double p_time) {
 	int idx = track_find_key(p_track, p_time, true);
 	ERR_FAIL_COND(idx < 0);
@@ -824,10 +1004,22 @@ void Animation::track_remove_key(int p_track, int p_idx) {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			ERR_FAIL_INDEX(p_idx, tt->transforms.size());
-			tt->transforms.remove(p_idx);
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			ERR_FAIL_INDEX(p_idx, tt->positions.size());
+			tt->positions.remove(p_idx);
+
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			ERR_FAIL_INDEX(p_idx, rt->rotations.size());
+			rt->rotations.remove(p_idx);
+
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			ERR_FAIL_INDEX(p_idx, st->scales.size());
+			st->scales.remove(p_idx);
 
 		} break;
 		case TYPE_VALUE: {
@@ -870,13 +1062,37 @@ int Animation::track_find_key(int p_track, double p_time, bool p_exact) const {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			int k = _find(tt->transforms, p_time);
-			if (k < 0 || k >= tt->transforms.size()) {
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			int k = _find(tt->positions, p_time);
+			if (k < 0 || k >= tt->positions.size()) {
 				return -1;
 			}
-			if (tt->transforms[k].time != p_time && p_exact) {
+			if (tt->positions[k].time != p_time && p_exact) {
+				return -1;
+			}
+			return k;
+
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			int k = _find(rt->rotations, p_time);
+			if (k < 0 || k >= rt->rotations.size()) {
+				return -1;
+			}
+			if (rt->rotations[k].time != p_time && p_exact) {
+				return -1;
+			}
+			return k;
+
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *rt = static_cast<ScaleTrack *>(t);
+			int k = _find(rt->scales, p_time);
+			if (k < 0 || k >= rt->scales.size()) {
+				return -1;
+			}
+			if (rt->scales[k].time != p_time && p_exact) {
 				return -1;
 			}
 			return k;
@@ -952,24 +1168,21 @@ void Animation::track_insert_key(int p_track, double p_time, const Variant &p_ke
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			Dictionary d = p_key;
-			Vector3 loc;
-			if (d.has("location")) {
-				loc = d["location"];
-			}
-
-			Quaternion rot;
-			if (d.has("rotation")) {
-				rot = d["rotation"];
-			}
+		case TYPE_POSITION_3D: {
+			ERR_FAIL_COND((p_key.get_type() != Variant::VECTOR3) && (p_key.get_type() != Variant::VECTOR3I));
+			int idx = position_track_insert_key(p_track, p_time, p_key);
+			track_set_key_transition(p_track, idx, p_transition);
 
-			Vector3 scale;
-			if (d.has("scale")) {
-				scale = d["scale"];
-			}
+		} break;
+		case TYPE_ROTATION_3D: {
+			ERR_FAIL_COND((p_key.get_type() != Variant::QUATERNION) && (p_key.get_type() != Variant::BASIS));
+			int idx = rotation_track_insert_key(p_track, p_time, p_key);
+			track_set_key_transition(p_track, idx, p_transition);
 
-			int idx = transform_track_insert_key(p_track, p_time, loc, rot, scale);
+		} break;
+		case TYPE_SCALE_3D: {
+			ERR_FAIL_COND((p_key.get_type() != Variant::VECTOR3) && (p_key.get_type() != Variant::VECTOR3I));
+			int idx = scale_track_insert_key(p_track, p_time, p_key);
 			track_set_key_transition(p_track, idx, p_transition);
 
 		} break;
@@ -1054,9 +1267,17 @@ int Animation::track_get_key_count(int p_track) const {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			return tt->transforms.size();
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			return tt->positions.size();
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			return rt->rotations.size();
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			return st->scales.size();
 		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
@@ -1089,16 +1310,23 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), Variant());
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, tt->positions.size(), Variant());
 
-			Dictionary d;
-			d["location"] = tt->transforms[p_key_idx].value.loc;
-			d["rotation"] = tt->transforms[p_key_idx].value.rot;
-			d["scale"] = tt->transforms[p_key_idx].value.scale;
+			return tt->positions[p_key_idx].value;
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, rt->rotations.size(), Variant());
 
-			return d;
+			return rt->rotations[p_key_idx].value;
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, st->scales.size(), Variant());
+
+			return st->scales[p_key_idx].value;
 		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
@@ -1157,10 +1385,20 @@ double Animation::track_get_key_time(int p_track, int p_key_idx) const {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1);
-			return tt->transforms[p_key_idx].time;
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, tt->positions.size(), -1);
+			return tt->positions[p_key_idx].time;
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, rt->rotations.size(), -1);
+			return rt->rotations[p_key_idx].time;
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, st->scales.size(), -1);
+			return st->scales[p_key_idx].time;
 		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
@@ -1202,13 +1440,31 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, double p_time) {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
-			TKey<TransformKey> key = tt->transforms[p_key_idx];
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, tt->positions.size());
+			TKey<Vector3> key = tt->positions[p_key_idx];
 			key.time = p_time;
-			tt->transforms.remove(p_key_idx);
-			_insert(p_time, tt->transforms, key);
+			tt->positions.remove(p_key_idx);
+			_insert(p_time, tt->positions, key);
+			return;
+		}
+		case TYPE_ROTATION_3D: {
+			RotationTrack *tt = static_cast<RotationTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, tt->rotations.size());
+			TKey<Quaternion> key = tt->rotations[p_key_idx];
+			key.time = p_time;
+			tt->rotations.remove(p_key_idx);
+			_insert(p_time, tt->rotations, key);
+			return;
+		}
+		case TYPE_SCALE_3D: {
+			ScaleTrack *tt = static_cast<ScaleTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, tt->scales.size());
+			TKey<Vector3> key = tt->scales[p_key_idx];
+			key.time = p_time;
+			tt->scales.remove(p_key_idx);
+			_insert(p_time, tt->scales, key);
 			return;
 		}
 		case TYPE_VALUE: {
@@ -1266,10 +1522,20 @@ real_t Animation::track_get_key_transition(int p_track, int p_key_idx) const {
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1);
-			return tt->transforms[p_key_idx].transition;
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, tt->positions.size(), -1);
+			return tt->positions[p_key_idx].transition;
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, rt->rotations.size(), -1);
+			return rt->rotations[p_key_idx].transition;
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, st->scales.size(), -1);
+			return st->scales[p_key_idx].transition;
 		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
@@ -1302,21 +1568,28 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
+		case TYPE_POSITION_3D: {
+			ERR_FAIL_COND((p_value.get_type() != Variant::VECTOR3) && (p_value.get_type() != Variant::VECTOR3I));
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, tt->positions.size());
 
-			Dictionary d = p_value;
+			tt->positions.write[p_key_idx].value = p_value;
 
-			if (d.has("location")) {
-				tt->transforms.write[p_key_idx].value.loc = d["location"];
-			}
-			if (d.has("rotation")) {
-				tt->transforms.write[p_key_idx].value.rot = d["rotation"];
-			}
-			if (d.has("scale")) {
-				tt->transforms.write[p_key_idx].value.scale = d["scale"];
-			}
+		} break;
+		case TYPE_ROTATION_3D: {
+			ERR_FAIL_COND((p_value.get_type() != Variant::QUATERNION) && (p_value.get_type() != Variant::BASIS));
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, rt->rotations.size());
+
+			rt->rotations.write[p_key_idx].value = p_value;
+
+		} break;
+		case TYPE_SCALE_3D: {
+			ERR_FAIL_COND((p_value.get_type() != Variant::VECTOR3) && (p_value.get_type() != Variant::VECTOR3I));
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, st->scales.size());
+
+			st->scales.write[p_key_idx].value = p_value;
 
 		} break;
 		case TYPE_VALUE: {
@@ -1385,10 +1658,20 @@ void Animation::track_set_key_transition(int p_track, int p_key_idx, real_t p_tr
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			TransformTrack *tt = static_cast<TransformTrack *>(t);
-			ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
-			tt->transforms.write[p_key_idx].transition = p_transition;
+		case TYPE_POSITION_3D: {
+			PositionTrack *tt = static_cast<PositionTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, tt->positions.size());
+			tt->positions.write[p_key_idx].transition = p_transition;
+		} break;
+		case TYPE_ROTATION_3D: {
+			RotationTrack *rt = static_cast<RotationTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, rt->rotations.size());
+			rt->rotations.write[p_key_idx].transition = p_transition;
+		} break;
+		case TYPE_SCALE_3D: {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, st->scales.size());
+			st->scales.write[p_key_idx].transition = p_transition;
 		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
@@ -1450,15 +1733,6 @@ int Animation::_find(const Vector<K> &p_keys, double p_time) const {
 	return middle;
 }
 
-Animation::TransformKey Animation::_interpolate(const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, real_t p_c) const {
-	TransformKey ret;
-	ret.loc = _interpolate(p_a.loc, p_b.loc, p_c);
-	ret.rot = _interpolate(p_a.rot, p_b.rot, p_c);
-	ret.scale = _interpolate(p_a.scale, p_b.scale, p_c);
-
-	return ret;
-}
-
 Vector3 Animation::_interpolate(const Vector3 &p_a, const Vector3 &p_b, real_t p_c) const {
 	return p_a.lerp(p_b, p_c);
 }
@@ -1477,16 +1751,6 @@ real_t Animation::_interpolate(const real_t &p_a, const real_t &p_b, real_t p_c)
 	return p_a * (1.0 - p_c) + p_b * p_c;
 }
 
-Animation::TransformKey Animation::_cubic_interpolate(const Animation::TransformKey &p_pre_a, const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, const Animation::TransformKey &p_post_b, real_t p_c) const {
-	Animation::TransformKey tk;
-
-	tk.loc = p_a.loc.cubic_interpolate(p_b.loc, p_pre_a.loc, p_post_b.loc, p_c);
-	tk.scale = p_a.scale.cubic_interpolate(p_b.scale, p_pre_a.scale, p_post_b.scale, p_c);
-	tk.rot = p_a.rot.cubic_slerp(p_b.rot, p_pre_a.rot, p_post_b.rot, p_c);
-
-	return tk;
-}
-
 Vector3 Animation::_cubic_interpolate(const Vector3 &p_pre_a, const Vector3 &p_a, const Vector3 &p_b, const Vector3 &p_post_b, real_t p_c) const {
 	return p_a.cubic_interpolate(p_b, p_pre_a, p_post_b, p_c);
 }
@@ -1729,36 +1993,6 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, double p_time, Interpol
 	// do a barrel roll
 }
 
-Error Animation::transform_track_interpolate(int p_track, double p_time, Vector3 *r_loc, Quaternion *r_rot, Vector3 *r_scale) const {
-	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
-	Track *t = tracks[p_track];
-	ERR_FAIL_COND_V(t->type != TYPE_TRANSFORM3D, ERR_INVALID_PARAMETER);
-
-	TransformTrack *tt = static_cast<TransformTrack *>(t);
-
-	bool ok = false;
-
-	TransformKey tk = _interpolate(tt->transforms, p_time, tt->interpolation, tt->loop_wrap, &ok);
-
-	if (!ok) {
-		return ERR_UNAVAILABLE;
-	}
-
-	if (r_loc) {
-		*r_loc = tk.loc;
-	}
-
-	if (r_rot) {
-		*r_rot = tk.rot;
-	}
-
-	if (r_scale) {
-		*r_scale = tk.scale;
-	}
-
-	return OK;
-}
-
 Variant Animation::value_track_interpolate(int p_track, double p_time) const {
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
 	Track *t = tracks[p_track];
@@ -1933,10 +2167,22 @@ void Animation::track_get_key_indices_in_range(int p_track, double p_time, doubl
 			// handle loop by splitting
 
 			switch (t->type) {
-				case TYPE_TRANSFORM3D: {
-					const TransformTrack *tt = static_cast<const TransformTrack *>(t);
-					_track_get_key_indices_in_range(tt->transforms, from_time, length, p_indices);
-					_track_get_key_indices_in_range(tt->transforms, 0, to_time, p_indices);
+				case TYPE_POSITION_3D: {
+					const PositionTrack *tt = static_cast<const PositionTrack *>(t);
+					_track_get_key_indices_in_range(tt->positions, from_time, length, p_indices);
+					_track_get_key_indices_in_range(tt->positions, 0, to_time, p_indices);
+
+				} break;
+				case TYPE_ROTATION_3D: {
+					const RotationTrack *rt = static_cast<const RotationTrack *>(t);
+					_track_get_key_indices_in_range(rt->rotations, from_time, length, p_indices);
+					_track_get_key_indices_in_range(rt->rotations, 0, to_time, p_indices);
+
+				} break;
+				case TYPE_SCALE_3D: {
+					const ScaleTrack *st = static_cast<const ScaleTrack *>(t);
+					_track_get_key_indices_in_range(st->scales, from_time, length, p_indices);
+					_track_get_key_indices_in_range(st->scales, 0, to_time, p_indices);
 
 				} break;
 				case TYPE_VALUE: {
@@ -1989,9 +2235,19 @@ void Animation::track_get_key_indices_in_range(int p_track, double p_time, doubl
 	}
 
 	switch (t->type) {
-		case TYPE_TRANSFORM3D: {
-			const TransformTrack *tt = static_cast<const TransformTrack *>(t);
-			_track_get_key_indices_in_range(tt->transforms, from_time, to_time, p_indices);
+		case TYPE_POSITION_3D: {
+			const PositionTrack *tt = static_cast<const PositionTrack *>(t);
+			_track_get_key_indices_in_range(tt->positions, from_time, to_time, p_indices);
+
+		} break;
+		case TYPE_ROTATION_3D: {
+			const RotationTrack *rt = static_cast<const RotationTrack *>(t);
+			_track_get_key_indices_in_range(rt->rotations, from_time, to_time, p_indices);
+
+		} break;
+		case TYPE_SCALE_3D: {
+			const ScaleTrack *st = static_cast<const ScaleTrack *>(t);
+			_track_get_key_indices_in_range(st->scales, from_time, to_time, p_indices);
 
 		} break;
 		case TYPE_VALUE: {
@@ -2608,7 +2864,10 @@ void Animation::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("track_set_enabled", "track_idx", "enabled"), &Animation::track_set_enabled);
 	ClassDB::bind_method(D_METHOD("track_is_enabled", "track_idx"), &Animation::track_is_enabled);
 
-	ClassDB::bind_method(D_METHOD("transform_track_insert_key", "track_idx", "time", "location", "rotation", "scale"), &Animation::transform_track_insert_key);
+	ClassDB::bind_method(D_METHOD("position_track_insert_key", "track_idx", "time", "position"), &Animation::position_track_insert_key);
+	ClassDB::bind_method(D_METHOD("rotation_track_insert_key", "track_idx", "time", "rotation"), &Animation::rotation_track_insert_key);
+	ClassDB::bind_method(D_METHOD("scale_track_insert_key", "track_idx", "time", "scale"), &Animation::scale_track_insert_key);
+
 	ClassDB::bind_method(D_METHOD("track_insert_key", "track_idx", "time", "key", "transition"), &Animation::track_insert_key, DEFVAL(1));
 	ClassDB::bind_method(D_METHOD("track_remove_key", "track_idx", "key_idx"), &Animation::track_remove_key);
 	ClassDB::bind_method(D_METHOD("track_remove_key_at_time", "track_idx", "time"), &Animation::track_remove_key_at_time);
@@ -2628,7 +2887,6 @@ void Animation::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("track_set_interpolation_loop_wrap", "track_idx", "interpolation"), &Animation::track_set_interpolation_loop_wrap);
 	ClassDB::bind_method(D_METHOD("track_get_interpolation_loop_wrap", "track_idx"), &Animation::track_get_interpolation_loop_wrap);
 
-	ClassDB::bind_method(D_METHOD("transform_track_interpolate", "track_idx", "time_sec"), &Animation::_transform_track_interpolate);
 	ClassDB::bind_method(D_METHOD("value_track_set_update_mode", "track_idx", "mode"), &Animation::value_track_set_update_mode);
 	ClassDB::bind_method(D_METHOD("value_track_get_update_mode", "track_idx"), &Animation::value_track_get_update_mode);
 
@@ -2682,7 +2940,9 @@ void Animation::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("tracks_changed"));
 
 	BIND_ENUM_CONSTANT(TYPE_VALUE);
-	BIND_ENUM_CONSTANT(TYPE_TRANSFORM3D);
+	BIND_ENUM_CONSTANT(TYPE_POSITION_3D);
+	BIND_ENUM_CONSTANT(TYPE_ROTATION_3D);
+	BIND_ENUM_CONSTANT(TYPE_SCALE_3D);
 	BIND_ENUM_CONSTANT(TYPE_METHOD);
 	BIND_ENUM_CONSTANT(TYPE_BEZIER);
 	BIND_ENUM_CONSTANT(TYPE_AUDIO);
@@ -2709,193 +2969,215 @@ void Animation::clear() {
 	emit_signal(SceneStringNames::get_singleton()->tracks_changed);
 }
 
-bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, const TKey<TransformKey> &t1, const TKey<TransformKey> &t2, real_t p_alowed_linear_err, real_t p_alowed_angular_err, real_t p_max_optimizable_angle, const Vector3 &p_norm) {
-	real_t c = (t1.time - t0.time) / (t2.time - t0.time);
-	real_t t[3] = { -1, -1, -1 };
+bool Animation::_position_track_optimize_key(const TKey<Vector3> &t0, const TKey<Vector3> &t1, const TKey<Vector3> &t2, real_t p_allowed_linear_err, real_t p_allowed_angular_error, const Vector3 &p_norm) {
+	const Vector3 &v0 = t0.value;
+	const Vector3 &v1 = t1.value;
+	const Vector3 &v2 = t2.value;
 
-	{ //translation
+	if (v0.is_equal_approx(v2)) {
+		//0 and 2 are close, let's see if 1 is close
+		if (!v0.is_equal_approx(v1)) {
+			//not close, not optimizable
+			return false;
+		}
 
-		const Vector3 &v0 = t0.value.loc;
-		const Vector3 &v1 = t1.value.loc;
-		const Vector3 &v2 = t2.value.loc;
+	} else {
+		Vector3 pd = (v2 - v0);
+		real_t d0 = pd.dot(v0);
+		real_t d1 = pd.dot(v1);
+		real_t d2 = pd.dot(v2);
+		if (d1 < d0 || d1 > d2) {
+			return false;
+		}
 
-		if (v0.is_equal_approx(v2)) {
-			//0 and 2 are close, let's see if 1 is close
-			if (!v0.is_equal_approx(v1)) {
-				//not close, not optimizable
-				return false;
-			}
+		Vector3 s[2] = { v0, v2 };
+		real_t d = Geometry3D::get_closest_point_to_segment(v1, s).distance_to(v1);
 
-		} else {
-			Vector3 pd = (v2 - v0);
-			real_t d0 = pd.dot(v0);
-			real_t d1 = pd.dot(v1);
-			real_t d2 = pd.dot(v2);
-			if (d1 < d0 || d1 > d2) {
-				return false;
-			}
+		if (d > pd.length() * p_allowed_linear_err) {
+			return false; //beyond allowed error for collinearity
+		}
 
-			Vector3 s[2] = { v0, v2 };
-			real_t d = Geometry3D::get_closest_point_to_segment(v1, s).distance_to(v1);
+		if (p_norm != Vector3() && Math::acos(pd.normalized().dot(p_norm)) > p_allowed_angular_error) {
+			return false;
+		}
+	}
 
-			if (d > pd.length() * p_alowed_linear_err) {
-				return false; //beyond allowed error for collinearity
-			}
+	return true;
+}
 
-			if (p_norm != Vector3() && Math::acos(pd.normalized().dot(p_norm)) > p_alowed_angular_err) {
-				return false;
-			}
+bool Animation::_rotation_track_optimize_key(const TKey<Quaternion> &t0, const TKey<Quaternion> &t1, const TKey<Quaternion> &t2, real_t p_allowed_angular_error, float p_max_optimizable_angle) {
+	const Quaternion &q0 = t0.value;
+	const Quaternion &q1 = t1.value;
+	const Quaternion &q2 = t2.value;
+
+	//localize both to rotation from q0
 
-			t[0] = (d1 - d0) / (d2 - d0);
+	if (q0.is_equal_approx(q2)) {
+		if (!q0.is_equal_approx(q1)) {
+			return false;
 		}
-	}
 
-	{ //rotation
+	} else {
+		Quaternion r02 = (q0.inverse() * q2).normalized();
+		Quaternion r01 = (q0.inverse() * q1).normalized();
 
-		const Quaternion &q0 = t0.value.rot;
-		const Quaternion &q1 = t1.value.rot;
-		const Quaternion &q2 = t2.value.rot;
+		Vector3 v02, v01;
+		real_t a02, a01;
 
-		//localize both to rotation from q0
+		r02.get_axis_angle(v02, a02);
+		r01.get_axis_angle(v01, a01);
 
-		if (q0.is_equal_approx(q2)) {
-			if (!q0.is_equal_approx(q1)) {
-				return false;
-			}
+		if (Math::abs(a02) > p_max_optimizable_angle) {
+			return false;
+		}
 
-		} else {
-			Quaternion r02 = (q0.inverse() * q2).normalized();
-			Quaternion r01 = (q0.inverse() * q1).normalized();
+		if (v01.dot(v02) < 0) {
+			//make sure both rotations go the same way to compare
+			v02 = -v02;
+			a02 = -a02;
+		}
 
-			Vector3 v02, v01;
-			real_t a02, a01;
+		real_t err_01 = Math::acos(v01.normalized().dot(v02.normalized())) / Math_PI;
+		if (err_01 > p_allowed_angular_error) {
+			//not rotating in the same axis
+			return false;
+		}
 
-			r02.get_axis_angle(v02, a02);
-			r01.get_axis_angle(v01, a01);
+		if (a01 * a02 < 0) {
+			//not rotating in the same direction
+			return false;
+		}
 
-			if (Math::abs(a02) > p_max_optimizable_angle) {
-				return false;
-			}
+		real_t tr = a01 / a02;
+		if (tr < 0 || tr > 1) {
+			return false; //rotating too much or too less
+		}
+	}
 
-			if (v01.dot(v02) < 0) {
-				//make sure both rotations go the same way to compare
-				v02 = -v02;
-				a02 = -a02;
-			}
+	return true;
+}
 
-			real_t err_01 = Math::acos(v01.normalized().dot(v02.normalized())) / Math_PI;
-			if (err_01 > p_alowed_angular_err) {
-				//not rotating in the same axis
-				return false;
-			}
+bool Animation::_scale_track_optimize_key(const TKey<Vector3> &t0, const TKey<Vector3> &t1, const TKey<Vector3> &t2, real_t p_allowed_linear_error) {
+	const Vector3 &v0 = t0.value;
+	const Vector3 &v1 = t1.value;
+	const Vector3 &v2 = t2.value;
 
-			if (a01 * a02 < 0) {
-				//not rotating in the same direction
-				return false;
-			}
+	if (v0.is_equal_approx(v2)) {
+		//0 and 2 are close, let's see if 1 is close
+		if (!v0.is_equal_approx(v1)) {
+			//not close, not optimizable
+			return false;
+		}
 
-			real_t tr = a01 / a02;
-			if (tr < 0 || tr > 1) {
-				return false; //rotating too much or too less
-			}
+	} else {
+		Vector3 pd = (v2 - v0);
+		real_t d0 = pd.dot(v0);
+		real_t d1 = pd.dot(v1);
+		real_t d2 = pd.dot(v2);
+		if (d1 < d0 || d1 > d2) {
+			return false; //beyond segment range
+		}
 
-			t[1] = tr;
+		Vector3 s[2] = { v0, v2 };
+		real_t d = Geometry3D::get_closest_point_to_segment(v1, s).distance_to(v1);
+
+		if (d > pd.length() * p_allowed_linear_error) {
+			return false; //beyond allowed error for colinearity
 		}
 	}
 
-	{ //scale
+	return true;
+}
 
-		const Vector3 &v0 = t0.value.scale;
-		const Vector3 &v1 = t1.value.scale;
-		const Vector3 &v2 = t2.value.scale;
+void Animation::_position_track_optimize(int p_idx, real_t p_allowed_linear_err, real_t p_allowed_angular_err) {
+	ERR_FAIL_INDEX(p_idx, tracks.size());
+	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_POSITION_3D);
+	PositionTrack *tt = static_cast<PositionTrack *>(tracks[p_idx]);
+	bool prev_erased = false;
+	TKey<Vector3> first_erased;
 
-		if (v0.is_equal_approx(v2)) {
-			//0 and 2 are close, let's see if 1 is close
-			if (!v0.is_equal_approx(v1)) {
-				//not close, not optimizable
-				return false;
-			}
+	Vector3 norm;
 
-		} else {
-			Vector3 pd = (v2 - v0);
-			real_t d0 = pd.dot(v0);
-			real_t d1 = pd.dot(v1);
-			real_t d2 = pd.dot(v2);
-			if (d1 < d0 || d1 > d2) {
-				return false; //beyond segment range
-			}
+	for (int i = 1; i < tt->positions.size() - 1; i++) {
+		TKey<Vector3> &t0 = tt->positions.write[i - 1];
+		TKey<Vector3> &t1 = tt->positions.write[i];
+		TKey<Vector3> &t2 = tt->positions.write[i + 1];
 
-			Vector3 s[2] = { v0, v2 };
-			real_t d = Geometry3D::get_closest_point_to_segment(v1, s).distance_to(v1);
+		bool erase = _position_track_optimize_key(t0, t1, t2, p_allowed_linear_err, p_allowed_angular_err, norm);
+		if (erase && !prev_erased) {
+			norm = (t2.value - t1.value).normalized();
+		}
+
+		if (prev_erased && !_position_track_optimize_key(t0, first_erased, t2, p_allowed_linear_err, p_allowed_angular_err, norm)) {
+			//avoid error to go beyond first erased key
+			erase = false;
+		}
 
-			if (d > pd.length() * p_alowed_linear_err) {
-				return false; //beyond allowed error for collinearity
+		if (erase) {
+			if (!prev_erased) {
+				first_erased = t1;
+				prev_erased = true;
 			}
 
-			t[2] = (d1 - d0) / (d2 - d0);
+			tt->positions.remove(i);
+			i--;
+
+		} else {
+			prev_erased = false;
+			norm = Vector3();
 		}
 	}
+}
 
-	bool erase = false;
-	if (t[0] == -1 && t[1] == -1 && t[2] == -1) {
-		erase = true;
-	} else {
-		erase = true;
-		real_t lt = -1.0;
-		for (int j = 0; j < 3; j++) {
-			//search for t on first, one must be it
-			if (t[j] != -1) {
-				lt = t[j]; //official t
-				//validate rest
-				for (int k = j + 1; k < 3; k++) {
-					if (t[k] == -1) {
-						continue;
-					}
+void Animation::_rotation_track_optimize(int p_idx, real_t p_allowed_angular_err, real_t p_max_optimizable_angle) {
+	ERR_FAIL_INDEX(p_idx, tracks.size());
+	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_ROTATION_3D);
+	RotationTrack *tt = static_cast<RotationTrack *>(tracks[p_idx]);
+	bool prev_erased = false;
+	TKey<Quaternion> first_erased;
 
-					if (Math::abs(lt - t[k]) > p_alowed_linear_err) {
-						erase = false;
-						break;
-					}
-				}
-				break;
-			}
-		}
+	for (int i = 1; i < tt->rotations.size() - 1; i++) {
+		TKey<Quaternion> &t0 = tt->rotations.write[i - 1];
+		TKey<Quaternion> &t1 = tt->rotations.write[i];
+		TKey<Quaternion> &t2 = tt->rotations.write[i + 1];
 
-		ERR_FAIL_COND_V(lt == -1, false);
+		bool erase = _rotation_track_optimize_key(t0, t1, t2, p_allowed_angular_err, p_max_optimizable_angle);
+
+		if (prev_erased && !_rotation_track_optimize_key(t0, first_erased, t2, p_allowed_angular_err, p_max_optimizable_angle)) {
+			//avoid error to go beyond first erased key
+			erase = false;
+		}
 
 		if (erase) {
-			if (Math::abs(lt - c) > p_alowed_linear_err) {
-				//todo, evaluate changing the transition if this fails?
-				//this could be done as a second pass and would be
-				//able to optimize more
-				erase = false;
+			if (!prev_erased) {
+				first_erased = t1;
+				prev_erased = true;
 			}
+
+			tt->rotations.remove(i);
+			i--;
+
+		} else {
+			prev_erased = false;
 		}
 	}
-
-	return erase;
 }
 
-void Animation::_transform_track_optimize(int p_idx, real_t p_allowed_linear_err, real_t p_allowed_angular_err, real_t p_max_optimizable_angle) {
+void Animation::_scale_track_optimize(int p_idx, real_t p_allowed_linear_err) {
 	ERR_FAIL_INDEX(p_idx, tracks.size());
-	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_TRANSFORM3D);
-	TransformTrack *tt = static_cast<TransformTrack *>(tracks[p_idx]);
+	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_SCALE_3D);
+	ScaleTrack *tt = static_cast<ScaleTrack *>(tracks[p_idx]);
 	bool prev_erased = false;
-	TKey<TransformKey> first_erased;
+	TKey<Vector3> first_erased;
 
-	Vector3 norm;
+	for (int i = 1; i < tt->scales.size() - 1; i++) {
+		TKey<Vector3> &t0 = tt->scales.write[i - 1];
+		TKey<Vector3> &t1 = tt->scales.write[i];
+		TKey<Vector3> &t2 = tt->scales.write[i + 1];
 
-	for (int i = 1; i < tt->transforms.size() - 1; i++) {
-		TKey<TransformKey> &t0 = tt->transforms.write[i - 1];
-		TKey<TransformKey> &t1 = tt->transforms.write[i];
-		TKey<TransformKey> &t2 = tt->transforms.write[i + 1];
+		bool erase = _scale_track_optimize_key(t0, t1, t2, p_allowed_linear_err);
 
-		bool erase = _transform_track_optimize_key(t0, t1, t2, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle, norm);
-		if (erase && !prev_erased) {
-			norm = (t2.value.loc - t1.value.loc).normalized();
-		}
-
-		if (prev_erased && !_transform_track_optimize_key(t0, first_erased, t2, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle, norm)) {
+		if (prev_erased && !_scale_track_optimize_key(t0, first_erased, t2, p_allowed_linear_err)) {
 			//avoid error to go beyond first erased key
 			erase = false;
 		}
@@ -2906,20 +3188,23 @@ void Animation::_transform_track_optimize(int p_idx, real_t p_allowed_linear_err
 				prev_erased = true;
 			}
 
-			tt->transforms.remove(i);
+			tt->scales.remove(i);
 			i--;
 
 		} else {
 			prev_erased = false;
-			norm = Vector3();
 		}
 	}
 }
 
 void Animation::optimize(real_t p_allowed_linear_err, real_t p_allowed_angular_err, real_t p_max_optimizable_angle) {
 	for (int i = 0; i < tracks.size(); i++) {
-		if (tracks[i]->type == TYPE_TRANSFORM3D) {
-			_transform_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle);
+		if (tracks[i]->type == TYPE_POSITION_3D) {
+			_position_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err);
+		} else if (tracks[i]->type == TYPE_ROTATION_3D) {
+			_rotation_track_optimize(i, p_allowed_angular_err, p_max_optimizable_angle);
+		} else if (tracks[i]->type == TYPE_SCALE_3D) {
+			_scale_track_optimize(i, p_allowed_linear_err);
 		}
 	}
 }
diff --git a/scene/resources/animation.h b/scene/resources/animation.h
index 9a410bd566..614e12a560 100644
--- a/scene/resources/animation.h
+++ b/scene/resources/animation.h
@@ -42,7 +42,9 @@ class Animation : public Resource {
 public:
 	enum TrackType {
 		TYPE_VALUE, ///< Set a value in a property, can be interpolated.
-		TYPE_TRANSFORM3D, ///< Transform a node or a bone.
+		TYPE_POSITION_3D, ///< Position 3D track
+		TYPE_ROTATION_3D, ///< Rotation 3D track
+		TYPE_SCALE_3D, ///< Scale 3D track
 		TYPE_METHOD, ///< Call any method on a specific node.
 		TYPE_BEZIER, ///< Bezier curve
 		TYPE_AUDIO,
@@ -86,21 +88,31 @@ private:
 		T value;
 	};
 
-	struct TransformKey {
-		Vector3 loc;
-		Quaternion rot;
-		Vector3 scale;
+	const int32_t POSITION_TRACK_SIZE = 5;
+	const int32_t ROTATION_TRACK_SIZE = 6;
+	const int32_t SCALE_TRACK_SIZE = 5;
+
+	/* POSITION TRACK */
+
+	struct PositionTrack : public Track {
+		Vector<TKey<Vector3>> positions;
+
+		PositionTrack() { type = TYPE_POSITION_3D; }
 	};
 
-	// Not necessarily the same size as Transform3D. The amount of numbers in Animation::Key and TransformKey.
-	const int32_t TRANSFORM_TRACK_SIZE = 12;
+	/* ROTATION TRACK */
 
-	/* TRANSFORM TRACK */
+	struct RotationTrack : public Track {
+		Vector<TKey<Quaternion>> rotations;
 
-	struct TransformTrack : public Track {
-		Vector<TKey<TransformKey>> transforms;
+		RotationTrack() { type = TYPE_ROTATION_3D; }
+	};
 
-		TransformTrack() { type = TYPE_TRANSFORM3D; }
+	/* SCALE TRACK */
+
+	struct ScaleTrack : public Track {
+		Vector<TKey<Vector3>> scales;
+		ScaleTrack() { type = TYPE_SCALE_3D; }
 	};
 
 	/* PROPERTY VALUE TRACK */
@@ -186,14 +198,11 @@ private:
 	template <class K>
 	inline int _find(const Vector<K> &p_keys, double p_time) const;
 
-	_FORCE_INLINE_ Animation::TransformKey _interpolate(const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, real_t p_c) const;
-
 	_FORCE_INLINE_ Vector3 _interpolate(const Vector3 &p_a, const Vector3 &p_b, real_t p_c) const;
 	_FORCE_INLINE_ Quaternion _interpolate(const Quaternion &p_a, const Quaternion &p_b, real_t p_c) const;
 	_FORCE_INLINE_ Variant _interpolate(const Variant &p_a, const Variant &p_b, real_t p_c) const;
 	_FORCE_INLINE_ real_t _interpolate(const real_t &p_a, const real_t &p_b, real_t p_c) const;
 
-	_FORCE_INLINE_ Animation::TransformKey _cubic_interpolate(const Animation::TransformKey &p_pre_a, const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, const Animation::TransformKey &p_post_b, real_t p_c) const;
 	_FORCE_INLINE_ Vector3 _cubic_interpolate(const Vector3 &p_pre_a, const Vector3 &p_a, const Vector3 &p_b, const Vector3 &p_post_b, real_t p_c) const;
 	_FORCE_INLINE_ Quaternion _cubic_interpolate(const Quaternion &p_pre_a, const Quaternion &p_a, const Quaternion &p_b, const Quaternion &p_post_b, real_t p_c) const;
 	_FORCE_INLINE_ Variant _cubic_interpolate(const Variant &p_pre_a, const Variant &p_a, const Variant &p_b, const Variant &p_post_b, real_t p_c) const;
@@ -214,18 +223,6 @@ private:
 
 	// bind helpers
 private:
-	Array _transform_track_interpolate(int p_track, double p_time) const {
-		Vector3 loc;
-		Quaternion rot;
-		Vector3 scale;
-		transform_track_interpolate(p_track, p_time, &loc, &rot, &scale);
-		Array ret;
-		ret.push_back(loc);
-		ret.push_back(rot);
-		ret.push_back(scale);
-		return ret;
-	}
-
 	Vector<int> _value_track_get_key_indices(int p_track, double p_time, double p_delta) const {
 		List<int> idxs;
 		value_track_get_key_indices(p_track, p_time, p_delta, &idxs);
@@ -247,8 +244,13 @@ private:
 		return idxr;
 	}
 
-	bool _transform_track_optimize_key(const TKey<TransformKey> &t0, const TKey<TransformKey> &t1, const TKey<TransformKey> &t2, real_t p_alowed_linear_err, real_t p_alowed_angular_err, real_t p_max_optimizable_angle, const Vector3 &p_norm);
-	void _transform_track_optimize(int p_idx, real_t p_allowed_linear_err = 0.05, real_t p_allowed_angular_err = 0.01, real_t p_max_optimizable_angle = Math_PI * 0.125);
+	bool _position_track_optimize_key(const TKey<Vector3> &t0, const TKey<Vector3> &t1, const TKey<Vector3> &t2, real_t p_alowed_linear_err, real_t p_allowed_angular_error, const Vector3 &p_norm);
+	bool _rotation_track_optimize_key(const TKey<Quaternion> &t0, const TKey<Quaternion> &t1, const TKey<Quaternion> &t2, real_t p_allowed_angular_error, float p_max_optimizable_angle);
+	bool _scale_track_optimize_key(const TKey<Vector3> &t0, const TKey<Vector3> &t1, const TKey<Vector3> &t2, real_t p_allowed_linear_error);
+
+	void _position_track_optimize(int p_idx, real_t p_allowed_linear_err, real_t p_allowed_angular_err);
+	void _rotation_track_optimize(int p_idx, real_t p_allowed_angular_err, real_t p_max_optimizable_angle);
+	void _scale_track_optimize(int p_idx, real_t p_allowed_linear_err);
 
 protected:
 	bool _set(const StringName &p_name, const Variant &p_value);
@@ -294,8 +296,18 @@ public:
 	double track_get_key_time(int p_track, int p_key_idx) const;
 	real_t track_get_key_transition(int p_track, int p_key_idx) const;
 
-	int transform_track_insert_key(int p_track, double p_time, const Vector3 &p_loc, const Quaternion &p_rot = Quaternion(), const Vector3 &p_scale = Vector3());
-	Error transform_track_get_key(int p_track, int p_key, Vector3 *r_loc, Quaternion *r_rot, Vector3 *r_scale) const;
+	int position_track_insert_key(int p_track, double p_time, const Vector3 &p_position);
+	Error position_track_get_key(int p_track, int p_key, Vector3 *r_position) const;
+	Error position_track_interpolate(int p_track, double p_time, Vector3 *r_interpolation) const;
+
+	int rotation_track_insert_key(int p_track, double p_time, const Quaternion &p_rotation);
+	Error rotation_track_get_key(int p_track, int p_key, Quaternion *r_rotation) const;
+	Error rotation_track_interpolate(int p_track, double p_time, Quaternion *r_interpolation) const;
+
+	int scale_track_insert_key(int p_track, double p_time, const Vector3 &p_scale);
+	Error scale_track_get_key(int p_track, int p_key, Vector3 *r_scale) const;
+	Error scale_track_interpolate(int p_track, double p_time, Vector3 *r_interpolation) const;
+
 	void track_set_interpolation_type(int p_track, InterpolationType p_interp);
 	InterpolationType track_get_interpolation_type(int p_track) const;
 
@@ -324,8 +336,6 @@ public:
 	void track_set_interpolation_loop_wrap(int p_track, bool p_enable);
 	bool track_get_interpolation_loop_wrap(int p_track) const;
 
-	Error transform_track_interpolate(int p_track, double p_time, Vector3 *r_loc, Quaternion *r_rot, Vector3 *r_scale) const;
-
 	Variant value_track_interpolate(int p_track, double p_time) const;
 	void value_track_get_key_indices(int p_track, double p_time, double p_delta, List<int> *p_indices) const;
 	void value_track_set_update_mode(int p_track, UpdateMode p_mode);