Style: clang-format: Disable KeepEmptyLinesAtTheStartOfBlocks

Which means that reduz' beloved style which we all became used to
will now be changed automatically to remove the first empty line.

This makes us lean closer to 1TBS (the one true brace style) instead
of hybridating it with some Allman-inspired spacing.

There's still the case of braces around single-statement blocks that
needs to be addressed (but clang-format can't help with that, but
clang-tidy may if we agree about it).

Part of #33027.

1 files changed, 0 insertions, 278 deletions

diff --git a/scene/resources/animation.cpp b/scene/resources/animation.cpp
index c5806ee7b3..44aa3f8319 100644
--- a/scene/resources/animation.cpp
+++ b/scene/resources/animation.cpp
@@ -36,38 +36,28 @@
 #define ANIM_MIN_LENGTH 0.001
 
 bool Animation::_set(const StringName &p_name, const Variant &p_value) {
-
 	String name = p_name;
 
 	if (name.begins_with("tracks/")) {
-
 		int track = name.get_slicec('/', 1).to_int();
 		String what = name.get_slicec('/', 2);
 
 		if (tracks.size() == track && what == "type") {
-
 			String type = p_value;
 
 			if (type == "transform") {
-
 				add_track(TYPE_TRANSFORM);
 			} else if (type == "value") {
-
 				add_track(TYPE_VALUE);
 			} else if (type == "method") {
-
 				add_track(TYPE_METHOD);
 			} else if (type == "bezier") {
-
 				add_track(TYPE_BEZIER);
 			} else if (type == "audio") {
-
 				add_track(TYPE_AUDIO);
 			} else if (type == "animation") {
-
 				add_track(TYPE_ANIMATION);
 			} else {
-
 				return false;
 			}
 
@@ -87,9 +77,7 @@ 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_TRANSFORM) {
-
 				TransformTrack *tt = static_cast<TransformTrack *>(tracks[track]);
 				Vector<float> values = p_value;
 				int vcount = values.size();
@@ -100,7 +88,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				tt->transforms.resize(vcount / 12);
 
 				for (int i = 0; i < (vcount / 12); i++) {
-
 					TKey<TransformKey> &tk = tt->transforms.write[i];
 					const float *ofs = &r[i * 12];
 					tk.time = ofs[0];
@@ -121,7 +108,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				}
 
 			} else if (track_get_type(track) == TYPE_VALUE) {
-
 				ValueTrack *vt = static_cast<ValueTrack *>(tracks[track]);
 				Dictionary d = p_value;
 				ERR_FAIL_COND_V(!d.has("times"), false);
@@ -146,7 +132,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				ERR_FAIL_COND_V(times.size() != values.size(), false);
 
 				if (times.size()) {
-
 					int valcount = times.size();
 
 					const float *rt = times.ptr();
@@ -154,20 +139,17 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 					vt->values.resize(valcount);
 
 					for (int i = 0; i < valcount; i++) {
-
 						vt->values.write[i].time = rt[i];
 						vt->values.write[i].value = values[i];
 					}
 
 					if (d.has("transitions")) {
-
 						Vector<float> transitions = d["transitions"];
 						ERR_FAIL_COND_V(transitions.size() != valcount, false);
 
 						const float *rtr = transitions.ptr();
 
 						for (int i = 0; i < valcount; i++) {
-
 							vt->values.write[i].transition = rtr[i];
 						}
 					}
@@ -176,7 +158,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				return true;
 
 			} else if (track_get_type(track) == TYPE_METHOD) {
-
 				while (track_get_key_count(track))
 					track_remove_key(track, 0); //well shouldn't be set anyway
 
@@ -190,31 +171,26 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				ERR_FAIL_COND_V(times.size() != values.size(), false);
 
 				if (times.size()) {
-
 					int valcount = times.size();
 
 					const float *rt = times.ptr();
 
 					for (int i = 0; i < valcount; i++) {
-
 						track_insert_key(track, rt[i], values[i]);
 					}
 
 					if (d.has("transitions")) {
-
 						Vector<float> transitions = d["transitions"];
 						ERR_FAIL_COND_V(transitions.size() != valcount, false);
 
 						const float *rtr = transitions.ptr();
 
 						for (int i = 0; i < valcount; i++) {
-
 							track_set_key_transition(track, i, rtr[i]);
 						}
 					}
 				}
 			} else if (track_get_type(track) == TYPE_BEZIER) {
-
 				BezierTrack *bt = static_cast<BezierTrack *>(tracks[track]);
 				Dictionary d = p_value;
 				ERR_FAIL_COND_V(!d.has("times"), false);
@@ -226,7 +202,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				ERR_FAIL_COND_V(times.size() * 5 != values.size(), false);
 
 				if (times.size()) {
-
 					int valcount = times.size();
 
 					const float *rt = times.ptr();
@@ -235,7 +210,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 					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 * 5 + 0];
@@ -248,7 +222,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 
 				return true;
 			} else if (track_get_type(track) == TYPE_AUDIO) {
-
 				AudioTrack *ad = static_cast<AudioTrack *>(tracks[track]);
 				Dictionary d = p_value;
 				ERR_FAIL_COND_V(!d.has("times"), false);
@@ -260,7 +233,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				ERR_FAIL_COND_V(clips.size() != times.size(), false);
 
 				if (times.size()) {
-
 					int valcount = times.size();
 
 					const float *rt = times.ptr();
@@ -268,7 +240,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 					ad->values.clear();
 
 					for (int i = 0; i < valcount; i++) {
-
 						Dictionary d2 = clips[i];
 						if (!d2.has("start_offset"))
 							continue;
@@ -289,7 +260,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 
 				return true;
 			} else if (track_get_type(track) == TYPE_ANIMATION) {
-
 				AnimationTrack *an = static_cast<AnimationTrack *>(tracks[track]);
 				Dictionary d = p_value;
 				ERR_FAIL_COND_V(!d.has("times"), false);
@@ -301,7 +271,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				ERR_FAIL_COND_V(clips.size() != times.size(), false);
 
 				if (times.size()) {
-
 					int valcount = times.size();
 
 					const float *rt = times.ptr();
@@ -310,7 +279,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 					an->values.resize(valcount);
 
 					for (int i = 0; i < valcount; i++) {
-
 						TKey<StringName> ak;
 						ak.time = rt[i];
 						ak.value = rc[i];
@@ -331,7 +299,6 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 }
 
 bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
-
 	String name = p_name;
 
 	if (name == "length")
@@ -341,14 +308,11 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 	else if (name == "step")
 		r_ret = step;
 	else if (name.begins_with("tracks/")) {
-
 		int track = name.get_slicec('/', 1).to_int();
 		String what = name.get_slicec('/', 2);
 		ERR_FAIL_INDEX_V(track, tracks.size(), false);
 		if (what == "type") {
-
 			switch (track_get_type(track)) {
-
 				case TYPE_TRANSFORM:
 					r_ret = "transform";
 					break;
@@ -382,9 +346,7 @@ 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_TRANSFORM) {
-
 				Vector<float> keys;
 				int kk = track_get_key_count(track);
 				keys.resize(kk * 12);
@@ -393,7 +355,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 				int idx = 0;
 				for (int i = 0; i < track_get_key_count(track); i++) {
-
 					Vector3 loc;
 					Quat rot;
 					Vector3 scale;
@@ -419,7 +380,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				return true;
 
 			} else if (track_get_type(track) == TYPE_VALUE) {
-
 				const ValueTrack *vt = static_cast<const ValueTrack *>(tracks[track]);
 
 				Dictionary d;
@@ -442,7 +402,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				const TKey<Variant> *vls = vt->values.ptr();
 
 				for (int i = 0; i < kk; i++) {
-
 					wti[idx] = vls[i].time;
 					wtr[idx] = vls[i].transition;
 					key_values[idx] = vls[i].value;
@@ -461,7 +420,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				return true;
 
 			} else if (track_get_type(track) == TYPE_METHOD) {
-
 				Dictionary d;
 
 				Vector<float> key_times;
@@ -479,7 +437,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 				int idx = 0;
 				for (int i = 0; i < track_get_key_count(track); i++) {
-
 					wti[idx] = track_get_key_time(track, i);
 					wtr[idx] = track_get_key_transition(track, i);
 					key_values[idx] = track_get_key_value(track, i);
@@ -497,7 +454,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 				return true;
 			} else if (track_get_type(track) == TYPE_BEZIER) {
-
 				const BezierTrack *bt = static_cast<const BezierTrack *>(tracks[track]);
 
 				Dictionary d;
@@ -518,7 +474,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				const TKey<BezierKey> *vls = bt->values.ptr();
 
 				for (int i = 0; i < kk; i++) {
-
 					wti[idx] = vls[i].time;
 					wpo[idx * 5 + 0] = vls[i].value.value;
 					wpo[idx * 5 + 1] = vls[i].value.in_handle.x;
@@ -535,7 +490,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 				return true;
 			} else if (track_get_type(track) == TYPE_AUDIO) {
-
 				const AudioTrack *ad = static_cast<const AudioTrack *>(tracks[track]);
 
 				Dictionary d;
@@ -554,7 +508,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				const TKey<AudioKey> *vls = ad->values.ptr();
 
 				for (int i = 0; i < kk; i++) {
-
 					wti[idx] = vls[i].time;
 					Dictionary clip;
 					clip["start_offset"] = vls[i].value.start_offset;
@@ -571,7 +524,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 				return true;
 			} else if (track_get_type(track) == TYPE_ANIMATION) {
-
 				const AnimationTrack *an = static_cast<const AnimationTrack *>(tracks[track]);
 
 				Dictionary d;
@@ -590,7 +542,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				const TKey<StringName> *vls = an->values.ptr();
 
 				for (int i = 0; i < kk; i++) {
-
 					wti[i] = vls[i].time;
 					wcl[i] = vls[i].value;
 				}
@@ -612,7 +563,6 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 void Animation::_get_property_list(List<PropertyInfo> *p_list) const {
 	for (int i = 0; i < tracks.size(); i++) {
-
 		p_list->push_back(PropertyInfo(Variant::STRING, "tracks/" + itos(i) + "/type", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
 		p_list->push_back(PropertyInfo(Variant::NODE_PATH, "tracks/" + itos(i) + "/path", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
 		p_list->push_back(PropertyInfo(Variant::INT, "tracks/" + itos(i) + "/interp", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
@@ -624,44 +574,35 @@ void Animation::_get_property_list(List<PropertyInfo> *p_list) const {
 }
 
 int Animation::add_track(TrackType p_type, int p_at_pos) {
-
 	if (p_at_pos < 0 || p_at_pos >= tracks.size())
 		p_at_pos = tracks.size();
 
 	switch (p_type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = memnew(TransformTrack);
 			tracks.insert(p_at_pos, tt);
 		} break;
 		case TYPE_VALUE: {
-
 			tracks.insert(p_at_pos, memnew(ValueTrack));
 
 		} break;
 		case TYPE_METHOD: {
-
 			tracks.insert(p_at_pos, memnew(MethodTrack));
 
 		} break;
 		case TYPE_BEZIER: {
-
 			tracks.insert(p_at_pos, memnew(BezierTrack));
 
 		} break;
 		case TYPE_AUDIO: {
-
 			tracks.insert(p_at_pos, memnew(AudioTrack));
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			tracks.insert(p_at_pos, memnew(AnimationTrack));
 
 		} break;
 		default: {
-
 			ERR_PRINT("Unknown track type");
 		}
 	}
@@ -671,44 +612,36 @@ int Animation::add_track(TrackType p_type, int p_at_pos) {
 }
 
 void Animation::remove_track(int p_track) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			_clear(tt->transforms);
 
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			_clear(vt->values);
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			_clear(mt->methods);
 
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bz = static_cast<BezierTrack *>(t);
 			_clear(bz->values);
 
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *ad = static_cast<AudioTrack *>(t);
 			_clear(ad->values);
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *an = static_cast<AnimationTrack *>(t);
 			_clear(an->values);
 
@@ -722,18 +655,15 @@ void Animation::remove_track(int p_track) {
 }
 
 int Animation::get_track_count() const {
-
 	return tracks.size();
 }
 
 Animation::TrackType Animation::track_get_type(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), TYPE_TRANSFORM);
 	return tracks[p_track]->type;
 }
 
 void Animation::track_set_path(int p_track, const NodePath &p_path) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	tracks[p_track]->path = p_path;
 	emit_changed();
@@ -741,15 +671,12 @@ void Animation::track_set_path(int p_track, const NodePath &p_path) {
 }
 
 NodePath Animation::track_get_path(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), NodePath());
 	return tracks[p_track]->path;
 }
 
 int Animation::find_track(const NodePath &p_path) const {
-
 	for (int i = 0; i < tracks.size(); i++) {
-
 		if (tracks[i]->path == p_path)
 			return i;
 	};
@@ -757,7 +684,6 @@ int Animation::find_track(const NodePath &p_path) 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;
@@ -765,7 +691,6 @@ void Animation::track_set_interpolation_type(int p_track, InterpolationType p_in
 }
 
 Animation::InterpolationType Animation::track_get_interpolation_type(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), INTERPOLATION_NEAREST);
 	return tracks[p_track]->interpolation;
 }
@@ -777,7 +702,6 @@ void Animation::track_set_interpolation_loop_wrap(int p_track, bool p_enable) {
 }
 
 bool Animation::track_get_interpolation_loop_wrap(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), INTERPOLATION_NEAREST);
 	return tracks[p_track]->loop_wrap;
 }
@@ -811,20 +735,16 @@ int Animation::_insert_pos(float p_time, T& p_keys) {
 */
 template <class T, class V>
 int Animation::_insert(float p_time, T &p_keys, const V &p_value) {
-
 	int idx = p_keys.size();
 
 	while (true) {
-
 		// Condition for replacement.
 		if (idx > 0 && Math::is_equal_approx(p_keys[idx - 1].time, p_time)) {
-
 			p_keys.write[idx - 1] = p_value;
 			return idx - 1;
 
 			// Condition for insert.
 		} else if (idx == 0 || p_keys[idx - 1].time < p_time) {
-
 			p_keys.insert(idx, p_value);
 			return idx;
 		}
@@ -837,12 +757,10 @@ int Animation::_insert(float p_time, T &p_keys, const V &p_value) {
 
 template <class T>
 void Animation::_clear(T &p_keys) {
-
 	p_keys.clear();
 }
 
 Error Animation::transform_track_get_key(int p_track, int p_key, Vector3 *r_loc, Quat *r_rot, Vector3 *r_scale) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
 	Track *t = tracks[p_track];
 
@@ -861,7 +779,6 @@ Error Animation::transform_track_get_key(int p_track, int p_key, Vector3 *r_loc,
 }
 
 int Animation::transform_track_insert_key(int p_track, float p_time, const Vector3 &p_loc, const Quat &p_rot, 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_TRANSFORM, -1);
@@ -880,55 +797,47 @@ int Animation::transform_track_insert_key(int p_track, float p_time, const Vecto
 }
 
 void Animation::track_remove_key_at_position(int p_track, float p_pos) {
-
 	int idx = track_find_key(p_track, p_pos, true);
 	ERR_FAIL_COND(idx < 0);
 	track_remove_key(p_track, idx);
 }
 
 void Animation::track_remove_key(int p_track, int p_idx) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			ERR_FAIL_INDEX(p_idx, tt->transforms.size());
 			tt->transforms.remove(p_idx);
 
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_idx, vt->values.size());
 			vt->values.remove(p_idx);
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			ERR_FAIL_INDEX(p_idx, mt->methods.size());
 			mt->methods.remove(p_idx);
 
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bz = static_cast<BezierTrack *>(t);
 			ERR_FAIL_INDEX(p_idx, bz->values.size());
 			bz->values.remove(p_idx);
 
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *ad = static_cast<AudioTrack *>(t);
 			ERR_FAIL_INDEX(p_idx, ad->values.size());
 			ad->values.remove(p_idx);
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *an = static_cast<AnimationTrack *>(t);
 			ERR_FAIL_INDEX(p_idx, an->values.size());
 			an->values.remove(p_idx);
@@ -940,13 +849,11 @@ void Animation::track_remove_key(int p_track, int p_idx) {
 }
 
 int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			int k = _find(tt->transforms, p_time);
 			if (k < 0 || k >= tt->transforms.size())
@@ -957,7 +864,6 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
 
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			int k = _find(vt->values, p_time);
 			if (k < 0 || k >= vt->values.size())
@@ -968,7 +874,6 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			int k = _find(mt->methods, p_time);
 			if (k < 0 || k >= mt->methods.size())
@@ -979,7 +884,6 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
 
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 			int k = _find(bt->values, p_time);
 			if (k < 0 || k >= bt->values.size())
@@ -990,7 +894,6 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
 
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *at = static_cast<AudioTrack *>(t);
 			int k = _find(at->values, p_time);
 			if (k < 0 || k >= at->values.size())
@@ -1001,7 +904,6 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *at = static_cast<AnimationTrack *>(t);
 			int k = _find(at->values, p_time);
 			if (k < 0 || k >= at->values.size())
@@ -1017,14 +919,11 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
 }
 
 void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key, float p_transition) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			Dictionary d = p_key;
 			Vector3 loc;
 			if (d.has("location"))
@@ -1043,7 +942,6 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key
 
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 
 			TKey<Variant> k;
@@ -1054,7 +952,6 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 
 			ERR_FAIL_COND(p_key.get_type() != Variant::DICTIONARY);
@@ -1074,7 +971,6 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key
 
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 
 			Array arr = p_key;
@@ -1091,7 +987,6 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key
 
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *at = static_cast<AudioTrack *>(t);
 
 			Dictionary k = p_key;
@@ -1108,7 +1003,6 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *at = static_cast<AnimationTrack *>(t);
 
 			TKey<StringName> ak;
@@ -1124,40 +1018,32 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key
 }
 
 int Animation::track_get_key_count(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			return tt->transforms.size();
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			return vt->values.size();
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			return mt->methods.size();
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 			return bt->values.size();
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *at = static_cast<AudioTrack *>(t);
 			return at->values.size();
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *at = static_cast<AnimationTrack *>(t);
 			return at->values.size();
 		} break;
@@ -1167,14 +1053,11 @@ int Animation::track_get_key_count(int p_track) const {
 }
 
 Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), Variant());
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), Variant());
 
@@ -1186,14 +1069,12 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 			return d;
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), Variant());
 			return vt->values[p_key_idx].value;
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), Variant());
 			Dictionary d;
@@ -1203,7 +1084,6 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, bt->values.size(), Variant());
 
@@ -1218,7 +1098,6 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *at = static_cast<AudioTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), Variant());
 
@@ -1230,7 +1109,6 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *at = static_cast<AnimationTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), Variant());
 
@@ -1243,48 +1121,40 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 }
 
 float Animation::track_get_key_time(int p_track, int p_key_idx) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1);
 			return tt->transforms[p_key_idx].time;
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1);
 			return vt->values[p_key_idx].time;
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), -1);
 			return mt->methods[p_key_idx].time;
 
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, bt->values.size(), -1);
 			return bt->values[p_key_idx].time;
 
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *at = static_cast<AudioTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), -1);
 			return at->values[p_key_idx].time;
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *at = static_cast<AnimationTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), -1);
 			return at->values[p_key_idx].time;
@@ -1296,14 +1166,11 @@ float Animation::track_get_key_time(int p_track, int p_key_idx) const {
 }
 
 void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
 			TKey<TransformKey> key = tt->transforms[p_key_idx];
@@ -1313,7 +1180,6 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
 			return;
 		}
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, vt->values.size());
 			TKey<Variant> key = vt->values[p_key_idx];
@@ -1323,7 +1189,6 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
 			return;
 		}
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, mt->methods.size());
 			MethodKey key = mt->methods[p_key_idx];
@@ -1333,7 +1198,6 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
 			return;
 		}
 		case TYPE_BEZIER: {
-
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, bt->values.size());
 			TKey<BezierKey> key = bt->values[p_key_idx];
@@ -1343,7 +1207,6 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
 			return;
 		}
 		case TYPE_AUDIO: {
-
 			AudioTrack *at = static_cast<AudioTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, at->values.size());
 			TKey<AudioKey> key = at->values[p_key_idx];
@@ -1353,7 +1216,6 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
 			return;
 		}
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *at = static_cast<AnimationTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, at->values.size());
 			TKey<StringName> key = at->values[p_key_idx];
@@ -1368,42 +1230,34 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
 }
 
 float Animation::track_get_key_transition(int p_track, int p_key_idx) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1);
 			return tt->transforms[p_key_idx].transition;
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1);
 			return vt->values[p_key_idx].transition;
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), -1);
 			return mt->methods[p_key_idx].transition;
 
 		} break;
 		case TYPE_BEZIER: {
-
 			return 1; //bezier does not really use transitions
 		} break;
 		case TYPE_AUDIO: {
-
 			return 1; //audio does not really use transitions
 		} break;
 		case TYPE_ANIMATION: {
-
 			return 1; //animation does not really use transitions
 		} break;
 	}
@@ -1412,14 +1266,11 @@ float Animation::track_get_key_transition(int p_track, int p_key_idx) const {
 }
 
 void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p_value) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
 
@@ -1434,7 +1285,6 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, vt->values.size());
 
@@ -1442,7 +1292,6 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, mt->methods.size());
 
@@ -1455,7 +1304,6 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 
 		} break;
 		case TYPE_BEZIER: {
-
 			BezierTrack *bt = static_cast<BezierTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, bt->values.size());
 
@@ -1470,7 +1318,6 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 
 		} break;
 		case TYPE_AUDIO: {
-
 			AudioTrack *at = static_cast<AudioTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, at->values.size());
 
@@ -1485,7 +1332,6 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			AnimationTrack *at = static_cast<AnimationTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, at->values.size());
 
@@ -1498,27 +1344,22 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 }
 
 void Animation::track_set_key_transition(int p_track, int p_key_idx, float p_transition) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			TransformTrack *tt = static_cast<TransformTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
 			tt->transforms.write[p_key_idx].transition = p_transition;
 		} break;
 		case TYPE_VALUE: {
-
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, vt->values.size());
 			vt->values.write[p_key_idx].transition = p_transition;
 
 		} break;
 		case TYPE_METHOD: {
-
 			MethodTrack *mt = static_cast<MethodTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, mt->methods.size());
 			mt->methods.write[p_key_idx].transition = p_transition;
@@ -1536,7 +1377,6 @@ void Animation::track_set_key_transition(int p_track, int p_key_idx, float p_tra
 
 template <class K>
 int Animation::_find(const Vector<K> &p_keys, float p_time) const {
-
 	int len = p_keys.size();
 	if (len == 0)
 		return -2;
@@ -1553,7 +1393,6 @@ int Animation::_find(const Vector<K> &p_keys, float p_time) const {
 	const K *keys = &p_keys[0];
 
 	while (low <= high) {
-
 		middle = (low + high) / 2;
 
 		if (Math::is_equal_approx(p_time, keys[middle].time)) { //match
@@ -1571,7 +1410,6 @@ int Animation::_find(const Vector<K> &p_keys, float p_time) const {
 }
 
 Animation::TransformKey Animation::_interpolate(const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, float 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);
@@ -1581,27 +1419,22 @@ Animation::TransformKey Animation::_interpolate(const Animation::TransformKey &p
 }
 
 Vector3 Animation::_interpolate(const Vector3 &p_a, const Vector3 &p_b, float p_c) const {
-
 	return p_a.lerp(p_b, p_c);
 }
 Quat Animation::_interpolate(const Quat &p_a, const Quat &p_b, float p_c) const {
-
 	return p_a.slerp(p_b, p_c);
 }
 Variant Animation::_interpolate(const Variant &p_a, const Variant &p_b, float p_c) const {
-
 	Variant dst;
 	Variant::interpolate(p_a, p_b, p_c, dst);
 	return dst;
 }
 
 float Animation::_interpolate(const float &p_a, const float &p_b, float p_c) const {
-
 	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, float 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);
@@ -1611,15 +1444,12 @@ Animation::TransformKey Animation::_cubic_interpolate(const Animation::Transform
 	return tk;
 }
 Vector3 Animation::_cubic_interpolate(const Vector3 &p_pre_a, const Vector3 &p_a, const Vector3 &p_b, const Vector3 &p_post_b, float p_c) const {
-
 	return p_a.cubic_interpolate(p_b, p_pre_a, p_post_b, p_c);
 }
 Quat Animation::_cubic_interpolate(const Quat &p_pre_a, const Quat &p_a, const Quat &p_b, const Quat &p_post_b, float p_c) const {
-
 	return p_a.cubic_slerp(p_b, p_pre_a, p_post_b, p_c);
 }
 Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a, const Variant &p_b, const Variant &p_post_b, float p_c) 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();
@@ -1650,14 +1480,11 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 							  (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);
 
 	} else if ((vformat & (vformat - 1))) {
-
 		return p_a; //can't interpolate, mix of types
 	}
 
 	switch (type_a) {
-
 		case Variant::VECTOR2: {
-
 			Vector2 a = p_a;
 			Vector2 b = p_b;
 			Vector2 pa = p_pre_a;
@@ -1666,7 +1493,6 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			return a.cubic_interpolate(b, pa, pb, p_c);
 		}
 		case Variant::RECT2: {
-
 			Rect2 a = p_a;
 			Rect2 b = p_b;
 			Rect2 pa = p_pre_a;
@@ -1677,7 +1503,6 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 					a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c));
 		}
 		case Variant::VECTOR3: {
-
 			Vector3 a = p_a;
 			Vector3 b = p_b;
 			Vector3 pa = p_pre_a;
@@ -1686,7 +1511,6 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			return a.cubic_interpolate(b, pa, pb, p_c);
 		}
 		case Variant::QUAT: {
-
 			Quat a = p_a;
 			Quat b = p_b;
 			Quat pa = p_pre_a;
@@ -1695,7 +1519,6 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			return a.cubic_slerp(b, pa, pb, p_c);
 		}
 		case Variant::AABB: {
-
 			AABB a = p_a;
 			AABB b = p_b;
 			AABB pa = p_pre_a;
@@ -1706,19 +1529,16 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 					a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c));
 		}
 		default: {
-
 			return _interpolate(p_a, p_b, p_c);
 		}
 	}
 }
 float Animation::_cubic_interpolate(const float &p_pre_a, const float &p_a, const float &p_b, const float &p_post_b, float p_c) const {
-
 	return _interpolate(p_a, p_b, p_c);
 }
 
 template <class T>
 T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, InterpolationType p_interp, bool p_loop_wrap, bool *p_ok) const {
-
 	int len = _find(p_keys, length) + 1; // try to find last key (there may be more past the end)
 
 	if (len <= 0) {
@@ -1746,9 +1566,7 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, Interpola
 	if (loop && p_loop_wrap) {
 		// loop
 		if (idx >= 0) {
-
 			if ((idx + 1) < len) {
-
 				next = idx + 1;
 				float delta = p_keys[next].time - p_keys[idx].time;
 				float from = p_time - p_keys[idx].time;
@@ -1759,7 +1577,6 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, Interpola
 					c = from / delta;
 
 			} else {
-
 				next = 0;
 				float delta = (length - p_keys[idx].time) + p_keys[next].time;
 				float from = p_time - p_keys[idx].time;
@@ -1789,9 +1606,7 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, Interpola
 	} else { // no loop
 
 		if (idx >= 0) {
-
 			if ((idx + 1) < len) {
-
 				next = idx + 1;
 				float delta = p_keys[next].time - p_keys[idx].time;
 				float from = p_time - p_keys[idx].time;
@@ -1802,12 +1617,10 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, Interpola
 					c = from / delta;
 
 			} else {
-
 				next = idx;
 			}
 
 		} else {
-
 			// only allow extending first key to anim start if looping
 			if (loop)
 				idx = next = 0;
@@ -1829,18 +1642,14 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, Interpola
 	}
 
 	if (tr != 1.0) {
-
 		c = Math::ease(c, tr);
 	}
 
 	switch (p_interp) {
-
 		case INTERPOLATION_NEAREST: {
-
 			return p_keys[idx].value;
 		} break;
 		case INTERPOLATION_LINEAR: {
-
 			return _interpolate(p_keys[idx].value, p_keys[next].value, c);
 		} break;
 		case INTERPOLATION_CUBIC: {
@@ -1862,7 +1671,6 @@ T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, Interpola
 }
 
 Error Animation::transform_track_interpolate(int p_track, float p_time, Vector3 *r_loc, Quat *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_TRANSFORM, ERR_INVALID_PARAMETER);
@@ -1889,7 +1697,6 @@ Error Animation::transform_track_interpolate(int p_track, float p_time, Vector3
 }
 
 Variant Animation::value_track_interpolate(int p_track, float p_time) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_VALUE, Variant());
@@ -1900,7 +1707,6 @@ Variant Animation::value_track_interpolate(int p_track, float p_time) const {
 	Variant res = _interpolate(vt->values, p_time, (vt->update_mode == UPDATE_CONTINUOUS || vt->update_mode == UPDATE_CAPTURE) ? vt->interpolation : INTERPOLATION_NEAREST, vt->loop_wrap, &ok);
 
 	if (ok) {
-
 		return res;
 	}
 
@@ -1908,7 +1714,6 @@ Variant Animation::value_track_interpolate(int p_track, float p_time) const {
 }
 
 void Animation::_value_track_get_key_indices_in_range(const ValueTrack *vt, float from_time, float to_time, List<int> *p_indices) const {
-
 	if (from_time != length && to_time == length)
 		to_time = length * 1.001; //include a little more if at the end
 	int to = _find(vt->values, to_time);
@@ -1936,14 +1741,12 @@ void Animation::_value_track_get_key_indices_in_range(const ValueTrack *vt, floa
 	int max = vt->values.size();
 
 	for (int i = from; i <= to; i++) {
-
 		ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen
 		p_indices->push_back(i);
 	}
 }
 
 void Animation::value_track_get_key_indices(int p_track, float p_time, float p_delta, List<int> *p_indices) const {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_VALUE);
@@ -1957,7 +1760,6 @@ void Animation::value_track_get_key_indices(int p_track, float p_time, float p_d
 		SWAP(from_time, to_time);
 
 	if (loop) {
-
 		from_time = Math::fposmod(from_time, length);
 		to_time = Math::fposmod(to_time, length);
 
@@ -1968,7 +1770,6 @@ void Animation::value_track_get_key_indices(int p_track, float p_time, float p_d
 			return;
 		}
 	} else {
-
 		if (from_time < 0)
 			from_time = 0;
 		if (from_time > length)
@@ -1984,7 +1785,6 @@ void Animation::value_track_get_key_indices(int p_track, float p_time, float p_d
 }
 
 void Animation::value_track_set_update_mode(int p_track, UpdateMode p_mode) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_VALUE);
@@ -1995,7 +1795,6 @@ void Animation::value_track_set_update_mode(int p_track, UpdateMode p_mode) {
 }
 
 Animation::UpdateMode Animation::value_track_get_update_mode(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), UPDATE_CONTINUOUS);
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_VALUE, UPDATE_CONTINUOUS);
@@ -2006,7 +1805,6 @@ Animation::UpdateMode Animation::value_track_get_update_mode(int p_track) const
 
 template <class T>
 void Animation::_track_get_key_indices_in_range(const Vector<T> &p_array, float from_time, float to_time, List<int> *p_indices) const {
-
 	if (from_time != length && to_time == length)
 		to_time = length * 1.01; //include a little more if at the end
 
@@ -2030,14 +1828,12 @@ void Animation::_track_get_key_indices_in_range(const Vector<T> &p_array, float
 	int max = p_array.size();
 
 	for (int i = from; i <= to; i++) {
-
 		ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen
 		p_indices->push_back(i);
 	}
 }
 
 void Animation::track_get_key_indices_in_range(int p_track, float p_time, float p_delta, List<int> *p_indices) const {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	const Track *t = tracks[p_track];
 
@@ -2048,7 +1844,6 @@ void Animation::track_get_key_indices_in_range(int p_track, float p_time, float
 		SWAP(from_time, to_time);
 
 	if (loop) {
-
 		if (from_time > length || from_time < 0)
 			from_time = Math::fposmod(from_time, length);
 
@@ -2059,44 +1854,37 @@ void Animation::track_get_key_indices_in_range(int p_track, float p_time, float
 			// handle loop by splitting
 
 			switch (t->type) {
-
 				case TYPE_TRANSFORM: {
-
 					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);
 
 				} break;
 				case TYPE_VALUE: {
-
 					const ValueTrack *vt = static_cast<const ValueTrack *>(t);
 					_track_get_key_indices_in_range(vt->values, from_time, length, p_indices);
 					_track_get_key_indices_in_range(vt->values, 0, to_time, p_indices);
 
 				} break;
 				case TYPE_METHOD: {
-
 					const MethodTrack *mt = static_cast<const MethodTrack *>(t);
 					_track_get_key_indices_in_range(mt->methods, from_time, length, p_indices);
 					_track_get_key_indices_in_range(mt->methods, 0, to_time, p_indices);
 
 				} break;
 				case TYPE_BEZIER: {
-
 					const BezierTrack *bz = static_cast<const BezierTrack *>(t);
 					_track_get_key_indices_in_range(bz->values, from_time, length, p_indices);
 					_track_get_key_indices_in_range(bz->values, 0, to_time, p_indices);
 
 				} break;
 				case TYPE_AUDIO: {
-
 					const AudioTrack *ad = static_cast<const AudioTrack *>(t);
 					_track_get_key_indices_in_range(ad->values, from_time, length, p_indices);
 					_track_get_key_indices_in_range(ad->values, 0, to_time, p_indices);
 
 				} break;
 				case TYPE_ANIMATION: {
-
 					const AnimationTrack *an = static_cast<const AnimationTrack *>(t);
 					_track_get_key_indices_in_range(an->values, from_time, length, p_indices);
 					_track_get_key_indices_in_range(an->values, 0, to_time, p_indices);
@@ -2106,7 +1894,6 @@ void Animation::track_get_key_indices_in_range(int p_track, float p_time, float
 			return;
 		}
 	} else {
-
 		if (from_time < 0)
 			from_time = 0;
 		if (from_time > length)
@@ -2119,39 +1906,32 @@ void Animation::track_get_key_indices_in_range(int p_track, float p_time, float
 	}
 
 	switch (t->type) {
-
 		case TYPE_TRANSFORM: {
-
 			const TransformTrack *tt = static_cast<const TransformTrack *>(t);
 			_track_get_key_indices_in_range(tt->transforms, from_time, to_time, p_indices);
 
 		} break;
 		case TYPE_VALUE: {
-
 			const ValueTrack *vt = static_cast<const ValueTrack *>(t);
 			_track_get_key_indices_in_range(vt->values, from_time, to_time, p_indices);
 
 		} break;
 		case TYPE_METHOD: {
-
 			const MethodTrack *mt = static_cast<const MethodTrack *>(t);
 			_track_get_key_indices_in_range(mt->methods, from_time, to_time, p_indices);
 
 		} break;
 		case TYPE_BEZIER: {
-
 			const BezierTrack *bz = static_cast<const BezierTrack *>(t);
 			_track_get_key_indices_in_range(bz->values, from_time, to_time, p_indices);
 
 		} break;
 		case TYPE_AUDIO: {
-
 			const AudioTrack *ad = static_cast<const AudioTrack *>(t);
 			_track_get_key_indices_in_range(ad->values, from_time, to_time, p_indices);
 
 		} break;
 		case TYPE_ANIMATION: {
-
 			const AnimationTrack *an = static_cast<const AnimationTrack *>(t);
 			_track_get_key_indices_in_range(an->values, from_time, to_time, p_indices);
 
@@ -2160,7 +1940,6 @@ void Animation::track_get_key_indices_in_range(int p_track, float p_time, float
 }
 
 void Animation::_method_track_get_key_indices_in_range(const MethodTrack *mt, float from_time, float to_time, List<int> *p_indices) const {
-
 	if (from_time != length && to_time == length)
 		to_time = length * 1.01; //include a little more if at the end
 
@@ -2184,14 +1963,12 @@ void Animation::_method_track_get_key_indices_in_range(const MethodTrack *mt, fl
 	int max = mt->methods.size();
 
 	for (int i = from; i <= to; i++) {
-
 		ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen
 		p_indices->push_back(i);
 	}
 }
 
 void Animation::method_track_get_key_indices(int p_track, float p_time, float p_delta, List<int> *p_indices) const {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_METHOD);
@@ -2205,7 +1982,6 @@ void Animation::method_track_get_key_indices(int p_track, float p_time, float p_
 		SWAP(from_time, to_time);
 
 	if (loop) {
-
 		if (from_time > length || from_time < 0)
 			from_time = Math::fposmod(from_time, length);
 
@@ -2219,7 +1995,6 @@ void Animation::method_track_get_key_indices(int p_track, float p_time, float p_
 			return;
 		}
 	} else {
-
 		if (from_time < 0)
 			from_time = 0;
 		if (from_time > length)
@@ -2234,7 +2009,6 @@ void Animation::method_track_get_key_indices(int p_track, float p_time, float p_
 	_method_track_get_key_indices_in_range(mt, from_time, to_time, p_indices);
 }
 Vector<Variant> Animation::method_track_get_params(int p_track, int p_key_idx) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), Vector<Variant>());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_METHOD, Vector<Variant>());
@@ -2248,7 +2022,6 @@ Vector<Variant> Animation::method_track_get_params(int p_track, int p_key_idx) c
 	return mk.params;
 }
 StringName Animation::method_track_get_name(int p_track, int p_key_idx) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), StringName());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_METHOD, StringName());
@@ -2261,7 +2034,6 @@ StringName Animation::method_track_get_name(int p_track, int p_key_idx) const {
 }
 
 int Animation::bezier_track_insert_key(int p_track, float p_time, float 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);
@@ -2288,7 +2060,6 @@ int Animation::bezier_track_insert_key(int p_track, float p_time, float p_value,
 }
 
 void Animation::bezier_track_set_key_value(int p_track, int p_index, float p_value) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_BEZIER);
@@ -2302,7 +2073,6 @@ void Animation::bezier_track_set_key_value(int p_track, int p_index, float p_val
 }
 
 void Animation::bezier_track_set_key_in_handle(int p_track, int p_index, const Vector2 &p_handle) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_BEZIER);
@@ -2318,7 +2088,6 @@ void Animation::bezier_track_set_key_in_handle(int p_track, int p_index, const V
 	emit_changed();
 }
 void Animation::bezier_track_set_key_out_handle(int p_track, int p_index, const Vector2 &p_handle) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_BEZIER);
@@ -2334,7 +2103,6 @@ void Animation::bezier_track_set_key_out_handle(int p_track, int p_index, const
 	emit_changed();
 }
 float Animation::bezier_track_get_key_value(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);
@@ -2346,7 +2114,6 @@ float Animation::bezier_track_get_key_value(int p_track, int p_index) const {
 	return bt->values[p_index].value.value;
 }
 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];
 	ERR_FAIL_COND_V(t->type != TYPE_BEZIER, Vector2());
@@ -2358,7 +2125,6 @@ Vector2 Animation::bezier_track_get_key_in_handle(int p_track, int p_index) cons
 	return bt->values[p_index].value.in_handle;
 }
 Vector2 Animation::bezier_track_get_key_out_handle(int p_track, int p_index) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), Vector2());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_BEZIER, Vector2());
@@ -2428,7 +2194,6 @@ float Animation::bezier_track_interpolate(int p_track, float p_time) const {
 
 	//narrow high and low as much as possible
 	for (int i = 0; i < iterations; i++) {
-
 		middle = (low + high) / 2;
 
 		Vector2 interp = _bezier_interp(middle, start, start_out, end_in, end);
@@ -2449,7 +2214,6 @@ float Animation::bezier_track_interpolate(int p_track, float p_time) const {
 }
 
 int Animation::audio_track_insert_key(int p_track, float p_time, const RES &p_stream, float p_start_offset, float p_end_offset) {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_AUDIO, -1);
@@ -2474,7 +2238,6 @@ int Animation::audio_track_insert_key(int p_track, float p_time, const RES &p_st
 }
 
 void Animation::audio_track_set_key_stream(int p_track, int p_key, const RES &p_stream) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_AUDIO);
@@ -2489,7 +2252,6 @@ void Animation::audio_track_set_key_stream(int p_track, int p_key, const RES &p_
 }
 
 void Animation::audio_track_set_key_start_offset(int p_track, int p_key, float p_offset) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_AUDIO);
@@ -2507,7 +2269,6 @@ void Animation::audio_track_set_key_start_offset(int p_track, int p_key, float p
 }
 
 void Animation::audio_track_set_key_end_offset(int p_track, int p_key, float p_offset) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_AUDIO);
@@ -2525,7 +2286,6 @@ void Animation::audio_track_set_key_end_offset(int p_track, int p_key, float p_o
 }
 
 RES Animation::audio_track_get_key_stream(int p_track, int p_key) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), RES());
 	const Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_AUDIO, RES());
@@ -2537,7 +2297,6 @@ RES Animation::audio_track_get_key_stream(int p_track, int p_key) const {
 	return at->values[p_key].value.stream;
 }
 float Animation::audio_track_get_key_start_offset(int p_track, int p_key) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
 	const Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_AUDIO, 0);
@@ -2549,7 +2308,6 @@ float Animation::audio_track_get_key_start_offset(int p_track, int p_key) const
 	return at->values[p_key].value.start_offset;
 }
 float Animation::audio_track_get_key_end_offset(int p_track, int p_key) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
 	const Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_AUDIO, 0);
@@ -2564,7 +2322,6 @@ float Animation::audio_track_get_key_end_offset(int p_track, int p_key) const {
 //
 
 int Animation::animation_track_insert_key(int p_track, float p_time, const StringName &p_animation) {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_ANIMATION, -1);
@@ -2583,7 +2340,6 @@ int Animation::animation_track_insert_key(int p_track, float p_time, const Strin
 }
 
 void Animation::animation_track_set_key_animation(int p_track, int p_key, const StringName &p_animation) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	Track *t = tracks[p_track];
 	ERR_FAIL_COND(t->type != TYPE_ANIMATION);
@@ -2598,7 +2354,6 @@ void Animation::animation_track_set_key_animation(int p_track, int p_key, const
 }
 
 StringName Animation::animation_track_get_key_animation(int p_track, int p_key) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), StringName());
 	const Track *t = tracks[p_track];
 	ERR_FAIL_COND_V(t->type != TYPE_ANIMATION, StringName());
@@ -2611,7 +2366,6 @@ StringName Animation::animation_track_get_key_animation(int p_track, int p_key)
 }
 
 void Animation::set_length(float p_length) {
-
 	if (p_length < ANIM_MIN_LENGTH) {
 		p_length = ANIM_MIN_LENGTH;
 	}
@@ -2619,49 +2373,40 @@ void Animation::set_length(float p_length) {
 	emit_changed();
 }
 float Animation::get_length() const {
-
 	return length;
 }
 
 void Animation::set_loop(bool p_enabled) {
-
 	loop = p_enabled;
 	emit_changed();
 }
 bool Animation::has_loop() const {
-
 	return loop;
 }
 
 void Animation::track_set_imported(int p_track, bool p_imported) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	tracks[p_track]->imported = p_imported;
 }
 
 bool Animation::track_is_imported(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), false);
 	return tracks[p_track]->imported;
 }
 
 void Animation::track_set_enabled(int p_track, bool p_enabled) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	tracks[p_track]->enabled = p_enabled;
 	emit_changed();
 }
 
 bool Animation::track_is_enabled(int p_track) const {
-
 	ERR_FAIL_INDEX_V(p_track, tracks.size(), false);
 	return tracks[p_track]->enabled;
 }
 
 void Animation::track_move_up(int p_track) {
-
 	if (p_track >= 0 && p_track < (tracks.size() - 1)) {
-
 		SWAP(tracks.write[p_track], tracks.write[p_track + 1]);
 	}
 
@@ -2670,9 +2415,7 @@ void Animation::track_move_up(int p_track) {
 }
 
 void Animation::track_move_down(int p_track) {
-
 	if (p_track > 0 && p_track < tracks.size()) {
-
 		SWAP(tracks.write[p_track], tracks.write[p_track - 1]);
 	}
 
@@ -2681,7 +2424,6 @@ void Animation::track_move_down(int p_track) {
 }
 
 void Animation::track_move_to(int p_track, int p_to_index) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	ERR_FAIL_INDEX(p_to_index, tracks.size() + 1);
 	if (p_track == p_to_index || p_track == p_to_index - 1)
@@ -2697,7 +2439,6 @@ void Animation::track_move_to(int p_track, int p_to_index) {
 }
 
 void Animation::track_swap(int p_track, int p_with_track) {
-
 	ERR_FAIL_INDEX(p_track, tracks.size());
 	ERR_FAIL_INDEX(p_with_track, tracks.size());
 	if (p_track == p_with_track)
@@ -2709,13 +2450,11 @@ void Animation::track_swap(int p_track, int p_with_track) {
 }
 
 void Animation::set_step(float p_step) {
-
 	step = p_step;
 	emit_changed();
 }
 
 float Animation::get_step() const {
-
 	return step;
 }
 
@@ -2737,7 +2476,6 @@ void Animation::copy_track(int p_track, Ref<Animation> p_to_animation) {
 }
 
 void Animation::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("add_track", "type", "at_position"), &Animation::add_track, DEFVAL(-1));
 	ClassDB::bind_method(D_METHOD("remove_track", "track_idx"), &Animation::remove_track);
 	ClassDB::bind_method(D_METHOD("get_track_count"), &Animation::get_track_count);
@@ -2847,7 +2585,6 @@ void Animation::_bind_methods() {
 }
 
 void Animation::clear() {
-
 	for (int i = 0; i < tracks.size(); i++)
 		memdelete(tracks[i]);
 	tracks.clear();
@@ -2858,7 +2595,6 @@ void Animation::clear() {
 }
 
 bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, const TKey<TransformKey> &t1, const TKey<TransformKey> &t2, float p_alowed_linear_err, float p_alowed_angular_err, float 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 };
 
@@ -2876,7 +2612,6 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, cons
 			}
 
 		} else {
-
 			Vector3 pd = (v2 - v0);
 			float d0 = pd.dot(v0);
 			float d1 = pd.dot(v1);
@@ -2908,12 +2643,10 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, cons
 		//localize both to rotation from q0
 
 		if (q0.is_equal_approx(q2)) {
-
 			if (!q0.is_equal_approx(q1))
 				return false;
 
 		} else {
-
 			Quat r02 = (q0.inverse() * q2).normalized();
 			Quat r01 = (q0.inverse() * q1).normalized();
 
@@ -2965,7 +2698,6 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, cons
 			}
 
 		} else {
-
 			Vector3 pd = (v2 - v0);
 			float d0 = pd.dot(v0);
 			float d1 = pd.dot(v1);
@@ -2987,10 +2719,8 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, cons
 
 	bool erase = false;
 	if (t[0] == -1 && t[1] == -1 && t[2] == -1) {
-
 		erase = true;
 	} else {
-
 		erase = true;
 		real_t lt = -1;
 		for (int j = 0; j < 3; j++) {
@@ -3014,7 +2744,6 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, cons
 		ERR_FAIL_COND_V(lt == -1, 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
@@ -3028,7 +2757,6 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, cons
 }
 
 void Animation::_transform_track_optimize(int p_idx, float p_allowed_linear_err, float p_allowed_angular_err, float p_max_optimizable_angle) {
-
 	ERR_FAIL_INDEX(p_idx, tracks.size());
 	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_TRANSFORM);
 	TransformTrack *tt = static_cast<TransformTrack *>(tracks[p_idx]);
@@ -3038,7 +2766,6 @@ void Animation::_transform_track_optimize(int p_idx, float p_allowed_linear_err,
 	Vector3 norm;
 
 	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];
@@ -3054,7 +2781,6 @@ void Animation::_transform_track_optimize(int p_idx, float p_allowed_linear_err,
 		}
 
 		if (erase) {
-
 			if (!prev_erased) {
 				first_erased = t1;
 				prev_erased = true;
@@ -3071,23 +2797,19 @@ void Animation::_transform_track_optimize(int p_idx, float p_allowed_linear_err,
 }
 
 void Animation::optimize(float p_allowed_linear_err, float p_allowed_angular_err, float p_max_optimizable_angle) {
-
 	for (int i = 0; i < tracks.size(); i++) {
-
 		if (tracks[i]->type == TYPE_TRANSFORM)
 			_transform_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle);
 	}
 }
 
 Animation::Animation() {
-
 	step = 0.1;
 	loop = false;
 	length = 1;
 }
 
 Animation::~Animation() {
-
 	for (int i = 0; i < tracks.size(); i++)
 		memdelete(tracks[i]);
 }