1 files changed, 574 insertions, 341 deletions

diff --git a/scene/resources/animation.cpp b/scene/resources/animation.cpp
index 69b30b72b0..9d5bc18c96 100644
--- a/scene/resources/animation.cpp
+++ b/scene/resources/animation.cpp
@@ -313,29 +313,37 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				Dictionary d = p_value;
 				ERR_FAIL_COND_V(!d.has("times"), false);
 				ERR_FAIL_COND_V(!d.has("points"), false);
-
 				Vector<real_t> times = d["times"];
 				Vector<real_t> values = d["points"];
+#ifdef TOOLS_ENABLED
+				ERR_FAIL_COND_V(!d.has("handle_modes"), false);
+				Vector<int> handle_modes = d["handle_modes"];
+#endif // TOOLS_ENABLED
 
-				ERR_FAIL_COND_V(times.size() * 6 != values.size(), false);
+				ERR_FAIL_COND_V(times.size() * 5 != values.size(), false);
 
 				if (times.size()) {
 					int valcount = times.size();
 
 					const real_t *rt = times.ptr();
 					const real_t *rv = values.ptr();
+#ifdef TOOLS_ENABLED
+					const int *rh = handle_modes.ptr();
+#endif // TOOLS_ENABLED
 
 					bt->values.resize(valcount);
 
 					for (int i = 0; i < valcount; i++) {
 						bt->values.write[i].time = rt[i];
 						bt->values.write[i].transition = 0; //unused in bezier
-						bt->values.write[i].value.value = rv[i * 6 + 0];
-						bt->values.write[i].value.in_handle.x = rv[i * 6 + 1];
-						bt->values.write[i].value.in_handle.y = rv[i * 6 + 2];
-						bt->values.write[i].value.out_handle.x = rv[i * 6 + 3];
-						bt->values.write[i].value.out_handle.y = rv[i * 6 + 4];
-						bt->values.write[i].value.handle_mode = static_cast<HandleMode>((int)rv[i * 6 + 5]);
+						bt->values.write[i].value.value = rv[i * 5 + 0];
+						bt->values.write[i].value.in_handle.x = rv[i * 5 + 1];
+						bt->values.write[i].value.in_handle.y = rv[i * 5 + 2];
+						bt->values.write[i].value.out_handle.x = rv[i * 5 + 3];
+						bt->values.write[i].value.out_handle.y = rv[i * 5 + 4];
+#ifdef TOOLS_ENABLED
+						bt->values.write[i].value.handle_mode = static_cast<HandleMode>(rh[i]);
+#endif // TOOLS_ENABLED
 					}
 				}
 
@@ -699,28 +707,39 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				int kk = bt->values.size();
 
 				key_times.resize(kk);
-				key_points.resize(kk * 6);
+				key_points.resize(kk * 5);
 
 				real_t *wti = key_times.ptrw();
 				real_t *wpo = key_points.ptrw();
 
+#ifdef TOOLS_ENABLED
+				Vector<int> handle_modes;
+				handle_modes.resize(kk);
+				int *whm = handle_modes.ptrw();
+#endif // TOOLS_ENABLED
+
 				int idx = 0;
 
 				const TKey<BezierKey> *vls = bt->values.ptr();
 
 				for (int i = 0; i < kk; i++) {
 					wti[idx] = vls[i].time;
-					wpo[idx * 6 + 0] = vls[i].value.value;
-					wpo[idx * 6 + 1] = vls[i].value.in_handle.x;
-					wpo[idx * 6 + 2] = vls[i].value.in_handle.y;
-					wpo[idx * 6 + 3] = vls[i].value.out_handle.x;
-					wpo[idx * 6 + 4] = vls[i].value.out_handle.y;
-					wpo[idx * 6 + 5] = (double)vls[i].value.handle_mode;
+					wpo[idx * 5 + 0] = vls[i].value.value;
+					wpo[idx * 5 + 1] = vls[i].value.in_handle.x;
+					wpo[idx * 5 + 2] = vls[i].value.in_handle.y;
+					wpo[idx * 5 + 3] = vls[i].value.out_handle.x;
+					wpo[idx * 5 + 4] = vls[i].value.out_handle.y;
+#ifdef TOOLS_ENABLED
+					whm[idx] = static_cast<int>(vls[i].value.handle_mode);
+#endif // TOOLS_ENABLED
 					idx++;
 				}
 
 				d["times"] = key_times;
 				d["points"] = key_points;
+#ifdef TOOLS_ENABLED
+				d["handle_modes"] = handle_modes;
+#endif // TOOLS_ENABLED
 
 				r_ret = d;
 
@@ -967,7 +986,6 @@ int Animation::find_track(const NodePath &p_path, const TrackType p_type) const
 
 void Animation::track_set_interpolation_type(int p_track, InterpolationType p_interp) {
 	ERR_FAIL_INDEX(p_track, tracks.size());
-	ERR_FAIL_INDEX(p_interp, 3);
 	tracks[p_track]->interpolation = p_interp;
 	emit_changed();
 }
@@ -1627,7 +1645,7 @@ int Animation::track_insert_key(int p_track, double p_time, const Variant &p_key
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 
 			Array arr = p_key;
-			ERR_FAIL_COND_V(arr.size() != 6, -1);
+			ERR_FAIL_COND_V(arr.size() != 5, -1);
 
 			TKey<BezierKey> k;
 			k.time = p_time;
@@ -1636,9 +1654,16 @@ int Animation::track_insert_key(int p_track, double p_time, const Variant &p_key
 			k.value.in_handle.y = arr[2];
 			k.value.out_handle.x = arr[3];
 			k.value.out_handle.y = arr[4];
-			k.value.handle_mode = static_cast<HandleMode>((int)arr[5]);
 			ret = _insert(p_time, bt->values, k);
 
+			Vector<int> key_neighborhood;
+			key_neighborhood.push_back(ret);
+			if (ret > 0) {
+				key_neighborhood.push_back(ret - 1);
+			}
+			if (ret < track_get_key_count(p_track) - 1) {
+				key_neighborhood.push_back(ret + 1);
+			}
 		} break;
 		case TYPE_AUDIO: {
 			AudioTrack *at = static_cast<AudioTrack *>(t);
@@ -1777,13 +1802,12 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 			ERR_FAIL_INDEX_V(p_key_idx, bt->values.size(), Variant());
 
 			Array arr;
-			arr.resize(6);
+			arr.resize(5);
 			arr[0] = bt->values[p_key_idx].value.value;
 			arr[1] = bt->values[p_key_idx].value.in_handle.x;
 			arr[2] = bt->values[p_key_idx].value.in_handle.y;
 			arr[3] = bt->values[p_key_idx].value.out_handle.x;
 			arr[4] = bt->values[p_key_idx].value.out_handle.y;
-			arr[5] = (double)bt->values[p_key_idx].value.handle_mode;
 			return arr;
 
 		} break;
@@ -2152,14 +2176,13 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 			ERR_FAIL_INDEX(p_key_idx, bt->values.size());
 
 			Array arr = p_value;
-			ERR_FAIL_COND(arr.size() != 6);
+			ERR_FAIL_COND(arr.size() != 5);
 
 			bt->values.write[p_key_idx].value.value = arr[0];
 			bt->values.write[p_key_idx].value.in_handle.x = arr[1];
 			bt->values.write[p_key_idx].value.in_handle.y = arr[2];
 			bt->values.write[p_key_idx].value.out_handle.x = arr[3];
 			bt->values.write[p_key_idx].value.out_handle.y = arr[4];
-			bt->values.write[p_key_idx].value.handle_mode = static_cast<HandleMode>((int)arr[5]);
 
 		} break;
 		case TYPE_AUDIO: {
@@ -2283,6 +2306,8 @@ int Animation::_find(const Vector<K> &p_keys, double p_time, bool p_backward) co
 	return middle;
 }
 
+// Linear interpolation for anytype.
+
 Vector3 Animation::_interpolate(const Vector3 &p_a, const Vector3 &p_b, real_t p_c) const {
 	return p_a.lerp(p_b, p_c);
 }
@@ -2298,18 +2323,33 @@ Variant Animation::_interpolate(const Variant &p_a, const Variant &p_b, real_t p
 }
 
 real_t Animation::_interpolate(const real_t &p_a, const real_t &p_b, real_t p_c) const {
-	return p_a * (1.0 - p_c) + p_b * p_c;
+	return Math::lerp(p_a, p_b, p_c);
 }
 
-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);
+Variant Animation::_interpolate_angle(const Variant &p_a, const Variant &p_b, real_t p_c) const {
+	Variant::Type type_a = p_a.get_type();
+	Variant::Type type_b = p_b.get_type();
+	uint32_t vformat = 1 << type_a;
+	vformat |= 1 << type_b;
+	if (vformat == ((1 << Variant::INT) | (1 << Variant::FLOAT)) || vformat == (1 << Variant::FLOAT)) {
+		real_t a = p_a;
+		real_t b = p_b;
+		return Math::fposmod((float)Math::lerp_angle(a, b, p_c), (float)Math_TAU);
+	}
+	return _interpolate(p_a, p_b, p_c);
+}
+
+// Cubic interpolation for anytype.
+
+Vector3 Animation::_cubic_interpolate_in_time(const Vector3 &p_pre_a, const Vector3 &p_a, const Vector3 &p_b, const Vector3 &p_post_b, real_t p_c, real_t p_pre_a_t, real_t p_b_t, real_t p_post_b_t) const {
+	return p_a.cubic_interpolate_in_time(p_b, p_pre_a, p_post_b, p_c, p_b_t, p_pre_a_t, p_post_b_t);
 }
 
-Quaternion Animation::_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 {
-	return p_a.spherical_cubic_interpolate(p_b, p_pre_a, p_post_b, p_c);
+Quaternion Animation::_cubic_interpolate_in_time(const Quaternion &p_pre_a, const Quaternion &p_a, const Quaternion &p_b, const Quaternion &p_post_b, real_t p_c, real_t p_pre_a_t, real_t p_b_t, real_t p_post_b_t) const {
+	return p_a.spherical_cubic_interpolate_in_time(p_b, p_pre_a, p_post_b, p_c, p_b_t, p_pre_a_t, p_post_b_t);
 }
 
-Variant Animation::_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 {
+Variant Animation::_cubic_interpolate_in_time(const Variant &p_pre_a, const Variant &p_a, const Variant &p_b, const Variant &p_post_b, real_t p_c, real_t p_pre_a_t, real_t p_b_t, real_t p_post_b_t) const {
 	Variant::Type type_a = p_a.get_type();
 	Variant::Type type_b = p_b.get_type();
 	Variant::Type type_pa = p_pre_a.get_type();
@@ -2329,7 +2369,7 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 		real_t pa = p_pre_a;
 		real_t pb = p_post_b;
 
-		return Math::cubic_interpolate(a, b, pa, pb, p_c);
+		return Math::cubic_interpolate_in_time(a, b, pa, pb, p_c, p_b_t, p_pre_a_t, p_post_b_t);
 	} else if ((vformat & (vformat - 1))) {
 		return p_a; //can't interpolate, mix of types
 	}
@@ -2341,7 +2381,7 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			Vector2 pa = p_pre_a;
 			Vector2 pb = p_post_b;
 
-			return a.cubic_interpolate(b, pa, pb, p_c);
+			return a.cubic_interpolate_in_time(b, pa, pb, p_c, p_b_t, p_pre_a_t, p_post_b_t);
 		}
 		case Variant::RECT2: {
 			Rect2 a = p_a;
@@ -2350,8 +2390,8 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			Rect2 pb = p_post_b;
 
 			return Rect2(
-					a.position.cubic_interpolate(b.position, pa.position, pb.position, p_c),
-					a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c));
+					a.position.cubic_interpolate_in_time(b.position, pa.position, pb.position, p_c, p_b_t, p_pre_a_t, p_post_b_t),
+					a.size.cubic_interpolate_in_time(b.size, pa.size, pb.size, p_c, p_b_t, p_pre_a_t, p_post_b_t));
 		}
 		case Variant::VECTOR3: {
 			Vector3 a = p_a;
@@ -2359,7 +2399,7 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			Vector3 pa = p_pre_a;
 			Vector3 pb = p_post_b;
 
-			return a.cubic_interpolate(b, pa, pb, p_c);
+			return a.cubic_interpolate_in_time(b, pa, pb, p_c, p_b_t, p_pre_a_t, p_post_b_t);
 		}
 		case Variant::QUATERNION: {
 			Quaternion a = p_a;
@@ -2367,7 +2407,7 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			Quaternion pa = p_pre_a;
 			Quaternion pb = p_post_b;
 
-			return a.spherical_cubic_interpolate(b, pa, pb, p_c);
+			return a.spherical_cubic_interpolate_in_time(b, pa, pb, p_c, p_b_t, p_pre_a_t, p_post_b_t);
 		}
 		case Variant::AABB: {
 			AABB a = p_a;
@@ -2376,8 +2416,8 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			AABB pb = p_post_b;
 
 			return AABB(
-					a.position.cubic_interpolate(b.position, pa.position, pb.position, p_c),
-					a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c));
+					a.position.cubic_interpolate_in_time(b.position, pa.position, pb.position, p_c, p_b_t, p_pre_a_t, p_post_b_t),
+					a.size.cubic_interpolate_in_time(b.size, pa.size, pb.size, p_c, p_b_t, p_pre_a_t, p_post_b_t));
 		}
 		default: {
 			return _interpolate(p_a, p_b, p_c);
@@ -2385,7 +2425,26 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 	}
 }
 
-real_t Animation::_cubic_interpolate(const real_t &p_pre_a, const real_t &p_a, const real_t &p_b, const real_t &p_post_b, real_t p_c) const {
+real_t Animation::_cubic_interpolate_in_time(const real_t &p_pre_a, const real_t &p_a, const real_t &p_b, const real_t &p_post_b, real_t p_c, real_t p_pre_a_t, real_t p_b_t, real_t p_post_b_t) const {
+	return Math::cubic_interpolate_in_time(p_a, p_b, p_pre_a, p_post_b, p_c, p_b_t, p_pre_a_t, p_post_b_t);
+}
+
+Variant Animation::_cubic_interpolate_angle_in_time(const Variant &p_pre_a, const Variant &p_a, const Variant &p_b, const Variant &p_post_b, real_t p_c, real_t p_pre_a_t, real_t p_b_t, real_t p_post_b_t) const {
+	Variant::Type type_a = p_a.get_type();
+	Variant::Type type_b = p_b.get_type();
+	Variant::Type type_pa = p_pre_a.get_type();
+	Variant::Type type_pb = p_post_b.get_type();
+	uint32_t vformat = 1 << type_a;
+	vformat |= 1 << type_b;
+	vformat |= 1 << type_pa;
+	vformat |= 1 << type_pb;
+	if (vformat == ((1 << Variant::INT) | (1 << Variant::FLOAT)) || vformat == (1 << Variant::FLOAT)) {
+		real_t a = p_a;
+		real_t b = p_b;
+		real_t pa = p_pre_a;
+		real_t pb = p_post_b;
+		return Math::fposmod((float)Math::cubic_interpolate_angle_in_time(a, b, pa, pb, p_c, p_b_t, p_pre_a_t, p_post_b_t), (float)Math_TAU);
+	}
 	return _interpolate(p_a, p_b, p_c);
 }
 
@@ -2568,26 +2627,70 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, double p_time, Interpol
 		case INTERPOLATION_LINEAR: {
 			return _interpolate(p_keys[idx].value, p_keys[next].value, c);
 		} break;
-		case INTERPOLATION_CUBIC: {
-			int pre = idx - 1;
-			if (pre < 0) {
-				if (loop_mode == LOOP_LINEAR && p_loop_wrap) {
-					pre = len - 1;
-				} else {
-					pre = 0;
+		case INTERPOLATION_LINEAR_ANGLE: {
+			return _interpolate_angle(p_keys[idx].value, p_keys[next].value, c);
+		} break;
+		case INTERPOLATION_CUBIC:
+		case INTERPOLATION_CUBIC_ANGLE: {
+			int pre = 0;
+			int post = 0;
+			if (!p_backward) {
+				pre = idx - 1;
+				if (pre < 0) {
+					if (loop_mode == LOOP_LINEAR && p_loop_wrap) {
+						pre = len - 1;
+					} else {
+						pre = 0;
+					}
 				}
-			}
-			int post = next + 1;
-			if (post >= len) {
-				if (loop_mode == LOOP_LINEAR && p_loop_wrap) {
-					post = 0;
-				} else {
-					post = next;
+				post = next + 1;
+				if (post >= len) {
+					if (loop_mode == LOOP_LINEAR && p_loop_wrap) {
+						post = 0;
+					} else {
+						post = next;
+					}
+				}
+			} else {
+				pre = idx + 1;
+				if (pre >= len) {
+					if (loop_mode == LOOP_LINEAR && p_loop_wrap) {
+						pre = 0;
+					} else {
+						pre = idx;
+					}
+				}
+				post = next - 1;
+				if (post < 0) {
+					if (loop_mode == LOOP_LINEAR && p_loop_wrap) {
+						post = len - 1;
+					} else {
+						post = 0;
+					}
 				}
 			}
 
-			return _cubic_interpolate(p_keys[pre].value, p_keys[idx].value, p_keys[next].value, p_keys[post].value, c);
+			real_t pre_t = 0.0;
+			real_t to_t = 0.0;
+			real_t post_t = 0.0;
+			if (loop_mode == LOOP_LINEAR && p_loop_wrap) {
+				pre_t = pre > idx ? -length + p_keys[pre].time - p_keys[idx].time : p_keys[pre].time - p_keys[idx].time;
+				to_t = next < idx ? length + p_keys[next].time - p_keys[idx].time : p_keys[next].time - p_keys[idx].time;
+				post_t = next < idx || post <= idx ? length + p_keys[post].time - p_keys[idx].time : p_keys[post].time - p_keys[idx].time;
+			} else {
+				pre_t = p_keys[pre].time - p_keys[idx].time;
+				to_t = p_keys[next].time - p_keys[idx].time;
+				post_t = p_keys[post].time - p_keys[idx].time;
+			}
 
+			if (p_interp == INTERPOLATION_CUBIC_ANGLE) {
+				return _cubic_interpolate_angle_in_time(
+						p_keys[pre].value, p_keys[idx].value, p_keys[next].value, p_keys[post].value, c,
+						pre_t, to_t, post_t);
+			}
+			return _cubic_interpolate_in_time(
+					p_keys[pre].value, p_keys[idx].value, p_keys[next].value, p_keys[post].value, c,
+					pre_t, to_t, post_t);
 		} break;
 		default:
 			return p_keys[idx].value;
@@ -3215,7 +3318,7 @@ StringName Animation::method_track_get_name(int p_track, int p_key_idx) const {
 	return pm->methods[p_key_idx].method;
 }
 
-int Animation::bezier_track_insert_key(int p_track, double p_time, real_t p_value, const Vector2 &p_in_handle, const Vector2 &p_out_handle, const HandleMode p_handle_mode) {
+int Animation::bezier_track_insert_key(int p_track, double p_time, real_t p_value, const Vector2 &p_in_handle, const Vector2 &p_out_handle) {
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_BEZIER, -1);
@@ -3233,7 +3336,6 @@ int Animation::bezier_track_insert_key(int p_track, double p_time, real_t p_valu
 	if (k.value.out_handle.x < 0) {
 		k.value.out_handle.x = 0;
 	}
-	k.value.handle_mode = p_handle_mode;
 
 	int key = _insert(p_time, bt->values, k);
 
@@ -3242,30 +3344,6 @@ int Animation::bezier_track_insert_key(int p_track, double p_time, real_t p_valu
 	return key;
 }
 
-void Animation::bezier_track_set_key_handle_mode(int p_track, int p_index, HandleMode p_mode, double p_balanced_value_time_ratio) {
-	ERR_FAIL_INDEX(p_track, tracks.size());
-	Track *t = tracks[p_track];
-	ERR_FAIL_COND(t->type != TYPE_BEZIER);
-
-	BezierTrack *bt = static_cast<BezierTrack *>(t);
-
-	ERR_FAIL_INDEX(p_index, bt->values.size());
-
-	bt->values.write[p_index].value.handle_mode = p_mode;
-
-	if (p_mode == HANDLE_MODE_BALANCED) {
-		Transform2D xform;
-		xform.set_scale(Vector2(1.0, 1.0 / p_balanced_value_time_ratio));
-
-		Vector2 vec_in = xform.xform(bt->values[p_index].value.in_handle);
-		Vector2 vec_out = xform.xform(bt->values[p_index].value.out_handle);
-
-		bt->values.write[p_index].value.in_handle = xform.affine_inverse().xform(-vec_out.normalized() * vec_in.length());
-	}
-
-	emit_changed();
-}
-
 void Animation::bezier_track_set_key_value(int p_track, int p_index, real_t p_value) {
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
@@ -3276,10 +3354,11 @@ void Animation::bezier_track_set_key_value(int p_track, int p_index, real_t p_va
 	ERR_FAIL_INDEX(p_index, bt->values.size());
 
 	bt->values.write[p_index].value.value = p_value;
+
 	emit_changed();
 }
 
-void Animation::bezier_track_set_key_in_handle(int p_track, int p_index, const Vector2 &p_handle, double p_balanced_value_time_ratio) {
+void Animation::bezier_track_set_key_in_handle(int p_track, int p_index, const Vector2 &p_handle, real_t p_balanced_value_time_ratio) {
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_BEZIER);
@@ -3294,7 +3373,11 @@ void Animation::bezier_track_set_key_in_handle(int p_track, int p_index, const V
 	}
 	bt->values.write[p_index].value.in_handle = in_handle;
 
-	if (bt->values[p_index].value.handle_mode == HANDLE_MODE_BALANCED) {
+#ifdef TOOLS_ENABLED
+	if (bt->values[p_index].value.handle_mode == HANDLE_MODE_LINEAR) {
+		bt->values.write[p_index].value.in_handle = Vector2();
+		bt->values.write[p_index].value.out_handle = Vector2();
+	} else if (bt->values[p_index].value.handle_mode == HANDLE_MODE_BALANCED) {
 		Transform2D xform;
 		xform.set_scale(Vector2(1.0, 1.0 / p_balanced_value_time_ratio));
 
@@ -3302,12 +3385,15 @@ void Animation::bezier_track_set_key_in_handle(int p_track, int p_index, const V
 		Vector2 vec_in = xform.xform(in_handle);
 
 		bt->values.write[p_index].value.out_handle = xform.affine_inverse().xform(-vec_in.normalized() * vec_out.length());
+	} else if (bt->values[p_index].value.handle_mode == HANDLE_MODE_MIRRORED) {
+		bt->values.write[p_index].value.out_handle = -in_handle;
 	}
+#endif // TOOLS_ENABLED
 
 	emit_changed();
 }
 
-void Animation::bezier_track_set_key_out_handle(int p_track, int p_index, const Vector2 &p_handle, double p_balanced_value_time_ratio) {
+void Animation::bezier_track_set_key_out_handle(int p_track, int p_index, const Vector2 &p_handle, real_t p_balanced_value_time_ratio) {
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_BEZIER);
@@ -3322,7 +3408,11 @@ void Animation::bezier_track_set_key_out_handle(int p_track, int p_index, const
 	}
 	bt->values.write[p_index].value.out_handle = out_handle;
 
-	if (bt->values[p_index].value.handle_mode == HANDLE_MODE_BALANCED) {
+#ifdef TOOLS_ENABLED
+	if (bt->values[p_index].value.handle_mode == HANDLE_MODE_LINEAR) {
+		bt->values.write[p_index].value.in_handle = Vector2();
+		bt->values.write[p_index].value.out_handle = Vector2();
+	} else if (bt->values[p_index].value.handle_mode == HANDLE_MODE_BALANCED) {
 		Transform2D xform;
 		xform.set_scale(Vector2(1.0, 1.0 / p_balanced_value_time_ratio));
 
@@ -3330,7 +3420,10 @@ void Animation::bezier_track_set_key_out_handle(int p_track, int p_index, const
 		Vector2 vec_out = xform.xform(out_handle);
 
 		bt->values.write[p_index].value.in_handle = xform.affine_inverse().xform(-vec_out.normalized() * vec_in.length());
+	} else if (bt->values[p_index].value.handle_mode == HANDLE_MODE_MIRRORED) {
+		bt->values.write[p_index].value.in_handle = -out_handle;
 	}
+#endif // TOOLS_ENABLED
 
 	emit_changed();
 }
@@ -3347,18 +3440,6 @@ real_t Animation::bezier_track_get_key_value(int p_track, int p_index) const {
 	return bt->values[p_index].value.value;
 }
 
-int Animation::bezier_track_get_key_handle_mode(int p_track, int p_index) const {
-	ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
-	Track *t = tracks[p_track];
-	ERR_FAIL_COND_V(t->type != TYPE_BEZIER, 0);
-
-	BezierTrack *bt = static_cast<BezierTrack *>(t);
-
-	ERR_FAIL_INDEX_V(p_index, bt->values.size(), 0);
-
-	return bt->values[p_index].value.handle_mode;
-}
-
 Vector2 Animation::bezier_track_get_key_in_handle(int p_track, int p_index) const {
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), Vector2());
 	Track *t = tracks[p_track];
@@ -3383,6 +3464,109 @@ Vector2 Animation::bezier_track_get_key_out_handle(int p_track, int p_index) con
 	return bt->values[p_index].value.out_handle;
 }
 
+#ifdef TOOLS_ENABLED
+void Animation::bezier_track_set_key_handle_mode(int p_track, int p_index, HandleMode p_mode, HandleSetMode p_set_mode) {
+	ERR_FAIL_INDEX(p_track, tracks.size());
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND(t->type != TYPE_BEZIER);
+
+	BezierTrack *bt = static_cast<BezierTrack *>(t);
+
+	ERR_FAIL_INDEX(p_index, bt->values.size());
+
+	bt->values.write[p_index].value.handle_mode = p_mode;
+
+	switch (p_mode) {
+		case HANDLE_MODE_LINEAR: {
+			bt->values.write[p_index].value.in_handle = Vector2(0, 0);
+			bt->values.write[p_index].value.out_handle = Vector2(0, 0);
+		} break;
+		case HANDLE_MODE_BALANCED:
+		case HANDLE_MODE_MIRRORED: {
+			int prev_key = MAX(0, p_index - 1);
+			int next_key = MIN(bt->values.size() - 1, p_index + 1);
+			if (prev_key == next_key) {
+				break; // Exists only one key.
+			}
+			real_t in_handle_x = 0;
+			real_t in_handle_y = 0;
+			real_t out_handle_x = 0;
+			real_t out_handle_y = 0;
+			if (p_mode == HANDLE_MODE_BALANCED) {
+				// Note:
+				// If p_set_mode == HANDLE_SET_MODE_NONE, I don't know if it should change the Tangent implicitly.
+				// At the least, we need to avoid corrupting the handles when loading animation from the resource.
+				// However, changes made by the Inspector do not go through the BezierEditor,
+				// so if you change from Free to Balanced or Mirrored in Inspector, there is no guarantee that
+				// it is Balanced or Mirrored until there is a handle operation.
+				if (p_set_mode == HANDLE_SET_MODE_RESET) {
+					real_t handle_length = 1.0 / 3.0;
+					in_handle_x = (bt->values[prev_key].time - bt->values[p_index].time) * handle_length;
+					in_handle_y = 0;
+					out_handle_x = (bt->values[next_key].time - bt->values[p_index].time) * handle_length;
+					out_handle_y = 0;
+					bt->values.write[p_index].value.in_handle = Vector2(in_handle_x, in_handle_y);
+					bt->values.write[p_index].value.out_handle = Vector2(out_handle_x, out_handle_y);
+				} else if (p_set_mode == HANDLE_SET_MODE_AUTO) {
+					real_t handle_length = 1.0 / 6.0;
+					real_t tangent = (bt->values[next_key].value.value - bt->values[prev_key].value.value) / (bt->values[next_key].time - bt->values[prev_key].time);
+					in_handle_x = (bt->values[prev_key].time - bt->values[p_index].time) * handle_length;
+					in_handle_y = in_handle_x * tangent;
+					out_handle_x = (bt->values[next_key].time - bt->values[p_index].time) * handle_length;
+					out_handle_y = out_handle_x * tangent;
+					bt->values.write[p_index].value.in_handle = Vector2(in_handle_x, in_handle_y);
+					bt->values.write[p_index].value.out_handle = Vector2(out_handle_x, out_handle_y);
+				}
+			} else {
+				real_t handle_length = 1.0 / 4.0;
+				real_t prev_interval = Math::abs(bt->values[p_index].time - bt->values[prev_key].time);
+				real_t next_interval = Math::abs(bt->values[p_index].time - bt->values[next_key].time);
+				real_t min_time = 0;
+				if (Math::is_zero_approx(prev_interval)) {
+					min_time = next_interval;
+				} else if (Math::is_zero_approx(next_interval)) {
+					min_time = prev_interval;
+				} else {
+					min_time = MIN(prev_interval, next_interval);
+				}
+				if (p_set_mode == HANDLE_SET_MODE_RESET) {
+					in_handle_x = -min_time * handle_length;
+					in_handle_y = 0;
+					out_handle_x = min_time * handle_length;
+					out_handle_y = 0;
+					bt->values.write[p_index].value.in_handle = Vector2(in_handle_x, in_handle_y);
+					bt->values.write[p_index].value.out_handle = Vector2(out_handle_x, out_handle_y);
+				} else if (p_set_mode == HANDLE_SET_MODE_AUTO) {
+					real_t tangent = (bt->values[next_key].value.value - bt->values[prev_key].value.value) / min_time;
+					in_handle_x = -min_time * handle_length;
+					in_handle_y = in_handle_x * tangent;
+					out_handle_x = min_time * handle_length;
+					out_handle_y = out_handle_x * tangent;
+					bt->values.write[p_index].value.in_handle = Vector2(in_handle_x, in_handle_y);
+					bt->values.write[p_index].value.out_handle = Vector2(out_handle_x, out_handle_y);
+				}
+			}
+		} break;
+		default: {
+		} break;
+	}
+
+	emit_changed();
+}
+
+Animation::HandleMode Animation::bezier_track_get_key_handle_mode(int p_track, int p_index) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), HANDLE_MODE_FREE);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_BEZIER, HANDLE_MODE_FREE);
+
+	BezierTrack *bt = static_cast<BezierTrack *>(t);
+
+	ERR_FAIL_INDEX_V(p_index, bt->values.size(), HANDLE_MODE_FREE);
+
+	return bt->values[p_index].value.handle_mode;
+}
+#endif // TOOLS_ENABLED
+
 real_t Animation::bezier_track_interpolate(int p_track, double p_time) const {
 	//this uses a different interpolation scheme
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
@@ -3779,7 +3963,7 @@ void Animation::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("method_track_get_name", "track_idx", "key_idx"), &Animation::method_track_get_name);
 	ClassDB::bind_method(D_METHOD("method_track_get_params", "track_idx", "key_idx"), &Animation::method_track_get_params);
 
-	ClassDB::bind_method(D_METHOD("bezier_track_insert_key", "track_idx", "time", "value", "in_handle", "out_handle", "handle_mode"), &Animation::bezier_track_insert_key, DEFVAL(Vector2()), DEFVAL(Vector2()), DEFVAL(Animation::HandleMode::HANDLE_MODE_BALANCED));
+	ClassDB::bind_method(D_METHOD("bezier_track_insert_key", "track_idx", "time", "value", "in_handle", "out_handle"), &Animation::bezier_track_insert_key, DEFVAL(Vector2()), DEFVAL(Vector2()));
 
 	ClassDB::bind_method(D_METHOD("bezier_track_set_key_value", "track_idx", "key_idx", "value"), &Animation::bezier_track_set_key_value);
 	ClassDB::bind_method(D_METHOD("bezier_track_set_key_in_handle", "track_idx", "key_idx", "in_handle", "balanced_value_time_ratio"), &Animation::bezier_track_set_key_in_handle, DEFVAL(1.0));
@@ -3799,9 +3983,6 @@ void Animation::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("audio_track_get_key_start_offset", "track_idx", "key_idx"), &Animation::audio_track_get_key_start_offset);
 	ClassDB::bind_method(D_METHOD("audio_track_get_key_end_offset", "track_idx", "key_idx"), &Animation::audio_track_get_key_end_offset);
 
-	ClassDB::bind_method(D_METHOD("bezier_track_set_key_handle_mode", "track_idx", "key_idx", "key_handle_mode", "balanced_value_time_ratio"), &Animation::bezier_track_set_key_handle_mode, DEFVAL(1.0));
-	ClassDB::bind_method(D_METHOD("bezier_track_get_key_handle_mode", "track_idx", "key_idx"), &Animation::bezier_track_get_key_handle_mode);
-
 	ClassDB::bind_method(D_METHOD("animation_track_insert_key", "track_idx", "time", "animation"), &Animation::animation_track_insert_key);
 	ClassDB::bind_method(D_METHOD("animation_track_set_key_animation", "track_idx", "key_idx", "animation"), &Animation::animation_track_set_key_animation);
 	ClassDB::bind_method(D_METHOD("animation_track_get_key_animation", "track_idx", "key_idx"), &Animation::animation_track_get_key_animation);
@@ -3839,6 +4020,8 @@ void Animation::_bind_methods() {
 	BIND_ENUM_CONSTANT(INTERPOLATION_NEAREST);
 	BIND_ENUM_CONSTANT(INTERPOLATION_LINEAR);
 	BIND_ENUM_CONSTANT(INTERPOLATION_CUBIC);
+	BIND_ENUM_CONSTANT(INTERPOLATION_LINEAR_ANGLE);
+	BIND_ENUM_CONSTANT(INTERPOLATION_CUBIC_ANGLE);
 
 	BIND_ENUM_CONSTANT(UPDATE_CONTINUOUS);
 	BIND_ENUM_CONSTANT(UPDATE_DISCRETE);
@@ -3848,9 +4031,6 @@ void Animation::_bind_methods() {
 	BIND_ENUM_CONSTANT(LOOP_NONE);
 	BIND_ENUM_CONSTANT(LOOP_LINEAR);
 	BIND_ENUM_CONSTANT(LOOP_PINGPONG);
-
-	BIND_ENUM_CONSTANT(HANDLE_MODE_FREE);
-	BIND_ENUM_CONSTANT(HANDLE_MODE_BALANCED);
 }
 
 void Animation::clear() {
@@ -3868,316 +4048,369 @@ void Animation::clear() {
 	emit_signal(SceneStringNames::get_singleton()->tracks_changed);
 }
 
-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;
-
-	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;
-		}
-
-	} 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;
-		}
-
-		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_err) {
-			return false; //beyond allowed error for collinearity
-		}
-
-		if (p_norm != Vector3() && Math::acos(pd.normalized().dot(p_norm)) > p_allowed_angular_error) {
-			return false;
+bool Animation::_float_track_optimize_key(const TKey<float> t0, const TKey<float> t1, const TKey<float> t2, real_t p_allowed_velocity_err, real_t p_allowed_precision_error) {
+	// Remove overlapping keys.
+	if (Math::is_equal_approx(t0.time, t1.time) || Math::is_equal_approx(t1.time, t2.time)) {
+		return true;
+	}
+	if (abs(t0.value - t1.value) < p_allowed_precision_error && abs(t1.value - t2.value) < p_allowed_precision_error) {
+		return true;
+	}
+	// Calc velocities.
+	double v0 = (t1.value - t0.value) / (t1.time - t0.time);
+	double v1 = (t2.value - t1.value) / (t2.time - t1.time);
+	// Avoid zero div but check equality.
+	if (abs(v0 - v1) < p_allowed_precision_error) {
+		return true;
+	} else if (abs(v0) < p_allowed_precision_error || abs(v1) < p_allowed_precision_error) {
+		return false;
+	}
+	if (!signbit(v0 * v1)) {
+		v0 = abs(v0);
+		v1 = abs(v1);
+		double ratio = v0 < v1 ? v0 / v1 : v1 / v0;
+		if (ratio >= 1.0 - p_allowed_velocity_err) {
+			return true;
 		}
 	}
-
-	return true;
+	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
-
-	if (q0.is_equal_approx(q2)) {
-		if (!q0.is_equal_approx(q1)) {
-			return false;
-		}
-
-	} else {
-		Quaternion r02 = (q0.inverse() * q2).normalized();
-		Quaternion r01 = (q0.inverse() * q1).normalized();
-
-		Vector3 v02, v01;
-		real_t a02, a01;
-
-		r02.get_axis_angle(v02, a02);
-		r01.get_axis_angle(v01, a01);
-
-		if (Math::abs(a02) > p_max_optimizable_angle) {
-			return false;
-		}
-
-		if (v01.dot(v02) < 0) {
-			//make sure both rotations go the same way to compare
-			v02 = -v02;
-			a02 = -a02;
-		}
-
-		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;
-		}
-
-		if (a01 * a02 < 0) {
-			//not rotating in the same direction
-			return false;
-		}
-
-		real_t tr = a01 / a02;
-		if (tr < 0 || tr > 1) {
-			return false; //rotating too much or too less
+bool Animation::_vector2_track_optimize_key(const TKey<Vector2> t0, const TKey<Vector2> t1, const TKey<Vector2> t2, real_t p_allowed_velocity_err, real_t p_allowed_angular_error, real_t p_allowed_precision_error) {
+	// Remove overlapping keys.
+	if (Math::is_equal_approx(t0.time, t1.time) || Math::is_equal_approx(t1.time, t2.time)) {
+		return true;
+	}
+	if ((t0.value - t1.value).length() < p_allowed_precision_error && (t1.value - t2.value).length() < p_allowed_precision_error) {
+		return true;
+	}
+	// Calc velocities.
+	Vector2 vc0 = (t1.value - t0.value) / (t1.time - t0.time);
+	Vector2 vc1 = (t2.value - t1.value) / (t2.time - t1.time);
+	double v0 = vc0.length();
+	double v1 = vc1.length();
+	// Avoid zero div but check equality.
+	if (abs(v0 - v1) < p_allowed_precision_error) {
+		return true;
+	} else if (abs(v0) < p_allowed_precision_error || abs(v1) < p_allowed_precision_error) {
+		return false;
+	}
+	// Check axis.
+	if (vc0.normalized().dot(vc1.normalized()) >= 1.0 - p_allowed_angular_error * 2.0) {
+		v0 = abs(v0);
+		v1 = abs(v1);
+		double ratio = v0 < v1 ? v0 / v1 : v1 / v0;
+		if (ratio >= 1.0 - p_allowed_velocity_err) {
+			return true;
 		}
 	}
-
-	return true;
+	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 (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;
-		}
-
-	} 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
-		}
-
-		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
+bool Animation::_vector3_track_optimize_key(const TKey<Vector3> t0, const TKey<Vector3> t1, const TKey<Vector3> t2, real_t p_allowed_velocity_err, real_t p_allowed_angular_error, real_t p_allowed_precision_error) {
+	// Remove overlapping keys.
+	if (Math::is_equal_approx(t0.time, t1.time) || Math::is_equal_approx(t1.time, t2.time)) {
+		return true;
+	}
+	if ((t0.value - t1.value).length() < p_allowed_precision_error && (t1.value - t2.value).length() < p_allowed_precision_error) {
+		return true;
+	}
+	// Calc velocities.
+	Vector3 vc0 = (t1.value - t0.value) / (t1.time - t0.time);
+	Vector3 vc1 = (t2.value - t1.value) / (t2.time - t1.time);
+	double v0 = vc0.length();
+	double v1 = vc1.length();
+	// Avoid zero div but check equality.
+	if (abs(v0 - v1) < p_allowed_precision_error) {
+		return true;
+	} else if (abs(v0) < p_allowed_precision_error || abs(v1) < p_allowed_precision_error) {
+		return false;
+	}
+	// Check axis.
+	if (vc0.normalized().dot(vc1.normalized()) >= 1.0 - p_allowed_angular_error * 2.0) {
+		v0 = abs(v0);
+		v1 = abs(v1);
+		double ratio = v0 < v1 ? v0 / v1 : v1 / v0;
+		if (ratio >= 1.0 - p_allowed_velocity_err) {
+			return true;
 		}
 	}
-
-	return true;
+	return false;
 }
 
-bool Animation::_blend_shape_track_optimize_key(const TKey<float> &t0, const TKey<float> &t1, const TKey<float> &t2, real_t p_allowed_unit_error) {
-	float v0 = t0.value;
-	float v1 = t1.value;
-	float v2 = t2.value;
-
-	if (Math::is_equal_approx(v1, v2, (float)p_allowed_unit_error)) {
-		//0 and 2 are close, let's see if 1 is close
-		if (!Math::is_equal_approx(v0, v1, (float)p_allowed_unit_error)) {
-			//not close, not optimizable
-			return false;
+bool Animation::_quaternion_track_optimize_key(const TKey<Quaternion> t0, const TKey<Quaternion> t1, const TKey<Quaternion> t2, real_t p_allowed_velocity_err, real_t p_allowed_angular_error, real_t p_allowed_precision_error) {
+	// Remove overlapping keys.
+	if (Math::is_equal_approx(t0.time, t1.time) || Math::is_equal_approx(t1.time, t2.time)) {
+		return true;
+	}
+	if ((t0.value - t1.value).length() < p_allowed_precision_error && (t1.value - t2.value).length() < p_allowed_precision_error) {
+		return true;
+	}
+	// Check axis.
+	Quaternion q0 = t0.value * t1.value * t0.value.inverse();
+	Quaternion q1 = t1.value * t2.value * t1.value.inverse();
+	if (q0.get_axis().dot(q1.get_axis()) >= 1.0 - p_allowed_angular_error * 2.0) {
+		double a0 = Math::acos(t0.value.dot(t1.value));
+		double a1 = Math::acos(t1.value.dot(t2.value));
+		if (a0 + a1 >= Math_PI) {
+			return false; // Rotation is more than 180 deg, keep key.
 		}
-	} else {
-		/*
-		TODO eventually discuss a way to optimize these better.
-		float 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
+		// Calc velocities.
+		double v0 = a0 / (t1.time - t0.time);
+		double v1 = a1 / (t2.time - t1.time);
+		// Avoid zero div but check equality.
+		if (abs(v0 - v1) < p_allowed_precision_error) {
+			return true;
+		} else if (abs(v0) < p_allowed_precision_error || abs(v1) < p_allowed_precision_error) {
+			return false;
 		}
-
-		float 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
+		double ratio = v0 < v1 ? v0 / v1 : v1 / v0;
+		if (ratio >= 1.0 - p_allowed_velocity_err) {
+			return true;
 		}
-*/
 	}
-
-	return true;
+	return false;
 }
 
-void Animation::_position_track_optimize(int p_idx, real_t p_allowed_linear_err, real_t p_allowed_angular_err) {
+void Animation::_position_track_optimize(int p_idx, real_t p_allowed_velocity_err, real_t p_allowed_angular_err, real_t p_allowed_precision_error) {
 	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;
 
-	Vector3 norm;
-
-	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];
-
-		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;
-		}
+	int i = 0;
+	while (i < tt->positions.size() - 2) {
+		TKey<Vector3> t0 = tt->positions[i];
+		TKey<Vector3> t1 = tt->positions[i + 1];
+		TKey<Vector3> t2 = tt->positions[i + 2];
 
+		bool erase = _vector3_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_angular_err, p_allowed_precision_error);
 		if (erase) {
-			if (!prev_erased) {
-				first_erased = t1;
-				prev_erased = true;
-			}
-
-			tt->positions.remove_at(i);
-			i--;
-
+			tt->positions.remove_at(i + 1);
 		} else {
-			prev_erased = false;
-			norm = Vector3();
+			i++;
+		}
+	}
+
+	if (tt->positions.size() == 2) {
+		if ((tt->positions[0].value - tt->positions[1].value).length() < p_allowed_precision_error) {
+			tt->positions.remove_at(1);
 		}
 	}
 }
 
-void Animation::_rotation_track_optimize(int p_idx, real_t p_allowed_angular_err, real_t p_max_optimizable_angle) {
+void Animation::_rotation_track_optimize(int p_idx, real_t p_allowed_velocity_err, real_t p_allowed_angular_err, real_t p_allowed_precision_error) {
 	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;
-
-	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];
+	RotationTrack *rt = static_cast<RotationTrack *>(tracks[p_idx]);
 
-		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;
-		}
+	int i = 0;
+	while (i < rt->rotations.size() - 2) {
+		TKey<Quaternion> t0 = rt->rotations[i];
+		TKey<Quaternion> t1 = rt->rotations[i + 1];
+		TKey<Quaternion> t2 = rt->rotations[i + 2];
 
+		bool erase = _quaternion_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_angular_err, p_allowed_precision_error);
 		if (erase) {
-			if (!prev_erased) {
-				first_erased = t1;
-				prev_erased = true;
-			}
-
-			tt->rotations.remove_at(i);
-			i--;
-
+			rt->rotations.remove_at(i + 1);
 		} else {
-			prev_erased = false;
+			i++;
+		}
+	}
+
+	if (rt->rotations.size() == 2) {
+		if ((rt->rotations[0].value - rt->rotations[1].value).length() < p_allowed_precision_error) {
+			rt->rotations.remove_at(1);
 		}
 	}
 }
 
-void Animation::_scale_track_optimize(int p_idx, real_t p_allowed_linear_err) {
+void Animation::_scale_track_optimize(int p_idx, real_t p_allowed_velocity_err, real_t p_allowed_angular_err, real_t p_allowed_precision_error) {
 	ERR_FAIL_INDEX(p_idx, tracks.size());
 	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_SCALE_3D);
-	ScaleTrack *tt = static_cast<ScaleTrack *>(tracks[p_idx]);
-	bool prev_erased = false;
-	TKey<Vector3> first_erased;
-
-	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];
+	ScaleTrack *st = static_cast<ScaleTrack *>(tracks[p_idx]);
 
-		bool erase = _scale_track_optimize_key(t0, t1, t2, p_allowed_linear_err);
-
-		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;
-		}
+	int i = 0;
+	while (i < st->scales.size() - 2) {
+		TKey<Vector3> t0 = st->scales[i];
+		TKey<Vector3> t1 = st->scales[i + 1];
+		TKey<Vector3> t2 = st->scales[i + 2];
 
+		bool erase = _vector3_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_angular_err, p_allowed_precision_error);
 		if (erase) {
-			if (!prev_erased) {
-				first_erased = t1;
-				prev_erased = true;
-			}
-
-			tt->scales.remove_at(i);
-			i--;
-
+			st->scales.remove_at(i + 1);
 		} else {
-			prev_erased = false;
+			i++;
+		}
+	}
+
+	if (st->scales.size() == 2) {
+		if ((st->scales[0].value - st->scales[1].value).length() < p_allowed_precision_error) {
+			st->scales.remove_at(1);
 		}
 	}
 }
 
-void Animation::_blend_shape_track_optimize(int p_idx, real_t p_allowed_linear_err) {
+void Animation::_blend_shape_track_optimize(int p_idx, real_t p_allowed_velocity_err, real_t p_allowed_precision_error) {
 	ERR_FAIL_INDEX(p_idx, tracks.size());
 	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_BLEND_SHAPE);
-	BlendShapeTrack *tt = static_cast<BlendShapeTrack *>(tracks[p_idx]);
-	bool prev_erased = false;
-	TKey<float> first_erased;
-	first_erased.value = 0.0;
+	BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(tracks[p_idx]);
 
-	for (int i = 1; i < tt->blend_shapes.size() - 1; i++) {
-		TKey<float> &t0 = tt->blend_shapes.write[i - 1];
-		TKey<float> &t1 = tt->blend_shapes.write[i];
-		TKey<float> &t2 = tt->blend_shapes.write[i + 1];
+	int i = 0;
+	while (i < bst->blend_shapes.size() - 2) {
+		TKey<float> t0 = bst->blend_shapes[i];
+		TKey<float> t1 = bst->blend_shapes[i + 1];
+		TKey<float> t2 = bst->blend_shapes[i + 2];
 
-		bool erase = _blend_shape_track_optimize_key(t0, t1, t2, p_allowed_linear_err);
-
-		if (prev_erased && !_blend_shape_track_optimize_key(t0, first_erased, t2, p_allowed_linear_err)) {
-			//avoid error to go beyond first erased key
-			erase = false;
+		bool erase = _float_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_precision_error);
+		if (erase) {
+			bst->blend_shapes.remove_at(i + 1);
+		} else {
+			i++;
 		}
+	}
 
-		if (erase) {
-			if (!prev_erased) {
-				first_erased = t1;
-				prev_erased = true;
-			}
+	if (bst->blend_shapes.size() == 2) {
+		if (abs(bst->blend_shapes[0].value - bst->blend_shapes[1].value) < p_allowed_precision_error) {
+			bst->blend_shapes.remove_at(1);
+		}
+	}
+}
 
-			tt->blend_shapes.remove_at(i);
-			i--;
+void Animation::_value_track_optimize(int p_idx, real_t p_allowed_velocity_err, real_t p_allowed_angular_err, real_t p_allowed_precision_error) {
+	ERR_FAIL_INDEX(p_idx, tracks.size());
+	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_VALUE);
+	ValueTrack *vt = static_cast<ValueTrack *>(tracks[p_idx]);
+	if (vt->values.size() == 0) {
+		return;
+	}
+	Variant::Type type = vt->values[0].value.get_type();
+
+	// Special case for angle interpolation.
+	bool is_using_angle = vt->interpolation == Animation::INTERPOLATION_LINEAR_ANGLE || vt->interpolation == Animation::INTERPOLATION_CUBIC_ANGLE;
+	int i = 0;
+	while (i < vt->values.size() - 2) {
+		bool erase = false;
+		switch (type) {
+			case Variant::FLOAT: {
+				TKey<float> t0;
+				TKey<float> t1;
+				TKey<float> t2;
+				t0.time = vt->values[i].time;
+				t1.time = vt->values[i + 1].time;
+				t2.time = vt->values[i + 2].time;
+				t0.value = vt->values[i].value;
+				t1.value = vt->values[i + 1].value;
+				t2.value = vt->values[i + 2].value;
+				if (is_using_angle) {
+					float diff1 = fmod(t1.value - t0.value, Math_TAU);
+					t1.value = t0.value + fmod(2.0 * diff1, Math_TAU) - diff1;
+					float diff2 = fmod(t2.value - t1.value, Math_TAU);
+					t2.value = t1.value + fmod(2.0 * diff2, Math_TAU) - diff2;
+					if (abs(abs(diff1) + abs(diff2)) >= Math_PI) {
+						break; // Rotation is more than 180 deg, keep key.
+					}
+				}
+				erase = _float_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_precision_error);
+			} break;
+			case Variant::VECTOR2: {
+				TKey<Vector2> t0;
+				TKey<Vector2> t1;
+				TKey<Vector2> t2;
+				t0.time = vt->values[i].time;
+				t1.time = vt->values[i + 1].time;
+				t2.time = vt->values[i + 2].time;
+				t0.value = vt->values[i].value;
+				t1.value = vt->values[i + 1].value;
+				t2.value = vt->values[i + 2].value;
+				erase = _vector2_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_angular_err, p_allowed_precision_error);
+			} break;
+			case Variant::VECTOR3: {
+				TKey<Vector3> t0;
+				TKey<Vector3> t1;
+				TKey<Vector3> t2;
+				t0.time = vt->values[i].time;
+				t1.time = vt->values[i + 1].time;
+				t2.time = vt->values[i + 2].time;
+				t0.value = vt->values[i].value;
+				t1.value = vt->values[i + 1].value;
+				t2.value = vt->values[i + 2].value;
+				erase = _vector3_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_angular_err, p_allowed_precision_error);
+			} break;
+			case Variant::QUATERNION: {
+				TKey<Quaternion> t0;
+				TKey<Quaternion> t1;
+				TKey<Quaternion> t2;
+				t0.time = vt->values[i].time;
+				t1.time = vt->values[i + 1].time;
+				t2.time = vt->values[i + 2].time;
+				t0.value = vt->values[i].value;
+				t1.value = vt->values[i + 1].value;
+				t2.value = vt->values[i + 2].value;
+				erase = _quaternion_track_optimize_key(t0, t1, t2, p_allowed_velocity_err, p_allowed_angular_err, p_allowed_precision_error);
+			} break;
+			default: {
+			} break;
+		}
 
+		if (erase) {
+			vt->values.remove_at(i + 1);
 		} else {
-			prev_erased = false;
+			i++;
+		}
+	}
+
+	if (vt->values.size() == 2) {
+		bool single_key = false;
+		switch (type) {
+			case Variant::FLOAT: {
+				float val_0 = vt->values[0].value;
+				float val_1 = vt->values[1].value;
+				if (is_using_angle) {
+					float diff1 = fmod(val_1 - val_0, Math_TAU);
+					val_1 = val_0 + fmod(2.0 * diff1, Math_TAU) - diff1;
+				}
+				single_key = abs(val_0 - val_1) < p_allowed_precision_error;
+			} break;
+			case Variant::VECTOR2: {
+				Vector2 val_0 = vt->values[0].value;
+				Vector2 val_1 = vt->values[1].value;
+				single_key = (val_0 - val_1).length() < p_allowed_precision_error;
+			} break;
+			case Variant::VECTOR3: {
+				Vector3 val_0 = vt->values[0].value;
+				Vector3 val_1 = vt->values[1].value;
+				single_key = (val_0 - val_1).length() < p_allowed_precision_error;
+			} break;
+			case Variant::QUATERNION: {
+				Quaternion val_0 = vt->values[0].value;
+				Quaternion val_1 = vt->values[1].value;
+				single_key = (val_0 - val_1).length() < p_allowed_precision_error;
+			} break;
+			default: {
+			} break;
+		}
+		if (single_key) {
+			vt->values.remove_at(1);
 		}
 	}
 }
 
-void Animation::optimize(real_t p_allowed_linear_err, real_t p_allowed_angular_err, real_t p_max_optimizable_angle) {
+void Animation::optimize(real_t p_allowed_velocity_err, real_t p_allowed_angular_err, int p_precision) {
+	real_t precision = Math::pow(0.1, p_precision);
 	for (int i = 0; i < tracks.size(); i++) {
 		if (track_is_compressed(i)) {
 			continue; //not possible to optimize compressed track
 		}
 		if (tracks[i]->type == TYPE_POSITION_3D) {
-			_position_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err);
+			_position_track_optimize(i, p_allowed_velocity_err, p_allowed_angular_err, precision);
 		} else if (tracks[i]->type == TYPE_ROTATION_3D) {
-			_rotation_track_optimize(i, p_allowed_angular_err, p_max_optimizable_angle);
+			_rotation_track_optimize(i, p_allowed_velocity_err, p_allowed_angular_err, precision);
 		} else if (tracks[i]->type == TYPE_SCALE_3D) {
-			_scale_track_optimize(i, p_allowed_linear_err);
+			_scale_track_optimize(i, p_allowed_velocity_err, p_allowed_angular_err, precision);
 		} else if (tracks[i]->type == TYPE_BLEND_SHAPE) {
-			_blend_shape_track_optimize(i, p_allowed_linear_err);
+			_blend_shape_track_optimize(i, p_allowed_velocity_err, precision);
+		} else if (tracks[i]->type == TYPE_VALUE) {
+			_value_track_optimize(i, p_allowed_velocity_err, p_allowed_angular_err, precision);
 		}
 	}
 }