Merge pull request #38738 from akien-mga/cause-we-never-go-out-of-style

Style: Remove new line at block start, enforce line between functions, enforce braces in if and loop blocks

15 files changed, 378 insertions, 624 deletions

diff --git a/scene/animation/animation_blend_space_1d.cpp b/scene/animation/animation_blend_space_1d.cpp
index 3502f5e961..e426e98def 100644
--- a/scene/animation/animation_blend_space_1d.cpp
+++ b/scene/animation/animation_blend_space_1d.cpp
@@ -33,6 +33,7 @@
 void AnimationNodeBlendSpace1D::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, blend_position));
 }
+
 Variant AnimationNodeBlendSpace1D::get_parameter_default_value(const StringName &p_parameter) const {
 	return 0;
 }
@@ -167,7 +168,6 @@ void AnimationNodeBlendSpace1D::remove_blend_point(int p_point) {
 }
 
 int AnimationNodeBlendSpace1D::get_blend_point_count() const {
-
 	return blend_points_used;
 }
 
@@ -220,7 +220,6 @@ void AnimationNodeBlendSpace1D::_add_blend_point(int p_index, const Ref<Animatio
 }
 
 float AnimationNodeBlendSpace1D::process(float p_time, bool p_seek) {
-
 	if (blend_points_used == 0) {
 		return 0.0;
 	}
@@ -241,7 +240,6 @@ float AnimationNodeBlendSpace1D::process(float p_time, bool p_seek) {
 
 	// find the closest two points to blend between
 	for (int i = 0; i < blend_points_used; i++) {
-
 		float pos = blend_points[i].position;
 
 		if (pos <= blend_pos) {
@@ -276,7 +274,6 @@ float AnimationNodeBlendSpace1D::process(float p_time, bool p_seek) {
 
 		weights[point_lower] = 1.0;
 	} else {
-
 		// we are between two points.
 		// figure out weights, then blend the animations
 
@@ -311,7 +308,6 @@ String AnimationNodeBlendSpace1D::get_caption() const {
 }
 
 AnimationNodeBlendSpace1D::AnimationNodeBlendSpace1D() {
-
 	for (int i = 0; i < MAX_BLEND_POINTS; i++) {
 		blend_points[i].name = itos(i);
 	}
diff --git a/scene/animation/animation_blend_space_2d.cpp b/scene/animation/animation_blend_space_2d.cpp
index ad60249f9a..003a4fad90 100644
--- a/scene/animation/animation_blend_space_2d.cpp
+++ b/scene/animation/animation_blend_space_2d.cpp
@@ -37,6 +37,7 @@ void AnimationNodeBlendSpace2D::get_parameter_list(List<PropertyInfo> *r_list) c
 	r_list->push_back(PropertyInfo(Variant::INT, closest, PROPERTY_HINT_NONE, "", 0));
 	r_list->push_back(PropertyInfo(Variant::FLOAT, length_internal, PROPERTY_HINT_NONE, "", 0));
 }
+
 Variant AnimationNodeBlendSpace2D::get_parameter_default_value(const StringName &p_parameter) const {
 	if (p_parameter == closest) {
 		return -1;
@@ -91,6 +92,7 @@ void AnimationNodeBlendSpace2D::set_blend_point_position(int p_point, const Vect
 	blend_points[p_point].position = p_position;
 	_queue_auto_triangles();
 }
+
 void AnimationNodeBlendSpace2D::set_blend_point_node(int p_point, const Ref<AnimationRootNode> &p_node) {
 	ERR_FAIL_INDEX(p_point, blend_points_used);
 	ERR_FAIL_COND(p_node.is_null());
@@ -103,14 +105,17 @@ void AnimationNodeBlendSpace2D::set_blend_point_node(int p_point, const Ref<Anim
 
 	emit_signal("tree_changed");
 }
+
 Vector2 AnimationNodeBlendSpace2D::get_blend_point_position(int p_point) const {
 	ERR_FAIL_INDEX_V(p_point, blend_points_used, Vector2());
 	return blend_points[p_point].position;
 }
+
 Ref<AnimationRootNode> AnimationNodeBlendSpace2D::get_blend_point_node(int p_point) const {
 	ERR_FAIL_INDEX_V(p_point, blend_points_used, Ref<AnimationRootNode>());
 	return blend_points[p_point].node;
 }
+
 void AnimationNodeBlendSpace2D::remove_blend_point(int p_point) {
 	ERR_FAIL_INDEX(p_point, blend_points_used);
 
@@ -142,12 +147,10 @@ void AnimationNodeBlendSpace2D::remove_blend_point(int p_point) {
 }
 
 int AnimationNodeBlendSpace2D::get_blend_point_count() const {
-
 	return blend_points_used;
 }
 
 bool AnimationNodeBlendSpace2D::has_triangle(int p_x, int p_y, int p_z) const {
-
 	ERR_FAIL_INDEX_V(p_x, blend_points_used, false);
 	ERR_FAIL_INDEX_V(p_y, blend_points_used, false);
 	ERR_FAIL_INDEX_V(p_z, blend_points_used, false);
@@ -168,15 +171,15 @@ bool AnimationNodeBlendSpace2D::has_triangle(int p_x, int p_y, int p_z) const {
 				break;
 			}
 		}
-		if (all_equal)
+		if (all_equal) {
 			return true;
+		}
 	}
 
 	return false;
 }
 
 void AnimationNodeBlendSpace2D::add_triangle(int p_x, int p_y, int p_z, int p_at_index) {
-
 	ERR_FAIL_INDEX(p_x, blend_points_used);
 	ERR_FAIL_INDEX(p_y, blend_points_used);
 	ERR_FAIL_INDEX(p_z, blend_points_used);
@@ -208,14 +211,15 @@ void AnimationNodeBlendSpace2D::add_triangle(int p_x, int p_y, int p_z, int p_at
 		triangles.insert(p_at_index, t);
 	}
 }
-int AnimationNodeBlendSpace2D::get_triangle_point(int p_triangle, int p_point) {
 
+int AnimationNodeBlendSpace2D::get_triangle_point(int p_triangle, int p_point) {
 	_update_triangles();
 
 	ERR_FAIL_INDEX_V(p_point, 3, -1);
 	ERR_FAIL_INDEX_V(p_triangle, triangles.size(), -1);
 	return triangles[p_triangle].points[p_point];
 }
+
 void AnimationNodeBlendSpace2D::remove_triangle(int p_triangle) {
 	ERR_FAIL_INDEX(p_triangle, triangles.size());
 
@@ -227,7 +231,6 @@ int AnimationNodeBlendSpace2D::get_triangle_count() const {
 }
 
 void AnimationNodeBlendSpace2D::set_min_space(const Vector2 &p_min) {
-
 	min_space = p_min;
 	if (min_space.x >= max_space.x) {
 		min_space.x = max_space.x - 1;
@@ -236,12 +239,12 @@ void AnimationNodeBlendSpace2D::set_min_space(const Vector2 &p_min) {
 		min_space.y = max_space.y - 1;
 	}
 }
+
 Vector2 AnimationNodeBlendSpace2D::get_min_space() const {
 	return min_space;
 }
 
 void AnimationNodeBlendSpace2D::set_max_space(const Vector2 &p_max) {
-
 	max_space = p_max;
 	if (max_space.x <= min_space.x) {
 		max_space.x = min_space.x + 1;
@@ -250,6 +253,7 @@ void AnimationNodeBlendSpace2D::set_max_space(const Vector2 &p_max) {
 		max_space.y = min_space.y + 1;
 	}
 }
+
 Vector2 AnimationNodeBlendSpace2D::get_max_space() const {
 	return max_space;
 }
@@ -257,6 +261,7 @@ Vector2 AnimationNodeBlendSpace2D::get_max_space() const {
 void AnimationNodeBlendSpace2D::set_snap(const Vector2 &p_snap) {
 	snap = p_snap;
 }
+
 Vector2 AnimationNodeBlendSpace2D::get_snap() const {
 	return snap;
 }
@@ -264,6 +269,7 @@ Vector2 AnimationNodeBlendSpace2D::get_snap() const {
 void AnimationNodeBlendSpace2D::set_x_label(const String &p_label) {
 	x_label = p_label;
 }
+
 String AnimationNodeBlendSpace2D::get_x_label() const {
 	return x_label;
 }
@@ -271,6 +277,7 @@ String AnimationNodeBlendSpace2D::get_x_label() const {
 void AnimationNodeBlendSpace2D::set_y_label(const String &p_label) {
 	y_label = p_label;
 }
+
 String AnimationNodeBlendSpace2D::get_y_label() const {
 	return y_label;
 }
@@ -284,9 +291,9 @@ void AnimationNodeBlendSpace2D::_add_blend_point(int p_index, const Ref<Animatio
 }
 
 void AnimationNodeBlendSpace2D::_set_triangles(const Vector<int> &p_triangles) {
-
-	if (auto_triangles)
+	if (auto_triangles) {
 		return;
+	}
 	ERR_FAIL_COND(p_triangles.size() % 3 != 0);
 	for (int i = 0; i < p_triangles.size(); i += 3) {
 		add_triangle(p_triangles[i + 0], p_triangles[i + 1], p_triangles[i + 2]);
@@ -294,10 +301,10 @@ void AnimationNodeBlendSpace2D::_set_triangles(const Vector<int> &p_triangles) {
 }
 
 Vector<int> AnimationNodeBlendSpace2D::_get_triangles() const {
-
 	Vector<int> t;
-	if (auto_triangles && trianges_dirty)
+	if (auto_triangles && trianges_dirty) {
 		return t;
+	}
 
 	t.resize(triangles.size() * 3);
 	for (int i = 0; i < triangles.size(); i++) {
@@ -318,9 +325,9 @@ void AnimationNodeBlendSpace2D::_queue_auto_triangles() {
 }
 
 void AnimationNodeBlendSpace2D::_update_triangles() {
-
-	if (!auto_triangles || !trianges_dirty)
+	if (!auto_triangles || !trianges_dirty) {
 		return;
+	}
 
 	trianges_dirty = false;
 	triangles.clear();
@@ -344,11 +351,11 @@ void AnimationNodeBlendSpace2D::_update_triangles() {
 }
 
 Vector2 AnimationNodeBlendSpace2D::get_closest_point(const Vector2 &p_point) {
-
 	_update_triangles();
 
-	if (triangles.size() == 0)
+	if (triangles.size() == 0) {
 		return Vector2();
+	}
 
 	Vector2 best_point;
 	bool first = true;
@@ -360,7 +367,6 @@ Vector2 AnimationNodeBlendSpace2D::get_closest_point(const Vector2 &p_point) {
 		}
 
 		if (Geometry::is_point_in_triangle(p_point, points[0], points[1], points[2])) {
-
 			return p_point;
 		}
 
@@ -381,7 +387,6 @@ Vector2 AnimationNodeBlendSpace2D::get_closest_point(const Vector2 &p_point) {
 }
 
 void AnimationNodeBlendSpace2D::_blend_triangle(const Vector2 &p_pos, const Vector2 *p_points, float *r_weights) {
-
 	if (p_pos.distance_squared_to(p_points[0]) < CMP_EPSILON2) {
 		r_weights[0] = 1;
 		r_weights[1] = 0;
@@ -427,7 +432,6 @@ void AnimationNodeBlendSpace2D::_blend_triangle(const Vector2 &p_pos, const Vect
 }
 
 float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
-
 	_update_triangles();
 
 	Vector2 blend_pos = get_parameter(blend_position);
@@ -436,9 +440,9 @@ float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
 	float mind = 0; //time of min distance point
 
 	if (blend_mode == BLEND_MODE_INTERPOLATED) {
-
-		if (triangles.size() == 0)
+		if (triangles.size() == 0) {
 			return 0;
+		}
 
 		Vector2 best_point;
 		bool first = true;
@@ -452,7 +456,6 @@ float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
 			}
 
 			if (Geometry::is_point_in_triangle(blend_pos, points[0], points[1], points[2])) {
-
 				blend_triangle = i;
 				_blend_triangle(blend_pos, points, blend_weights);
 				break;
@@ -494,7 +497,6 @@ float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
 		first = true;
 
 		for (int i = 0; i < blend_points_used; i++) {
-
 			bool found = false;
 			for (int j = 0; j < 3; j++) {
 				if (i == triangle_points[j]) {
@@ -515,22 +517,18 @@ float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
 			}
 		}
 	} else {
-
 		int new_closest = -1;
 		float new_closest_dist = 1e20;
 
 		for (int i = 0; i < blend_points_used; i++) {
-
 			float d = blend_points[i].position.distance_squared_to(blend_pos);
 			if (d < new_closest_dist) {
-
 				new_closest = i;
 				new_closest_dist = d;
 			}
 		}
 
 		if (new_closest != closest && new_closest != -1) {
-
 			float from = 0;
 			if (blend_mode == BLEND_MODE_DISCRETE_CARRY && closest != -1) {
 				//see how much animation remains
@@ -557,7 +555,6 @@ String AnimationNodeBlendSpace2D::get_caption() const {
 }
 
 void AnimationNodeBlendSpace2D::_validate_property(PropertyInfo &property) const {
-
 	if (auto_triangles && property.name == "triangles") {
 		property.usage = 0;
 	}
@@ -601,7 +598,6 @@ AnimationNodeBlendSpace2D::BlendMode AnimationNodeBlendSpace2D::get_blend_mode()
 }
 
 void AnimationNodeBlendSpace2D::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("add_blend_point", "node", "pos", "at_index"), &AnimationNodeBlendSpace2D::add_blend_point, DEFVAL(-1));
 	ClassDB::bind_method(D_METHOD("set_blend_point_position", "point", "pos"), &AnimationNodeBlendSpace2D::set_blend_point_position);
 	ClassDB::bind_method(D_METHOD("get_blend_point_position", "point"), &AnimationNodeBlendSpace2D::get_blend_point_position);
@@ -666,7 +662,6 @@ void AnimationNodeBlendSpace2D::_bind_methods() {
 }
 
 AnimationNodeBlendSpace2D::AnimationNodeBlendSpace2D() {
-
 	for (int i = 0; i < MAX_BLEND_POINTS; i++) {
 		blend_points[i].name = itos(i);
 	}
diff --git a/scene/animation/animation_blend_tree.cpp b/scene/animation/animation_blend_tree.cpp
index 570735ad87..56995c0c13 100644
--- a/scene/animation/animation_blend_tree.cpp
+++ b/scene/animation/animation_blend_tree.cpp
@@ -46,13 +46,12 @@ Vector<String> (*AnimationNodeAnimation::get_editable_animation_list)() = nullpt
 void AnimationNodeAnimation::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", 0));
 }
-void AnimationNodeAnimation::_validate_property(PropertyInfo &property) const {
 
+void AnimationNodeAnimation::_validate_property(PropertyInfo &property) const {
 	if (property.name == "animation" && get_editable_animation_list) {
 		Vector<String> names = get_editable_animation_list();
 		String anims;
 		for (int i = 0; i < names.size(); i++) {
-
 			if (i > 0) {
 				anims += ",";
 			}
@@ -66,14 +65,12 @@ void AnimationNodeAnimation::_validate_property(PropertyInfo &property) const {
 }
 
 float AnimationNodeAnimation::process(float p_time, bool p_seek) {
-
 	AnimationPlayer *ap = state->player;
 	ERR_FAIL_COND_V(!ap, 0);
 
 	float time = get_parameter(this->time);
 
 	if (!ap->has_animation(animation)) {
-
 		AnimationNodeBlendTree *tree = Object::cast_to<AnimationNodeBlendTree>(parent);
 		if (tree) {
 			String name = tree->get_node_name(Ref<AnimationNodeAnimation>(this));
@@ -101,13 +98,11 @@ float AnimationNodeAnimation::process(float p_time, bool p_seek) {
 	float anim_size = anim->get_length();
 
 	if (anim->has_loop()) {
-
 		if (anim_size) {
 			time = Math::fposmod(time, anim_size);
 		}
 
 	} else if (time > anim_size) {
-
 		time = anim_size;
 	}
 
@@ -156,56 +151,50 @@ Variant AnimationNodeOneShot::get_parameter_default_value(const StringName &p_pa
 }
 
 void AnimationNodeOneShot::set_fadein_time(float p_time) {
-
 	fade_in = p_time;
 }
 
 void AnimationNodeOneShot::set_fadeout_time(float p_time) {
-
 	fade_out = p_time;
 }
 
 float AnimationNodeOneShot::get_fadein_time() const {
-
 	return fade_in;
 }
-float AnimationNodeOneShot::get_fadeout_time() const {
 
+float AnimationNodeOneShot::get_fadeout_time() const {
 	return fade_out;
 }
 
 void AnimationNodeOneShot::set_autorestart(bool p_active) {
-
 	autorestart = p_active;
 }
-void AnimationNodeOneShot::set_autorestart_delay(float p_time) {
 
+void AnimationNodeOneShot::set_autorestart_delay(float p_time) {
 	autorestart_delay = p_time;
 }
-void AnimationNodeOneShot::set_autorestart_random_delay(float p_time) {
 
+void AnimationNodeOneShot::set_autorestart_random_delay(float p_time) {
 	autorestart_random_delay = p_time;
 }
 
 bool AnimationNodeOneShot::has_autorestart() const {
-
 	return autorestart;
 }
-float AnimationNodeOneShot::get_autorestart_delay() const {
 
+float AnimationNodeOneShot::get_autorestart_delay() const {
 	return autorestart_delay;
 }
-float AnimationNodeOneShot::get_autorestart_random_delay() const {
 
+float AnimationNodeOneShot::get_autorestart_random_delay() const {
 	return autorestart_random_delay;
 }
 
 void AnimationNodeOneShot::set_mix_mode(MixMode p_mix) {
-
 	mix = p_mix;
 }
-AnimationNodeOneShot::MixMode AnimationNodeOneShot::get_mix_mode() const {
 
+AnimationNodeOneShot::MixMode AnimationNodeOneShot::get_mix_mode() const {
 	return mix;
 }
 
@@ -218,7 +207,6 @@ bool AnimationNodeOneShot::has_filter() const {
 }
 
 float AnimationNodeOneShot::process(float p_time, bool p_seek) {
-
 	bool active = get_parameter(this->active);
 	bool prev_active = get_parameter(this->prev_active);
 	float time = get_parameter(this->time);
@@ -247,8 +235,9 @@ float AnimationNodeOneShot::process(float p_time, bool p_seek) {
 
 	bool os_seek = p_seek;
 
-	if (p_seek)
+	if (p_seek) {
 		time = p_time;
+	}
 	bool do_start = !prev_active;
 
 	if (do_start) {
@@ -260,20 +249,21 @@ float AnimationNodeOneShot::process(float p_time, bool p_seek) {
 	float blend;
 
 	if (time < fade_in) {
-
-		if (fade_in > 0)
+		if (fade_in > 0) {
 			blend = time / fade_in;
-		else
+		} else {
 			blend = 0; //wtf
+		}
 
 	} else if (!do_start && remaining < fade_out) {
-
-		if (fade_out)
+		if (fade_out) {
 			blend = (remaining / fade_out);
-		else
+		} else {
 			blend = 1.0;
-	} else
+		}
+	} else {
 		blend = 1.0;
+	}
 
 	float main_rem;
 	if (mix == MIX_MODE_ADD) {
@@ -306,18 +296,16 @@ float AnimationNodeOneShot::process(float p_time, bool p_seek) {
 
 	return MAX(main_rem, remaining);
 }
-void AnimationNodeOneShot::set_use_sync(bool p_sync) {
 
+void AnimationNodeOneShot::set_use_sync(bool p_sync) {
 	sync = p_sync;
 }
 
 bool AnimationNodeOneShot::is_using_sync() const {
-
 	return sync;
 }
 
 void AnimationNodeOneShot::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_fadein_time", "time"), &AnimationNodeOneShot::set_fadein_time);
 	ClassDB::bind_method(D_METHOD("get_fadein_time"), &AnimationNodeOneShot::get_fadein_time);
 
@@ -356,7 +344,6 @@ void AnimationNodeOneShot::_bind_methods() {
 }
 
 AnimationNodeOneShot::AnimationNodeOneShot() {
-
 	add_input("in");
 	add_input("shot");
 
@@ -381,6 +368,7 @@ AnimationNodeOneShot::AnimationNodeOneShot() {
 void AnimationNodeAdd2::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, add_amount, PROPERTY_HINT_RANGE, "0,1,0.01"));
 }
+
 Variant AnimationNodeAdd2::get_parameter_default_value(const StringName &p_parameter) const {
 	return 0;
 }
@@ -388,23 +376,20 @@ Variant AnimationNodeAdd2::get_parameter_default_value(const StringName &p_param
 String AnimationNodeAdd2::get_caption() const {
 	return "Add2";
 }
-void AnimationNodeAdd2::set_use_sync(bool p_sync) {
 
+void AnimationNodeAdd2::set_use_sync(bool p_sync) {
 	sync = p_sync;
 }
 
 bool AnimationNodeAdd2::is_using_sync() const {
-
 	return sync;
 }
 
 bool AnimationNodeAdd2::has_filter() const {
-
 	return true;
 }
 
 float AnimationNodeAdd2::process(float p_time, bool p_seek) {
-
 	float amount = get_parameter(add_amount);
 	float rem0 = blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
 	blend_input(1, p_time, p_seek, amount, FILTER_PASS, !sync);
@@ -413,7 +398,6 @@ float AnimationNodeAdd2::process(float p_time, bool p_seek) {
 }
 
 void AnimationNodeAdd2::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeAdd2::set_use_sync);
 	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeAdd2::is_using_sync);
 
@@ -421,7 +405,6 @@ void AnimationNodeAdd2::_bind_methods() {
 }
 
 AnimationNodeAdd2::AnimationNodeAdd2() {
-
 	add_amount = "add_amount";
 	add_input("in");
 	add_input("add");
@@ -433,6 +416,7 @@ AnimationNodeAdd2::AnimationNodeAdd2() {
 void AnimationNodeAdd3::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, add_amount, PROPERTY_HINT_RANGE, "-1,1,0.01"));
 }
+
 Variant AnimationNodeAdd3::get_parameter_default_value(const StringName &p_parameter) const {
 	return 0;
 }
@@ -440,23 +424,20 @@ Variant AnimationNodeAdd3::get_parameter_default_value(const StringName &p_param
 String AnimationNodeAdd3::get_caption() const {
 	return "Add3";
 }
-void AnimationNodeAdd3::set_use_sync(bool p_sync) {
 
+void AnimationNodeAdd3::set_use_sync(bool p_sync) {
 	sync = p_sync;
 }
 
 bool AnimationNodeAdd3::is_using_sync() const {
-
 	return sync;
 }
 
 bool AnimationNodeAdd3::has_filter() const {
-
 	return true;
 }
 
 float AnimationNodeAdd3::process(float p_time, bool p_seek) {
-
 	float amount = get_parameter(add_amount);
 	blend_input(0, p_time, p_seek, MAX(0, -amount), FILTER_PASS, !sync);
 	float rem0 = blend_input(1, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
@@ -466,7 +447,6 @@ float AnimationNodeAdd3::process(float p_time, bool p_seek) {
 }
 
 void AnimationNodeAdd3::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeAdd3::set_use_sync);
 	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeAdd3::is_using_sync);
 
@@ -474,18 +454,19 @@ void AnimationNodeAdd3::_bind_methods() {
 }
 
 AnimationNodeAdd3::AnimationNodeAdd3() {
-
 	add_amount = "add_amount";
 	add_input("-add");
 	add_input("in");
 	add_input("+add");
 	sync = false;
 }
+
 /////////////////////////////////////////////
 
 void AnimationNodeBlend2::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, blend_amount, PROPERTY_HINT_RANGE, "0,1,0.01"));
 }
+
 Variant AnimationNodeBlend2::get_parameter_default_value(const StringName &p_parameter) const {
 	return 0; //for blend amount
 }
@@ -495,7 +476,6 @@ String AnimationNodeBlend2::get_caption() const {
 }
 
 float AnimationNodeBlend2::process(float p_time, bool p_seek) {
-
 	float amount = get_parameter(blend_amount);
 
 	float rem0 = blend_input(0, p_time, p_seek, 1.0 - amount, FILTER_BLEND, !sync);
@@ -505,26 +485,24 @@ float AnimationNodeBlend2::process(float p_time, bool p_seek) {
 }
 
 void AnimationNodeBlend2::set_use_sync(bool p_sync) {
-
 	sync = p_sync;
 }
 
 bool AnimationNodeBlend2::is_using_sync() const {
-
 	return sync;
 }
 
 bool AnimationNodeBlend2::has_filter() const {
-
 	return true;
 }
-void AnimationNodeBlend2::_bind_methods() {
 
+void AnimationNodeBlend2::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeBlend2::set_use_sync);
 	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeBlend2::is_using_sync);
 
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
 }
+
 AnimationNodeBlend2::AnimationNodeBlend2() {
 	blend_amount = "blend_amount";
 	add_input("in");
@@ -537,6 +515,7 @@ AnimationNodeBlend2::AnimationNodeBlend2() {
 void AnimationNodeBlend3::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, blend_amount, PROPERTY_HINT_RANGE, "-1,1,0.01"));
 }
+
 Variant AnimationNodeBlend3::get_parameter_default_value(const StringName &p_parameter) const {
 	return 0; //for blend amount
 }
@@ -546,17 +525,14 @@ String AnimationNodeBlend3::get_caption() const {
 }
 
 void AnimationNodeBlend3::set_use_sync(bool p_sync) {
-
 	sync = p_sync;
 }
 
 bool AnimationNodeBlend3::is_using_sync() const {
-
 	return sync;
 }
 
 float AnimationNodeBlend3::process(float p_time, bool p_seek) {
-
 	float amount = get_parameter(blend_amount);
 	float rem0 = blend_input(0, p_time, p_seek, MAX(0, -amount), FILTER_IGNORE, !sync);
 	float rem1 = blend_input(1, p_time, p_seek, 1.0 - ABS(amount), FILTER_IGNORE, !sync);
@@ -566,12 +542,12 @@ float AnimationNodeBlend3::process(float p_time, bool p_seek) {
 }
 
 void AnimationNodeBlend3::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeBlend3::set_use_sync);
 	ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeBlend3::is_using_sync);
 
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
 }
+
 AnimationNodeBlend3::AnimationNodeBlend3() {
 	blend_amount = "blend_amount";
 	add_input("-blend");
@@ -585,6 +561,7 @@ AnimationNodeBlend3::AnimationNodeBlend3() {
 void AnimationNodeTimeScale::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, scale, PROPERTY_HINT_RANGE, "0,32,0.01,or_greater"));
 }
+
 Variant AnimationNodeTimeScale::get_parameter_default_value(const StringName &p_parameter) const {
 	return 1.0; //initial timescale
 }
@@ -594,7 +571,6 @@ String AnimationNodeTimeScale::get_caption() const {
 }
 
 float AnimationNodeTimeScale::process(float p_time, bool p_seek) {
-
 	float scale = get_parameter(this->scale);
 	if (p_seek) {
 		return blend_input(0, p_time, true, 1.0, FILTER_IGNORE, false);
@@ -605,6 +581,7 @@ float AnimationNodeTimeScale::process(float p_time, bool p_seek) {
 
 void AnimationNodeTimeScale::_bind_methods() {
 }
+
 AnimationNodeTimeScale::AnimationNodeTimeScale() {
 	scale = "scale";
 	add_input("in");
@@ -615,6 +592,7 @@ AnimationNodeTimeScale::AnimationNodeTimeScale() {
 void AnimationNodeTimeSeek::get_parameter_list(List<PropertyInfo> *r_list) const {
 	r_list->push_back(PropertyInfo(Variant::FLOAT, seek_pos, PROPERTY_HINT_RANGE, "-1,3600,0.01,or_greater"));
 }
+
 Variant AnimationNodeTimeSeek::get_parameter_default_value(const StringName &p_parameter) const {
 	return 1.0; //initial timescale
 }
@@ -624,7 +602,6 @@ String AnimationNodeTimeSeek::get_caption() const {
 }
 
 float AnimationNodeTimeSeek::process(float p_time, bool p_seek) {
-
 	float seek_pos = get_parameter(this->seek_pos);
 	if (p_seek) {
 		return blend_input(0, p_time, true, 1.0, FILTER_IGNORE, false);
@@ -649,7 +626,6 @@ AnimationNodeTimeSeek::AnimationNodeTimeSeek() {
 /////////////////////////////////////////////////
 
 void AnimationNodeTransition::get_parameter_list(List<PropertyInfo> *r_list) const {
-
 	String anims;
 	for (int i = 0; i < enabled_inputs; i++) {
 		if (i > 0) {
@@ -664,6 +640,7 @@ void AnimationNodeTransition::get_parameter_list(List<PropertyInfo> *r_list) con
 	r_list->push_back(PropertyInfo(Variant::FLOAT, time, PROPERTY_HINT_NONE, "", 0));
 	r_list->push_back(PropertyInfo(Variant::FLOAT, prev_xfading, PROPERTY_HINT_NONE, "", 0));
 }
+
 Variant AnimationNodeTransition::get_parameter_default_value(const StringName &p_parameter) const {
 	if (p_parameter == time || p_parameter == prev_xfading) {
 		return 0.0;
@@ -728,7 +705,6 @@ float AnimationNodeTransition::get_cross_fade_time() const {
 }
 
 float AnimationNodeTransition::process(float p_time, bool p_seek) {
-
 	int current = get_parameter(this->current);
 	int prev = get_parameter(this->prev);
 	int prev_current = get_parameter(this->prev_current);
@@ -758,13 +734,13 @@ float AnimationNodeTransition::process(float p_time, bool p_seek) {
 
 		rem = blend_input(current, p_time, p_seek, 1.0, FILTER_IGNORE, false);
 
-		if (p_seek)
+		if (p_seek) {
 			time = p_time;
-		else
+		} else {
 			time += p_time;
+		}
 
 		if (inputs[current].auto_advance && rem <= xfade) {
-
 			set_parameter(this->current, (current + 1) % enabled_inputs);
 		}
 
@@ -776,7 +752,6 @@ float AnimationNodeTransition::process(float p_time, bool p_seek) {
 
 			rem = blend_input(current, 0, true, 1.0 - blend, FILTER_IGNORE, false);
 		} else {
-
 			rem = blend_input(current, p_time, p_seek, 1.0 - blend, FILTER_IGNORE, false);
 		}
 
@@ -800,7 +775,6 @@ float AnimationNodeTransition::process(float p_time, bool p_seek) {
 }
 
 void AnimationNodeTransition::_validate_property(PropertyInfo &property) const {
-
 	if (property.name.begins_with("input_")) {
 		String n = property.name.get_slicec('/', 0).get_slicec('_', 1);
 		if (n != "count") {
@@ -815,7 +789,6 @@ void AnimationNodeTransition::_validate_property(PropertyInfo &property) const {
 }
 
 void AnimationNodeTransition::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_enabled_inputs", "amount"), &AnimationNodeTransition::set_enabled_inputs);
 	ClassDB::bind_method(D_METHOD("get_enabled_inputs"), &AnimationNodeTransition::get_enabled_inputs);
 
@@ -838,7 +811,6 @@ void AnimationNodeTransition::_bind_methods() {
 }
 
 AnimationNodeTransition::AnimationNodeTransition() {
-
 	prev_xfading = "prev_xfading";
 	prev = "prev";
 	time = "time";
@@ -869,7 +841,6 @@ AnimationNodeOutput::AnimationNodeOutput() {
 
 ///////////////////////////////////////////////////////
 void AnimationNodeBlendTree::add_node(const StringName &p_name, Ref<AnimationNode> p_node, const Vector2 &p_position) {
-
 	ERR_FAIL_COND(nodes.has(p_name));
 	ERR_FAIL_COND(p_node.is_null());
 	ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output);
@@ -889,7 +860,6 @@ void AnimationNodeBlendTree::add_node(const StringName &p_name, Ref<AnimationNod
 }
 
 Ref<AnimationNode> AnimationNodeBlendTree::get_node(const StringName &p_name) const {
-
 	ERR_FAIL_COND_V(!nodes.has(p_name), Ref<AnimationNode>());
 
 	return nodes[p_name].node;
@@ -935,13 +905,13 @@ void AnimationNodeBlendTree::get_child_nodes(List<ChildNode> *r_child_nodes) {
 bool AnimationNodeBlendTree::has_node(const StringName &p_name) const {
 	return nodes.has(p_name);
 }
-Vector<StringName> AnimationNodeBlendTree::get_node_connection_array(const StringName &p_name) const {
 
+Vector<StringName> AnimationNodeBlendTree::get_node_connection_array(const StringName &p_name) const {
 	ERR_FAIL_COND_V(!nodes.has(p_name), Vector<StringName>());
 	return nodes[p_name].connections;
 }
-void AnimationNodeBlendTree::remove_node(const StringName &p_name) {
 
+void AnimationNodeBlendTree::remove_node(const StringName &p_name) {
 	ERR_FAIL_COND(!nodes.has(p_name));
 	ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output); //can't delete output
 
@@ -967,7 +937,6 @@ void AnimationNodeBlendTree::remove_node(const StringName &p_name) {
 }
 
 void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringName &p_new_name) {
-
 	ERR_FAIL_COND(!nodes.has(p_name));
 	ERR_FAIL_COND(nodes.has(p_new_name));
 	ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output);
@@ -980,7 +949,6 @@ void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringN
 
 	//rename connections
 	for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
-
 		for (int i = 0; i < E->get().connections.size(); i++) {
 			if (E->get().connections[i] == p_name) {
 				E->get().connections.write[i] = p_new_name;
@@ -994,7 +962,6 @@ void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringN
 }
 
 void AnimationNodeBlendTree::connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) {
-
 	ERR_FAIL_COND(!nodes.has(p_output_node));
 	ERR_FAIL_COND(!nodes.has(p_input_node));
 	ERR_FAIL_COND(p_output_node == SceneStringNames::get_singleton()->output);
@@ -1016,7 +983,6 @@ void AnimationNodeBlendTree::connect_node(const StringName &p_input_node, int p_
 }
 
 void AnimationNodeBlendTree::disconnect_node(const StringName &p_node, int p_input_index) {
-
 	ERR_FAIL_COND(!nodes.has(p_node));
 
 	Ref<AnimationNode> input = nodes[p_node].node;
@@ -1026,7 +992,6 @@ void AnimationNodeBlendTree::disconnect_node(const StringName &p_node, int p_inp
 }
 
 AnimationNodeBlendTree::ConnectionError AnimationNodeBlendTree::can_connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) const {
-
 	if (!nodes.has(p_output_node) || p_output_node == SceneStringNames::get_singleton()->output) {
 		return CONNECTION_ERROR_NO_OUTPUT;
 	}
@@ -1061,7 +1026,6 @@ AnimationNodeBlendTree::ConnectionError AnimationNodeBlendTree::can_connect_node
 }
 
 void AnimationNodeBlendTree::get_node_connections(List<NodeConnection> *r_connections) const {
-
 	for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
 		for (int i = 0; i < E->get().connections.size(); i++) {
 			StringName output = E->get().connections[i];
@@ -1081,25 +1045,21 @@ String AnimationNodeBlendTree::get_caption() const {
 }
 
 float AnimationNodeBlendTree::process(float p_time, bool p_seek) {
-
 	Ref<AnimationNodeOutput> output = nodes[SceneStringNames::get_singleton()->output].node;
 	return _blend_node("output", nodes[SceneStringNames::get_singleton()->output].connections, this, output, p_time, p_seek, 1.0);
 }
 
 void AnimationNodeBlendTree::get_node_list(List<StringName> *r_list) {
-
 	for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
 		r_list->push_back(E->key());
 	}
 }
 
 void AnimationNodeBlendTree::set_graph_offset(const Vector2 &p_graph_offset) {
-
 	graph_offset = p_graph_offset;
 }
 
 Vector2 AnimationNodeBlendTree::get_graph_offset() const {
-
 	return graph_offset;
 }
 
@@ -1108,10 +1068,8 @@ Ref<AnimationNode> AnimationNodeBlendTree::get_child_by_name(const StringName &p
 }
 
 bool AnimationNodeBlendTree::_set(const StringName &p_name, const Variant &p_value) {
-
 	String name = p_name;
 	if (name.begins_with("nodes/")) {
-
 		String node_name = name.get_slicec('/', 1);
 		String what = name.get_slicec('/', 2);
 
@@ -1124,14 +1082,12 @@ bool AnimationNodeBlendTree::_set(const StringName &p_name, const Variant &p_val
 		}
 
 		if (what == "position") {
-
 			if (nodes.has(node_name)) {
 				nodes[node_name].position = p_value;
 			}
 			return true;
 		}
 	} else if (name == "node_connections") {
-
 		Array conns = p_value;
 		ERR_FAIL_COND_V(conns.size() % 3 != 0, false);
 
@@ -1145,7 +1101,6 @@ bool AnimationNodeBlendTree::_set(const StringName &p_name, const Variant &p_val
 }
 
 bool AnimationNodeBlendTree::_get(const StringName &p_name, Variant &r_ret) const {
-
 	String name = p_name;
 	if (name.begins_with("nodes/")) {
 		String node_name = name.get_slicec('/', 1);
@@ -1159,7 +1114,6 @@ bool AnimationNodeBlendTree::_get(const StringName &p_name, Variant &r_ret) cons
 		}
 
 		if (what == "position") {
-
 			if (nodes.has(node_name)) {
 				r_ret = nodes[node_name].position;
 				return true;
@@ -1185,8 +1139,8 @@ bool AnimationNodeBlendTree::_get(const StringName &p_name, Variant &r_ret) cons
 
 	return false;
 }
-void AnimationNodeBlendTree::_get_property_list(List<PropertyInfo> *p_list) const {
 
+void AnimationNodeBlendTree::_get_property_list(List<PropertyInfo> *p_list) const {
 	List<StringName> names;
 	for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
 		names.push_back(E->key());
@@ -1209,13 +1163,11 @@ void AnimationNodeBlendTree::_tree_changed() {
 }
 
 void AnimationNodeBlendTree::_node_changed(const StringName &p_node) {
-
 	ERR_FAIL_COND(!nodes.has(p_node));
 	nodes[p_node].connections.resize(nodes[p_node].node->get_input_count());
 }
 
 void AnimationNodeBlendTree::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("add_node", "name", "node", "position"), &AnimationNodeBlendTree::add_node, DEFVAL(Vector2()));
 	ClassDB::bind_method(D_METHOD("get_node", "name"), &AnimationNodeBlendTree::get_node);
 	ClassDB::bind_method(D_METHOD("remove_node", "name"), &AnimationNodeBlendTree::remove_node);
@@ -1241,7 +1193,6 @@ void AnimationNodeBlendTree::_bind_methods() {
 }
 
 AnimationNodeBlendTree::AnimationNodeBlendTree() {
-
 	Ref<AnimationNodeOutput> output;
 	output.instance();
 	Node n;
diff --git a/scene/animation/animation_blend_tree.h b/scene/animation/animation_blend_tree.h
index 7ebe3f5444..5c722d00f9 100644
--- a/scene/animation/animation_blend_tree.h
+++ b/scene/animation/animation_blend_tree.h
@@ -34,7 +34,6 @@
 #include "scene/animation/animation_tree.h"
 
 class AnimationNodeAnimation : public AnimationRootNode {
-
 	GDCLASS(AnimationNodeAnimation, AnimationRootNode);
 
 	StringName animation;
@@ -268,7 +267,6 @@ class AnimationNodeTransition : public AnimationNode {
 		MAX_INPUTS = 32
 	};
 	struct InputData {
-
 		String name;
 		bool auto_advance;
 		InputData() { auto_advance = false; }
diff --git a/scene/animation/animation_cache.cpp b/scene/animation/animation_cache.cpp
index ab8be47b4d..abb2cf1b65 100644
--- a/scene/animation/animation_cache.cpp
+++ b/scene/animation/animation_cache.cpp
@@ -31,7 +31,6 @@
 #include "animation_cache.h"
 
 void AnimationCache::_node_exit_tree(Node *p_node) {
-
 	//it is one shot, so it disconnects upon arrival
 
 	ERR_FAIL_COND(!connected_nodes.has(p_node));
@@ -39,23 +38,20 @@ void AnimationCache::_node_exit_tree(Node *p_node) {
 	connected_nodes.erase(p_node);
 
 	for (int i = 0; i < path_cache.size(); i++) {
-
-		if (path_cache[i].node != p_node)
+		if (path_cache[i].node != p_node) {
 			continue;
+		}
 
 		path_cache.write[i].valid = false; //invalidate path cache
 	}
 }
 
 void AnimationCache::_animation_changed() {
-
 	_clear_cache();
 }
 
 void AnimationCache::_clear_cache() {
-
 	while (connected_nodes.size()) {
-
 		connected_nodes.front()->get()->disconnect("tree_exiting", callable_mp(this, &AnimationCache::_node_exit_tree));
 		connected_nodes.erase(connected_nodes.front());
 	}
@@ -65,7 +61,6 @@ void AnimationCache::_clear_cache() {
 }
 
 void AnimationCache::_update_cache() {
-
 	cache_valid = false;
 
 	ERR_FAIL_COND(!root);
@@ -73,12 +68,10 @@ void AnimationCache::_update_cache() {
 	ERR_FAIL_COND(animation.is_null());
 
 	for (int i = 0; i < animation->get_track_count(); i++) {
-
 		NodePath np = animation->track_get_path(i);
 
 		Node *node = root->get_node(np);
 		if (!node) {
-
 			path_cache.push_back(Path());
 			ERR_CONTINUE_MSG(!node, "Invalid track path in animation '" + np + "'.");
 		}
@@ -88,7 +81,6 @@ void AnimationCache::_update_cache() {
 		Ref<Resource> res;
 
 		if (animation->track_get_type(i) == Animation::TYPE_TRANSFORM) {
-
 			if (np.get_subname_count() > 1) {
 				path_cache.push_back(Path());
 				ERR_CONTINUE_MSG(animation->track_get_type(i) == Animation::TYPE_TRANSFORM, "Transform tracks can't have a subpath '" + np + "'.");
@@ -97,7 +89,6 @@ void AnimationCache::_update_cache() {
 			Node3D *sp = Object::cast_to<Node3D>(node);
 
 			if (!sp) {
-
 				path_cache.push_back(Path());
 				ERR_CONTINUE_MSG(!sp, "Transform track not of type Node3D '" + np + "'.");
 			}
@@ -108,7 +99,6 @@ void AnimationCache::_update_cache() {
 
 				Skeleton3D *sk = Object::cast_to<Skeleton3D>(node);
 				if (!sk) {
-
 					path_cache.push_back(Path());
 					ERR_CONTINUE_MSG(!sk, "Property defined in Transform track, but not a Skeleton! '" + np + "'.");
 				}
@@ -127,7 +117,6 @@ void AnimationCache::_update_cache() {
 
 		} else {
 			if (np.get_subname_count() > 0) {
-
 				RES res2;
 				Vector<StringName> leftover_subpath;
 
@@ -144,7 +133,6 @@ void AnimationCache::_update_cache() {
 				path.subpath = leftover_subpath;
 
 			} else {
-
 				path.node = node;
 				path.object = node;
 				path.subpath = np.get_subnames();
@@ -152,15 +140,12 @@ void AnimationCache::_update_cache() {
 		}
 
 		if (animation->track_get_type(i) == Animation::TYPE_VALUE) {
-
 			if (np.get_subname_count() == 0) {
-
 				path_cache.push_back(Path());
 				ERR_CONTINUE_MSG(np.get_subname_count() == 0, "Value Track lacks property: " + np + ".");
 			}
 
 		} else if (animation->track_get_type(i) == Animation::TYPE_METHOD) {
-
 			if (path.subpath.size() != 0) { // Trying to call a method of a non-resource
 
 				path_cache.push_back(Path());
@@ -183,15 +168,16 @@ void AnimationCache::_update_cache() {
 }
 
 void AnimationCache::set_track_transform(int p_idx, const Transform &p_transform) {
-
-	if (cache_dirty)
+	if (cache_dirty) {
 		_update_cache();
+	}
 
 	ERR_FAIL_COND(!cache_valid);
 	ERR_FAIL_INDEX(p_idx, path_cache.size());
 	Path &p = path_cache.write[p_idx];
-	if (!p.valid)
+	if (!p.valid) {
 		return;
+	}
 
 	ERR_FAIL_COND(!p.node);
 	ERR_FAIL_COND(!p.spatial);
@@ -204,49 +190,48 @@ void AnimationCache::set_track_transform(int p_idx, const Transform &p_transform
 }
 
 void AnimationCache::set_track_value(int p_idx, const Variant &p_value) {
-
-	if (cache_dirty)
+	if (cache_dirty) {
 		_update_cache();
+	}
 
 	ERR_FAIL_COND(!cache_valid);
 	ERR_FAIL_INDEX(p_idx, path_cache.size());
 	Path &p = path_cache.write[p_idx];
-	if (!p.valid)
+	if (!p.valid) {
 		return;
+	}
 
 	ERR_FAIL_COND(!p.object);
 	p.object->set_indexed(p.subpath, p_value);
 }
 
 void AnimationCache::call_track(int p_idx, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
-
-	if (cache_dirty)
+	if (cache_dirty) {
 		_update_cache();
+	}
 
 	ERR_FAIL_COND(!cache_valid);
 	ERR_FAIL_INDEX(p_idx, path_cache.size());
 	Path &p = path_cache.write[p_idx];
-	if (!p.valid)
+	if (!p.valid) {
 		return;
+	}
 
 	ERR_FAIL_COND(!p.object);
 	p.object->call(p_method, p_args, p_argcount, r_error);
 }
 
 void AnimationCache::set_all(float p_time, float p_delta) {
-
-	if (cache_dirty)
+	if (cache_dirty) {
 		_update_cache();
+	}
 
 	ERR_FAIL_COND(!cache_valid);
 
 	int tc = animation->get_track_count();
 	for (int i = 0; i < tc; i++) {
-
 		switch (animation->track_get_type(i)) {
-
 			case Animation::TYPE_TRANSFORM: {
-
 				Vector3 loc, scale;
 				Quat rot;
 				animation->transform_track_interpolate(i, p_time, &loc, &rot, &scale);
@@ -257,17 +242,14 @@ void AnimationCache::set_all(float p_time, float p_delta) {
 
 			} break;
 			case Animation::TYPE_VALUE: {
-
 				if (animation->value_track_get_update_mode(i) == Animation::UPDATE_CONTINUOUS || (animation->value_track_get_update_mode(i) == Animation::UPDATE_DISCRETE && p_delta == 0)) {
 					Variant v = animation->value_track_interpolate(i, p_time);
 					set_track_value(i, v);
 				} else {
-
 					List<int> indices;
 					animation->value_track_get_key_indices(i, p_time, p_delta, &indices);
 
 					for (List<int>::Element *E = indices.front(); E; E = E->next()) {
-
 						Variant v = animation->track_get_key_value(i, E->get());
 						set_track_value(i, v);
 					}
@@ -275,25 +257,20 @@ void AnimationCache::set_all(float p_time, float p_delta) {
 
 			} break;
 			case Animation::TYPE_METHOD: {
-
 				List<int> indices;
 				animation->method_track_get_key_indices(i, p_time, p_delta, &indices);
 
 				for (List<int>::Element *E = indices.front(); E; E = E->next()) {
-
 					Vector<Variant> args = animation->method_track_get_params(i, E->get());
 					StringName name = animation->method_track_get_name(i, E->get());
 					Callable::CallError err;
 
 					if (!args.size()) {
-
 						call_track(i, name, nullptr, 0, err);
 					} else {
-
 						Vector<const Variant *> argptrs;
 						argptrs.resize(args.size());
 						for (int j = 0; j < args.size(); j++) {
-
 							argptrs.write[j] = &args.write[j];
 						}
 
@@ -309,29 +286,28 @@ void AnimationCache::set_all(float p_time, float p_delta) {
 }
 
 void AnimationCache::set_animation(const Ref<Animation> &p_animation) {
-
 	_clear_cache();
 
-	if (animation.is_valid())
+	if (animation.is_valid()) {
 		animation->disconnect("changed", callable_mp(this, &AnimationCache::_animation_changed));
+	}
 
 	animation = p_animation;
 
-	if (animation.is_valid())
+	if (animation.is_valid()) {
 		animation->connect("changed", callable_mp(this, &AnimationCache::_animation_changed));
+	}
 }
 
 void AnimationCache::_bind_methods() {
 }
 
 void AnimationCache::set_root(Node *p_root) {
-
 	_clear_cache();
 	root = p_root;
 }
 
 AnimationCache::AnimationCache() {
-
 	root = nullptr;
 	cache_dirty = true;
 	cache_valid = false;
diff --git a/scene/animation/animation_cache.h b/scene/animation/animation_cache.h
index 23312ca7ec..feff1d364a 100644
--- a/scene/animation/animation_cache.h
+++ b/scene/animation/animation_cache.h
@@ -35,11 +35,9 @@
 #include "scene/resources/animation.h"
 
 class AnimationCache : public Object {
-
 	GDCLASS(AnimationCache, Object);
 
 	struct Path {
-
 		RES resource;
 		Object *object;
 		Skeleton3D *skeleton; // haxor
diff --git a/scene/animation/animation_node_state_machine.cpp b/scene/animation/animation_node_state_machine.cpp
index 9f5e06c43d..17ce05f130 100644
--- a/scene/animation/animation_node_state_machine.cpp
+++ b/scene/animation/animation_node_state_machine.cpp
@@ -33,12 +33,10 @@
 /////////////////////////////////////////////////
 
 void AnimationNodeStateMachineTransition::set_switch_mode(SwitchMode p_mode) {
-
 	switch_mode = p_mode;
 }
 
 AnimationNodeStateMachineTransition::SwitchMode AnimationNodeStateMachineTransition::get_switch_mode() const {
-
 	return switch_mode;
 }
 
@@ -71,7 +69,6 @@ StringName AnimationNodeStateMachineTransition::get_advance_condition_name() con
 }
 
 void AnimationNodeStateMachineTransition::set_xfade_time(float p_xfade) {
-
 	ERR_FAIL_COND(p_xfade < 0);
 	xfade = p_xfade;
 	emit_changed();
@@ -133,7 +130,6 @@ void AnimationNodeStateMachineTransition::_bind_methods() {
 }
 
 AnimationNodeStateMachineTransition::AnimationNodeStateMachineTransition() {
-
 	switch_mode = SWITCH_MODE_IMMEDIATE;
 	auto_advance = false;
 	xfade = 0;
@@ -144,7 +140,6 @@ AnimationNodeStateMachineTransition::AnimationNodeStateMachineTransition() {
 ////////////////////////////////////////////////////////
 
 void AnimationNodeStateMachinePlayback::travel(const StringName &p_state) {
-
 	start_request_travel = true;
 	start_request = p_state;
 	stop_request = false;
@@ -155,39 +150,45 @@ void AnimationNodeStateMachinePlayback::start(const StringName &p_state) {
 	start_request = p_state;
 	stop_request = false;
 }
-void AnimationNodeStateMachinePlayback::stop() {
 
+void AnimationNodeStateMachinePlayback::stop() {
 	stop_request = true;
 }
+
 bool AnimationNodeStateMachinePlayback::is_playing() const {
 	return playing;
 }
+
 StringName AnimationNodeStateMachinePlayback::get_current_node() const {
 	return current;
 }
+
 StringName AnimationNodeStateMachinePlayback::get_blend_from_node() const {
 	return fading_from;
 }
+
 Vector<StringName> AnimationNodeStateMachinePlayback::get_travel_path() const {
 	return path;
 }
+
 float AnimationNodeStateMachinePlayback::get_current_play_pos() const {
 	return pos_current;
 }
+
 float AnimationNodeStateMachinePlayback::get_current_length() const {
 	return len_current;
 }
 
 bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_state_machine, const StringName &p_travel) {
-
 	ERR_FAIL_COND_V(!playing, false);
 	ERR_FAIL_COND_V(!p_state_machine->states.has(p_travel), false);
 	ERR_FAIL_COND_V(!p_state_machine->states.has(current), false);
 
 	path.clear(); //a new one will be needed
 
-	if (current == p_travel)
+	if (current == p_travel) {
 		return true; //nothing to do
+	}
 
 	loops_current = 0; // reset loops, so fade does not happen immediately
 
@@ -219,7 +220,6 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 	//begin astar
 	bool found_route = false;
 	while (!found_route) {
-
 		if (open_list.size() == 0) {
 			return false; //no path found
 		}
@@ -229,7 +229,6 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 		float least_cost = 1e20;
 
 		for (List<int>::Element *E = open_list.front(); E; E = E->next()) {
-
 			float cost = cost_map[p_state_machine->transitions[E->get()].to].distance;
 			cost += p_state_machine->states[p_state_machine->transitions[E->get()].to].position.distance_to(target_pos);
 
@@ -293,7 +292,6 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 }
 
 float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_state_machine, float p_time, bool p_seek) {
-
 	//if not playing and it can restart, then restart
 	if (!playing && start_request == StringName()) {
 		if (!stop_request && p_state_machine->start_node) {
@@ -347,7 +345,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 	bool do_start = (p_seek && p_time == 0) || play_start || current == StringName();
 
 	if (do_start) {
-
 		if (p_state_machine->start_node != StringName() && p_seek && p_time == 0) {
 			current = p_state_machine->start_node;
 		}
@@ -365,7 +362,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 	float fade_blend = 1.0;
 
 	if (fading_from != StringName()) {
-
 		if (!p_state_machine->states.has(fading_from)) {
 			fading_from = StringName();
 		} else {
@@ -382,7 +378,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 	float rem = p_state_machine->blend_node(current, p_state_machine->states[current].node, p_time, p_seek, fade_blend, AnimationNode::FILTER_IGNORE, false);
 
 	if (fading_from != StringName()) {
-
 		p_state_machine->blend_node(fading_from, p_state_machine->states[fading_from].node, p_time, p_seek, 1.0 - fade_blend, AnimationNode::FILTER_IGNORE, false);
 	}
 
@@ -407,7 +402,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 	AnimationNodeStateMachineTransition::SwitchMode switch_mode = AnimationNodeStateMachineTransition::SWITCH_MODE_IMMEDIATE;
 
 	if (path.size()) {
-
 		for (int i = 0; i < p_state_machine->transitions.size(); i++) {
 			if (p_state_machine->transitions[i].from == current && p_state_machine->transitions[i].to == path[0]) {
 				next_xfade = p_state_machine->transitions[i].transition->get_xfade_time();
@@ -419,7 +413,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 		float priority_best = 1e20;
 		int auto_advance_to = -1;
 		for (int i = 0; i < p_state_machine->transitions.size(); i++) {
-
 			bool auto_advance = false;
 			if (p_state_machine->transitions[i].transition->has_auto_advance()) {
 				auto_advance = true;
@@ -430,7 +423,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 			}
 
 			if (p_state_machine->transitions[i].from == current && auto_advance) {
-
 				if (p_state_machine->transitions[i].transition->get_priority() <= priority_best) {
 					priority_best = p_state_machine->transitions[i].transition->get_priority();
 					auto_advance_to = i;
@@ -447,7 +439,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 
 	//if next, see when to transition
 	if (next != StringName()) {
-
 		bool goto_next = false;
 
 		if (switch_mode == AnimationNodeStateMachineTransition::SWITCH_MODE_AT_END) {
@@ -492,7 +483,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 
 	//compute time left for transitions by using the end node
 	if (p_state_machine->end_node != StringName() && p_state_machine->end_node != current) {
-
 		rem = p_state_machine->blend_node(p_state_machine->end_node, p_state_machine->states[p_state_machine->end_node].node, 0, true, 0, AnimationNode::FILTER_IGNORE, false);
 	}
 
@@ -500,7 +490,6 @@ float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_st
 }
 
 void AnimationNodeStateMachinePlayback::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("travel", "to_node"), &AnimationNodeStateMachinePlayback::travel);
 	ClassDB::bind_method(D_METHOD("start", "node"), &AnimationNodeStateMachinePlayback::start);
 	ClassDB::bind_method(D_METHOD("stop"), &AnimationNodeStateMachinePlayback::stop);
@@ -542,7 +531,6 @@ void AnimationNodeStateMachine::get_parameter_list(List<PropertyInfo> *r_list) c
 }
 
 Variant AnimationNodeStateMachine::get_parameter_default_value(const StringName &p_parameter) const {
-
 	if (p_parameter == playback) {
 		Ref<AnimationNodeStateMachinePlayback> p;
 		p.instance();
@@ -553,7 +541,6 @@ Variant AnimationNodeStateMachine::get_parameter_default_value(const StringName
 }
 
 void AnimationNodeStateMachine::add_node(const StringName &p_name, Ref<AnimationNode> p_node, const Vector2 &p_position) {
-
 	ERR_FAIL_COND(states.has(p_name));
 	ERR_FAIL_COND(p_node.is_null());
 	ERR_FAIL_COND(String(p_name).find("/") != -1);
@@ -571,7 +558,6 @@ void AnimationNodeStateMachine::add_node(const StringName &p_name, Ref<Animation
 }
 
 void AnimationNodeStateMachine::replace_node(const StringName &p_name, Ref<AnimationNode> p_node) {
-
 	ERR_FAIL_COND(states.has(p_name) == false);
 	ERR_FAIL_COND(p_node.is_null());
 	ERR_FAIL_COND(String(p_name).find("/") != -1);
@@ -592,7 +578,6 @@ void AnimationNodeStateMachine::replace_node(const StringName &p_name, Ref<Anima
 }
 
 Ref<AnimationNode> AnimationNodeStateMachine::get_node(const StringName &p_name) const {
-
 	ERR_FAIL_COND_V(!states.has(p_name), Ref<AnimationNode>());
 
 	return states[p_name].node;
@@ -628,8 +613,8 @@ void AnimationNodeStateMachine::get_child_nodes(List<ChildNode> *r_child_nodes)
 bool AnimationNodeStateMachine::has_node(const StringName &p_name) const {
 	return states.has(p_name);
 }
-void AnimationNodeStateMachine::remove_node(const StringName &p_name) {
 
+void AnimationNodeStateMachine::remove_node(const StringName &p_name) {
 	ERR_FAIL_COND(!states.has(p_name));
 
 	{
@@ -668,7 +653,6 @@ void AnimationNodeStateMachine::remove_node(const StringName &p_name) {
 }
 
 void AnimationNodeStateMachine::rename_node(const StringName &p_name, const StringName &p_new_name) {
-
 	ERR_FAIL_COND(!states.has(p_name));
 	ERR_FAIL_COND(states.has(p_new_name));
 
@@ -702,7 +686,6 @@ void AnimationNodeStateMachine::rename_node(const StringName &p_name, const Stri
 }
 
 void AnimationNodeStateMachine::get_node_list(List<StringName> *r_nodes) const {
-
 	List<StringName> nodes;
 	for (Map<StringName, State>::Element *E = states.front(); E; E = E->next()) {
 		nodes.push_back(E->key());
@@ -715,25 +698,24 @@ void AnimationNodeStateMachine::get_node_list(List<StringName> *r_nodes) const {
 }
 
 bool AnimationNodeStateMachine::has_transition(const StringName &p_from, const StringName &p_to) const {
-
 	for (int i = 0; i < transitions.size(); i++) {
-		if (transitions[i].from == p_from && transitions[i].to == p_to)
+		if (transitions[i].from == p_from && transitions[i].to == p_to) {
 			return true;
+		}
 	}
 	return false;
 }
 
 int AnimationNodeStateMachine::find_transition(const StringName &p_from, const StringName &p_to) const {
-
 	for (int i = 0; i < transitions.size(); i++) {
-		if (transitions[i].from == p_from && transitions[i].to == p_to)
+		if (transitions[i].from == p_from && transitions[i].to == p_to) {
 			return i;
+		}
 	}
 	return -1;
 }
 
 void AnimationNodeStateMachine::add_transition(const StringName &p_from, const StringName &p_to, const Ref<AnimationNodeStateMachineTransition> &p_transition) {
-
 	ERR_FAIL_COND(p_from == p_to);
 	ERR_FAIL_COND(!states.has(p_from));
 	ERR_FAIL_COND(!states.has(p_to));
@@ -757,23 +739,22 @@ Ref<AnimationNodeStateMachineTransition> AnimationNodeStateMachine::get_transiti
 	ERR_FAIL_INDEX_V(p_transition, transitions.size(), Ref<AnimationNodeStateMachineTransition>());
 	return transitions[p_transition].transition;
 }
-StringName AnimationNodeStateMachine::get_transition_from(int p_transition) const {
 
+StringName AnimationNodeStateMachine::get_transition_from(int p_transition) const {
 	ERR_FAIL_INDEX_V(p_transition, transitions.size(), StringName());
 	return transitions[p_transition].from;
 }
-StringName AnimationNodeStateMachine::get_transition_to(int p_transition) const {
 
+StringName AnimationNodeStateMachine::get_transition_to(int p_transition) const {
 	ERR_FAIL_INDEX_V(p_transition, transitions.size(), StringName());
 	return transitions[p_transition].to;
 }
 
 int AnimationNodeStateMachine::get_transition_count() const {
-
 	return transitions.size();
 }
-void AnimationNodeStateMachine::remove_transition(const StringName &p_from, const StringName &p_to) {
 
+void AnimationNodeStateMachine::remove_transition(const StringName &p_from, const StringName &p_to) {
 	for (int i = 0; i < transitions.size(); i++) {
 		if (transitions[i].from == p_from && transitions[i].to == p_to) {
 			transitions.write[i].transition->disconnect("advance_condition_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed));
@@ -788,7 +769,6 @@ void AnimationNodeStateMachine::remove_transition(const StringName &p_from, cons
 }
 
 void AnimationNodeStateMachine::remove_transition_by_index(int p_transition) {
-
 	ERR_FAIL_INDEX(p_transition, transitions.size());
 	transitions.write[p_transition].transition->disconnect("advance_condition_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed));
 	transitions.remove(p_transition);
@@ -798,24 +778,20 @@ void AnimationNodeStateMachine::remove_transition_by_index(int p_transition) {
 }
 
 void AnimationNodeStateMachine::set_start_node(const StringName &p_node) {
-
 	ERR_FAIL_COND(p_node != StringName() && !states.has(p_node));
 	start_node = p_node;
 }
 
 String AnimationNodeStateMachine::get_start_node() const {
-
 	return start_node;
 }
 
 void AnimationNodeStateMachine::set_end_node(const StringName &p_node) {
-
 	ERR_FAIL_COND(p_node != StringName() && !states.has(p_node));
 	end_node = p_node;
 }
 
 String AnimationNodeStateMachine::get_end_node() const {
-
 	return end_node;
 }
 
@@ -828,7 +804,6 @@ Vector2 AnimationNodeStateMachine::get_graph_offset() const {
 }
 
 float AnimationNodeStateMachine::process(float p_time, bool p_seek) {
-
 	Ref<AnimationNodeStateMachinePlayback> playback = get_parameter(this->playback);
 	ERR_FAIL_COND_V(playback.is_null(), 0.0);
 
@@ -847,7 +822,6 @@ Ref<AnimationNode> AnimationNodeStateMachine::get_child_by_name(const StringName
 }
 
 bool AnimationNodeStateMachine::_set(const StringName &p_name, const Variant &p_value) {
-
 	String name = p_name;
 	if (name.begins_with("states/")) {
 		String node_name = name.get_slicec('/', 1);
@@ -862,14 +836,12 @@ bool AnimationNodeStateMachine::_set(const StringName &p_name, const Variant &p_
 		}
 
 		if (what == "position") {
-
 			if (states.has(node_name)) {
 				states[node_name].position = p_value;
 			}
 			return true;
 		}
 	} else if (name == "transitions") {
-
 		Array trans = p_value;
 		ERR_FAIL_COND_V(trans.size() % 3 != 0, false);
 
@@ -892,7 +864,6 @@ bool AnimationNodeStateMachine::_set(const StringName &p_name, const Variant &p_
 }
 
 bool AnimationNodeStateMachine::_get(const StringName &p_name, Variant &r_ret) const {
-
 	String name = p_name;
 	if (name.begins_with("states/")) {
 		String node_name = name.get_slicec('/', 1);
@@ -906,7 +877,6 @@ bool AnimationNodeStateMachine::_get(const StringName &p_name, Variant &r_ret) c
 		}
 
 		if (what == "position") {
-
 			if (states.has(node_name)) {
 				r_ret = states[node_name].position;
 				return true;
@@ -937,8 +907,8 @@ bool AnimationNodeStateMachine::_get(const StringName &p_name, Variant &r_ret) c
 
 	return false;
 }
-void AnimationNodeStateMachine::_get_property_list(List<PropertyInfo> *p_list) const {
 
+void AnimationNodeStateMachine::_get_property_list(List<PropertyInfo> *p_list) const {
 	List<StringName> names;
 	for (Map<StringName, State>::Element *E = states.front(); E; E = E->next()) {
 		names.push_back(E->key());
@@ -963,7 +933,6 @@ void AnimationNodeStateMachine::set_node_position(const StringName &p_name, cons
 }
 
 Vector2 AnimationNodeStateMachine::get_node_position(const StringName &p_name) const {
-
 	ERR_FAIL_COND_V(!states.has(p_name), Vector2());
 	return states[p_name].position;
 }
@@ -973,7 +942,6 @@ void AnimationNodeStateMachine::_tree_changed() {
 }
 
 void AnimationNodeStateMachine::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("add_node", "name", "node", "position"), &AnimationNodeStateMachine::add_node, DEFVAL(Vector2()));
 	ClassDB::bind_method(D_METHOD("replace_node", "name", "node"), &AnimationNodeStateMachine::replace_node);
 	ClassDB::bind_method(D_METHOD("get_node", "name"), &AnimationNodeStateMachine::get_node);
@@ -1005,6 +973,5 @@ void AnimationNodeStateMachine::_bind_methods() {
 }
 
 AnimationNodeStateMachine::AnimationNodeStateMachine() {
-
 	playback = "playback";
 }
diff --git a/scene/animation/animation_node_state_machine.h b/scene/animation/animation_node_state_machine.h
index 27a4451f08..72fa6f77d0 100644
--- a/scene/animation/animation_node_state_machine.h
+++ b/scene/animation/animation_node_state_machine.h
@@ -134,7 +134,6 @@ public:
 };
 
 class AnimationNodeStateMachine : public AnimationRootNode {
-
 	GDCLASS(AnimationNodeStateMachine, AnimationRootNode);
 
 private:
@@ -148,7 +147,6 @@ private:
 	Map<StringName, State> states;
 
 	struct Transition {
-
 		StringName from;
 		StringName to;
 		Ref<AnimationNodeStateMachineTransition> transition;
diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp
index 7bac09f839..4e56f1acf0 100644
--- a/scene/animation/animation_player.cpp
+++ b/scene/animation/animation_player.cpp
@@ -40,7 +40,6 @@
 #include "scene/2d/skeleton_2d.h"
 
 void AnimatedValuesBackup::update_skeletons() {
-
 	for (int i = 0; i < entries.size(); i++) {
 		if (entries[i].bone_idx != -1) {
 			// 3D bone
@@ -57,7 +56,6 @@ void AnimatedValuesBackup::update_skeletons() {
 #endif
 
 bool AnimationPlayer::_set(const StringName &p_name, const Variant &p_value) {
-
 	String name = p_name;
 
 	if (name.begins_with("playback/play")) { // bw compatibility
@@ -65,23 +63,19 @@ bool AnimationPlayer::_set(const StringName &p_name, const Variant &p_value) {
 		set_current_animation(p_value);
 
 	} else if (name.begins_with("anims/")) {
-
 		String which = name.get_slicec('/', 1);
 		add_animation(which, p_value);
 
 	} else if (name.begins_with("next/")) {
-
 		String which = name.get_slicec('/', 1);
 		animation_set_next(which, p_value);
 
 	} else if (p_name == SceneStringNames::get_singleton()->blend_times) {
-
 		Array array = p_value;
 		int len = array.size();
 		ERR_FAIL_COND_V(len % 3, false);
 
 		for (int i = 0; i < len / 3; i++) {
-
 			StringName from = array[i * 3 + 0];
 			StringName to = array[i * 3 + 1];
 			float time = array[i * 3 + 2];
@@ -89,14 +83,14 @@ bool AnimationPlayer::_set(const StringName &p_name, const Variant &p_value) {
 			set_blend_time(from, to, time);
 		}
 
-	} else
+	} else {
 		return false;
+	}
 
 	return true;
 }
 
 bool AnimationPlayer::_get(const StringName &p_name, Variant &r_ret) const {
-
 	String name = p_name;
 
 	if (name == "playback/play") { // bw compatibility
@@ -104,41 +98,36 @@ bool AnimationPlayer::_get(const StringName &p_name, Variant &r_ret) const {
 		r_ret = get_current_animation();
 
 	} else if (name.begins_with("anims/")) {
-
 		String which = name.get_slicec('/', 1);
 		r_ret = get_animation(which);
 
 	} else if (name.begins_with("next/")) {
-
 		String which = name.get_slicec('/', 1);
 
 		r_ret = animation_get_next(which);
 
 	} else if (name == "blend_times") {
-
 		Vector<BlendKey> keys;
 		for (Map<BlendKey, float>::Element *E = blend_times.front(); E; E = E->next()) {
-
 			keys.ordered_insert(E->key());
 		}
 
 		Array array;
 		for (int i = 0; i < keys.size(); i++) {
-
 			array.push_back(keys[i].from);
 			array.push_back(keys[i].to);
 			array.push_back(blend_times[keys[i]]);
 		}
 
 		r_ret = array;
-	} else
+	} else {
 		return false;
+	}
 
 	return true;
 }
 
 void AnimationPlayer::_validate_property(PropertyInfo &property) const {
-
 	if (property.name == "current_animation") {
 		List<String> names;
 
@@ -149,9 +138,9 @@ void AnimationPlayer::_validate_property(PropertyInfo &property) const {
 		names.push_front("[stop]");
 		String hint;
 		for (List<String>::Element *E = names.front(); E; E = E->next()) {
-
-			if (E != names.front())
+			if (E != names.front()) {
 				hint += ",";
+			}
 			hint += E->get();
 		}
 
@@ -160,14 +149,13 @@ void AnimationPlayer::_validate_property(PropertyInfo &property) const {
 }
 
 void AnimationPlayer::_get_property_list(List<PropertyInfo> *p_list) const {
-
 	List<PropertyInfo> anim_names;
 
 	for (Map<StringName, AnimationData>::Element *E = animation_set.front(); E; E = E->next()) {
-
 		anim_names.push_back(PropertyInfo(Variant::OBJECT, "anims/" + String(E->key()), PROPERTY_HINT_RESOURCE_TYPE, "Animation", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
-		if (E->get().next != StringName())
+		if (E->get().next != StringName()) {
 			anim_names.push_back(PropertyInfo(Variant::STRING, "next/" + String(E->key()), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
+		}
 	}
 
 	anim_names.sort();
@@ -180,16 +168,12 @@ void AnimationPlayer::_get_property_list(List<PropertyInfo> *p_list) const {
 }
 
 void AnimationPlayer::advance(float p_time) {
-
 	_animation_process(p_time);
 }
 
 void AnimationPlayer::_notification(int p_what) {
-
 	switch (p_what) {
-
 		case NOTIFICATION_ENTER_TREE: {
-
 			if (!processing) {
 				//make sure that a previous process state was not saved
 				//only process if "processing" is set
@@ -200,39 +184,40 @@ void AnimationPlayer::_notification(int p_what) {
 			clear_caches();
 		} break;
 		case NOTIFICATION_READY: {
-
 			if (!Engine::get_singleton()->is_editor_hint() && animation_set.has(autoplay)) {
 				play(autoplay);
 				_animation_process(0);
 			}
 		} break;
 		case NOTIFICATION_INTERNAL_PROCESS: {
-			if (animation_process_mode == ANIMATION_PROCESS_PHYSICS)
+			if (animation_process_mode == ANIMATION_PROCESS_PHYSICS) {
 				break;
+			}
 
-			if (processing)
+			if (processing) {
 				_animation_process(get_process_delta_time());
+			}
 		} break;
 		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
-
-			if (animation_process_mode == ANIMATION_PROCESS_IDLE)
+			if (animation_process_mode == ANIMATION_PROCESS_IDLE) {
 				break;
+			}
 
-			if (processing)
+			if (processing) {
 				_animation_process(get_physics_process_delta_time());
+			}
 		} break;
 		case NOTIFICATION_EXIT_TREE: {
-
 			clear_caches();
 		} break;
 	}
 }
 
 void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim) {
-
 	// Already cached?
-	if (p_anim->node_cache.size() == p_anim->animation->get_track_count())
+	if (p_anim->node_cache.size() == p_anim->animation->get_track_count()) {
 		return;
+	}
 
 	Node *parent = get_node(root);
 
@@ -243,7 +228,6 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim) {
 	p_anim->node_cache.resize(a->get_track_count());
 
 	for (int i = 0; i < a->get_track_count(); i++) {
-
 		p_anim->node_cache.write[i] = nullptr;
 		RES resource;
 		Vector<StringName> leftover_path;
@@ -253,26 +237,26 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim) {
 		int bone_idx = -1;
 
 		if (a->track_get_path(i).get_subname_count() == 1 && Object::cast_to<Skeleton3D>(child)) {
-
 			Skeleton3D *sk = Object::cast_to<Skeleton3D>(child);
 			bone_idx = sk->find_bone(a->track_get_path(i).get_subname(0));
 			if (bone_idx == -1) {
-
 				continue;
 			}
 		}
 
 		{
-			if (!child->is_connected("tree_exiting", callable_mp(this, &AnimationPlayer::_node_removed)))
+			if (!child->is_connected("tree_exiting", callable_mp(this, &AnimationPlayer::_node_removed))) {
 				child->connect("tree_exiting", callable_mp(this, &AnimationPlayer::_node_removed), make_binds(child), CONNECT_ONESHOT);
+			}
 		}
 
 		TrackNodeCacheKey key;
 		key.id = id;
 		key.bone_idx = bone_idx;
 
-		if (!node_cache_map.has(key))
+		if (!node_cache_map.has(key)) {
 			node_cache_map[key] = TrackNodeCache();
+		}
 
 		p_anim->node_cache.write[i] = &node_cache_map[key];
 		p_anim->node_cache[i]->path = a->track_get_path(i);
@@ -305,31 +289,27 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim) {
 		}
 
 		if (a->track_get_type(i) == Animation::TYPE_VALUE) {
-
 			if (!p_anim->node_cache[i]->property_anim.has(a->track_get_path(i).get_concatenated_subnames())) {
-
 				TrackNodeCache::PropertyAnim pa;
 				pa.subpath = leftover_path;
 				pa.object = resource.is_valid() ? (Object *)resource.ptr() : (Object *)child;
 				pa.special = SP_NONE;
 				pa.owner = p_anim->node_cache[i];
 				if (false && p_anim->node_cache[i]->node_2d) {
-
-					if (leftover_path.size() == 1 && leftover_path[0] == SceneStringNames::get_singleton()->transform_pos)
+					if (leftover_path.size() == 1 && leftover_path[0] == SceneStringNames::get_singleton()->transform_pos) {
 						pa.special = SP_NODE2D_POS;
-					else if (leftover_path.size() == 1 && leftover_path[0] == SceneStringNames::get_singleton()->transform_rot)
+					} else if (leftover_path.size() == 1 && leftover_path[0] == SceneStringNames::get_singleton()->transform_rot) {
 						pa.special = SP_NODE2D_ROT;
-					else if (leftover_path.size() == 1 && leftover_path[0] == SceneStringNames::get_singleton()->transform_scale)
+					} else if (leftover_path.size() == 1 && leftover_path[0] == SceneStringNames::get_singleton()->transform_scale) {
 						pa.special = SP_NODE2D_SCALE;
+					}
 				}
 				p_anim->node_cache[i]->property_anim[a->track_get_path(i).get_concatenated_subnames()] = pa;
 			}
 		}
 
 		if (a->track_get_type(i) == Animation::TYPE_BEZIER && leftover_path.size()) {
-
 			if (!p_anim->node_cache[i]->bezier_anim.has(a->track_get_path(i).get_concatenated_subnames())) {
-
 				TrackNodeCache::BezierAnim ba;
 				ba.bezier_property = leftover_path;
 				ba.object = resource.is_valid() ? (Object *)resource.ptr() : (Object *)child;
@@ -342,7 +322,6 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim) {
 }
 
 void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float p_time, float p_delta, float p_interp, bool p_is_current, bool p_seeked, bool p_started) {
-
 	_ensure_node_caches(p_anim);
 	ERR_FAIL_COND(p_anim->node_cache.size() != p_anim->animation->get_track_count());
 
@@ -350,7 +329,6 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 	bool can_call = is_inside_tree() && !Engine::get_singleton()->is_editor_hint();
 
 	for (int i = 0; i < a->get_track_count(); i++) {
-
 		// If an animation changes this animation (or it animates itself)
 		// we need to recreate our animation cache
 		if (p_anim->node_cache.size() != a->get_track_count()) {
@@ -359,21 +337,23 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 		TrackNodeCache *nc = p_anim->node_cache[i];
 
-		if (!nc)
+		if (!nc) {
 			continue; // no node cache for this track, skip it
+		}
 
-		if (!a->track_is_enabled(i))
+		if (!a->track_is_enabled(i)) {
 			continue; // do nothing if the track is disabled
+		}
 
-		if (a->track_get_key_count(i) == 0)
+		if (a->track_get_key_count(i) == 0) {
 			continue; // do nothing if track is empty
+		}
 
 		switch (a->track_get_type(i)) {
-
 			case Animation::TYPE_TRANSFORM: {
-
-				if (!nc->spatial)
+				if (!nc->spatial) {
 					continue;
+				}
 
 				Vector3 loc;
 				Quat rot;
@@ -382,8 +362,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 				Error err = a->transform_track_interpolate(i, p_time, &loc, &rot, &scale);
 				//ERR_CONTINUE(err!=OK); //used for testing, should be removed
 
-				if (err != OK)
+				if (err != OK) {
 					continue;
+				}
 
 				if (nc->accum_pass != accum_pass) {
 					ERR_CONTINUE(cache_update_size >= NODE_CACHE_UPDATE_MAX);
@@ -394,7 +375,6 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 					nc->scale_accum = scale;
 
 				} else {
-
 					nc->loc_accum = nc->loc_accum.lerp(loc, p_interp);
 					nc->rot_accum = nc->rot_accum.slerp(rot, p_interp);
 					nc->scale_accum = nc->scale_accum.lerp(scale, p_interp);
@@ -402,9 +382,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 			} break;
 			case Animation::TYPE_VALUE: {
-
-				if (!nc->node)
+				if (!nc->node) {
 					continue;
+				}
 
 				//StringName property=a->track_get_path(i).get_property();
 
@@ -416,14 +396,14 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 				Animation::UpdateMode update_mode = a->value_track_get_update_mode(i);
 
 				if (update_mode == Animation::UPDATE_CAPTURE) {
-
 					if (p_started) {
 						pa->capture = pa->object->get_indexed(pa->subpath);
 					}
 
 					int key_count = a->track_get_key_count(i);
-					if (key_count == 0)
+					if (key_count == 0) {
 						continue; //eeh not worth it
+					}
 
 					float first_key_time = a->track_get_key_time(i, 0);
 					float transition = 1.0;
@@ -431,8 +411,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 					if (first_key_time == 0.0) {
 						//ignore, use for transition
-						if (key_count == 1)
+						if (key_count == 1) {
 							continue; //with one key we can't do anything
+						}
 						transition = a->track_get_key_transition(i, 0);
 						first_key_time = a->track_get_key_time(i, 1);
 						first_key = 1;
@@ -461,8 +442,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 					Variant value = a->value_track_interpolate(i, p_time);
 
-					if (value == Variant())
+					if (value == Variant()) {
 						continue;
+					}
 
 					//thanks to trigger mode, this should be solved now..
 					/*
@@ -479,15 +461,12 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 					}
 
 				} else if (p_is_current && p_delta != 0) {
-
 					List<int> indices;
 					a->value_track_get_key_indices(i, p_time, p_delta, &indices);
 
 					for (List<int>::Element *F = indices.front(); F; F = F->next()) {
-
 						Variant value = a->track_get_key_value(i, F->get());
 						switch (pa->special) {
-
 							case SP_NONE: {
 								bool valid;
 								pa->object->set_indexed(pa->subpath, value, &valid); //you are not speshul
@@ -530,21 +509,21 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 			} break;
 			case Animation::TYPE_METHOD: {
-
-				if (!nc->node)
+				if (!nc->node) {
 					continue;
+				}
 				if (p_delta == 0) {
 					continue;
 				}
-				if (!p_is_current)
+				if (!p_is_current) {
 					break;
+				}
 
 				List<int> indices;
 
 				a->method_track_get_key_indices(i, p_time, p_delta, &indices);
 
 				for (List<int>::Element *E = indices.front(); E; E = E->next()) {
-
 					StringName method = a->method_track_get_name(i, E->get());
 					Vector<Variant> params = a->method_track_get_params(i, E->get());
 
@@ -581,9 +560,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 			} break;
 			case Animation::TYPE_BEZIER: {
-
-				if (!nc->node)
+				if (!nc->node) {
 					continue;
+				}
 
 				Map<StringName, TrackNodeCache::BezierAnim>::Element *E = nc->bezier_anim.find(a->track_get_path(i).get_concatenated_subnames());
 				ERR_CONTINUE(!E); //should it continue, or create a new one?
@@ -602,9 +581,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 			} break;
 			case Animation::TYPE_AUDIO: {
-
-				if (!nc->node)
+				if (!nc->node) {
 					continue;
+				}
 				if (p_delta == 0) {
 					continue;
 				}
@@ -612,8 +591,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 				if (p_seeked) {
 					//find whathever should be playing
 					int idx = a->track_find_key(i, p_time);
-					if (idx < 0)
+					if (idx < 0) {
 						continue;
+					}
 
 					Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
 					if (!stream.is_valid()) {
@@ -678,7 +658,6 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 							nc->audio_start = p_time;
 						}
 					} else if (nc->audio_playing) {
-
 						bool loop = a->has_loop();
 
 						bool stop = false;
@@ -704,22 +683,24 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 			} break;
 			case Animation::TYPE_ANIMATION: {
-
 				AnimationPlayer *player = Object::cast_to<AnimationPlayer>(nc->node);
-				if (!player)
+				if (!player) {
 					continue;
+				}
 
 				if (p_delta == 0 || p_seeked) {
 					//seek
 					int idx = a->track_find_key(i, p_time);
-					if (idx < 0)
+					if (idx < 0) {
 						continue;
+					}
 
 					float pos = a->track_get_key_time(i, idx);
 
 					StringName anim_name = a->animation_track_get_key_animation(i, idx);
-					if (String(anim_name) == "[stop]" || !player->has_animation(anim_name))
+					if (String(anim_name) == "[stop]" || !player->has_animation(anim_name)) {
 						continue;
+					}
 
 					Ref<Animation> anim = player->get_animation(anim_name);
 
@@ -749,7 +730,6 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 						StringName anim_name = a->animation_track_get_key_animation(i, idx);
 						if (String(anim_name) == "[stop]" || !player->has_animation(anim_name)) {
-
 							if (playing_caches.has(nc)) {
 								playing_caches.erase(nc);
 								player->stop();
@@ -769,7 +749,6 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 }
 
 void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, float p_blend, bool p_seeked, bool p_started) {
-
 	float delta = p_delta * speed_scale * cd.speed_scale;
 	float next_pos = cd.pos + delta;
 
@@ -777,17 +756,16 @@ void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, f
 	bool loop = cd.from->animation->has_loop();
 
 	if (!loop) {
-
-		if (next_pos < 0)
+		if (next_pos < 0) {
 			next_pos = 0;
-		else if (next_pos > len)
+		} else if (next_pos > len) {
 			next_pos = len;
+		}
 
 		// fix delta
 		delta = next_pos - cd.pos;
 
 		if (&cd == &playback.current) {
-
 			bool backwards = delta < 0;
 
 			if (!backwards && cd.pos <= len && next_pos == len /*&& playback.blend.empty()*/) {
@@ -804,7 +782,6 @@ void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, f
 		}
 
 	} else {
-
 		float looped_next_pos = Math::fposmod(next_pos, len);
 		if (looped_next_pos == 0 && next_pos != 0) {
 			// Loop multiples of the length to it, rather than 0
@@ -819,8 +796,8 @@ void AnimationPlayer::_animation_process_data(PlaybackData &cd, float p_delta, f
 
 	_animation_process_animation(cd.from, cd.pos, delta, p_blend, &cd == &playback.current, p_seeked, p_started);
 }
-void AnimationPlayer::_animation_process2(float p_delta, bool p_started) {
 
+void AnimationPlayer::_animation_process2(float p_delta, bool p_started) {
 	Playback &c = playback;
 
 	accum_pass++;
@@ -832,7 +809,6 @@ void AnimationPlayer::_animation_process2(float p_delta, bool p_started) {
 
 	List<Blend>::Element *prev = nullptr;
 	for (List<Blend>::Element *E = c.blend.back(); E; E = prev) {
-
 		Blend &b = E->get();
 		float blend = b.blend_left / b.blend_time;
 		_animation_process_data(b.data, p_delta, blend, false, false);
@@ -841,7 +817,6 @@ void AnimationPlayer::_animation_process2(float p_delta, bool p_started) {
 
 		prev = E->prev();
 		if (b.blend_left < 0) {
-
 			c.blend.erase(E);
 		}
 	}
@@ -851,7 +826,6 @@ void AnimationPlayer::_animation_update_transforms() {
 	{
 		Transform t;
 		for (int i = 0; i < cache_update_size; i++) {
-
 			TrackNodeCache *nc = cache_update[i];
 
 			ERR_CONTINUE(nc->accum_pass != accum_pass);
@@ -859,11 +833,9 @@ void AnimationPlayer::_animation_update_transforms() {
 			t.origin = nc->loc_accum;
 			t.basis.set_quat_scale(nc->rot_accum, nc->scale_accum);
 			if (nc->skeleton && nc->bone_idx >= 0) {
-
 				nc->skeleton->set_bone_pose(nc->bone_idx, t);
 
 			} else if (nc->spatial) {
-
 				nc->spatial->set_transform(t);
 			}
 		}
@@ -872,13 +844,11 @@ void AnimationPlayer::_animation_update_transforms() {
 	cache_update_size = 0;
 
 	for (int i = 0; i < cache_update_prop_size; i++) {
-
 		TrackNodeCache::PropertyAnim *pa = cache_update_prop[i];
 
 		ERR_CONTINUE(pa->accum_pass != accum_pass);
 
 		switch (pa->special) {
-
 			case SP_NONE: {
 				bool valid;
 				pa->object->set_indexed(pa->subpath, pa->value_accum, &valid); //you are not speshul
@@ -921,7 +891,6 @@ void AnimationPlayer::_animation_update_transforms() {
 	cache_update_prop_size = 0;
 
 	for (int i = 0; i < cache_update_bezier_size; i++) {
-
 		TrackNodeCache::BezierAnim *ba = cache_update_bezier[i];
 
 		ERR_CONTINUE(ba->accum_pass != accum_pass);
@@ -932,9 +901,7 @@ void AnimationPlayer::_animation_update_transforms() {
 }
 
 void AnimationPlayer::_animation_process(float p_delta) {
-
 	if (playback.current.from) {
-
 		end_reached = false;
 		end_notify = false;
 		_animation_process2(p_delta, playback.started);
@@ -950,14 +917,16 @@ void AnimationPlayer::_animation_process(float p_delta) {
 				play(queued.front()->get());
 				String new_name = playback.assigned;
 				queued.pop_front();
-				if (end_notify)
+				if (end_notify) {
 					emit_signal(SceneStringNames::get_singleton()->animation_changed, old, new_name);
+				}
 			} else {
 				//stop();
 				playing = false;
 				_set_process(false);
-				if (end_notify)
+				if (end_notify) {
 					emit_signal(SceneStringNames::get_singleton()->animation_finished, playback.assigned);
+				}
 			}
 			end_reached = false;
 		}
@@ -968,7 +937,6 @@ void AnimationPlayer::_animation_process(float p_delta) {
 }
 
 Error AnimationPlayer::add_animation(const StringName &p_name, const Ref<Animation> &p_animation) {
-
 #ifdef DEBUG_ENABLED
 	ERR_FAIL_COND_V_MSG(String(p_name).find("/") != -1 || String(p_name).find(":") != -1 || String(p_name).find(",") != -1 || String(p_name).find("[") != -1, ERR_INVALID_PARAMETER, "Invalid animation name: " + String(p_name) + ".");
 #endif
@@ -976,12 +944,10 @@ Error AnimationPlayer::add_animation(const StringName &p_name, const Ref<Animati
 	ERR_FAIL_COND_V(p_animation.is_null(), ERR_INVALID_PARAMETER);
 
 	if (animation_set.has(p_name)) {
-
 		_unref_anim(animation_set[p_name].animation);
 		animation_set[p_name].animation = p_animation;
 		clear_caches();
 	} else {
-
 		AnimationData ad;
 		ad.animation = p_animation;
 		ad.name = p_name;
@@ -994,7 +960,6 @@ Error AnimationPlayer::add_animation(const StringName &p_name, const Ref<Animati
 }
 
 void AnimationPlayer::remove_animation(const StringName &p_name) {
-
 	ERR_FAIL_COND(!animation_set.has(p_name));
 
 	stop();
@@ -1006,17 +971,14 @@ void AnimationPlayer::remove_animation(const StringName &p_name) {
 }
 
 void AnimationPlayer::_ref_anim(const Ref<Animation> &p_anim) {
-
 	Ref<Animation>(p_anim)->connect(SceneStringNames::get_singleton()->tracks_changed, callable_mp(this, &AnimationPlayer::_animation_changed), varray(), CONNECT_REFERENCE_COUNTED);
 }
 
 void AnimationPlayer::_unref_anim(const Ref<Animation> &p_anim) {
-
 	Ref<Animation>(p_anim)->disconnect(SceneStringNames::get_singleton()->tracks_changed, callable_mp(this, &AnimationPlayer::_animation_changed));
 }
 
 void AnimationPlayer::rename_animation(const StringName &p_name, const StringName &p_new_name) {
-
 	ERR_FAIL_COND(!animation_set.has(p_name));
 	ERR_FAIL_COND(String(p_new_name).find("/") != -1 || String(p_new_name).find(":") != -1);
 	ERR_FAIL_COND(animation_set.has(p_new_name));
@@ -1030,7 +992,6 @@ void AnimationPlayer::rename_animation(const StringName &p_name, const StringNam
 	List<BlendKey> to_erase;
 	Map<BlendKey, float> to_insert;
 	for (Map<BlendKey, float>::Element *E = blend_times.front(); E; E = E->next()) {
-
 		BlendKey bk = E->key();
 		BlendKey new_bk = bk;
 		bool erase = false;
@@ -1050,7 +1011,6 @@ void AnimationPlayer::rename_animation(const StringName &p_name, const StringNam
 	}
 
 	while (to_erase.size()) {
-
 		blend_times.erase(to_erase.front()->get());
 		to_erase.pop_front();
 	}
@@ -1060,73 +1020,71 @@ void AnimationPlayer::rename_animation(const StringName &p_name, const StringNam
 		to_insert.erase(to_insert.front());
 	}
 
-	if (autoplay == p_name)
+	if (autoplay == p_name) {
 		autoplay = p_new_name;
+	}
 
 	clear_caches();
 	_change_notify();
 }
 
 bool AnimationPlayer::has_animation(const StringName &p_name) const {
-
 	return animation_set.has(p_name);
 }
-Ref<Animation> AnimationPlayer::get_animation(const StringName &p_name) const {
 
+Ref<Animation> AnimationPlayer::get_animation(const StringName &p_name) const {
 	ERR_FAIL_COND_V(!animation_set.has(p_name), Ref<Animation>());
 
 	const AnimationData &data = animation_set[p_name];
 
 	return data.animation;
 }
-void AnimationPlayer::get_animation_list(List<StringName> *p_animations) const {
 
+void AnimationPlayer::get_animation_list(List<StringName> *p_animations) const {
 	List<String> anims;
 
 	for (Map<StringName, AnimationData>::Element *E = animation_set.front(); E; E = E->next()) {
-
 		anims.push_back(E->key());
 	}
 
 	anims.sort();
 
 	for (List<String>::Element *E = anims.front(); E; E = E->next()) {
-
 		p_animations->push_back(E->get());
 	}
 }
 
 void AnimationPlayer::set_blend_time(const StringName &p_animation1, const StringName &p_animation2, float p_time) {
-
 	ERR_FAIL_COND_MSG(p_time < 0, "Blend time cannot be smaller than 0.");
 
 	BlendKey bk;
 	bk.from = p_animation1;
 	bk.to = p_animation2;
-	if (p_time == 0)
+	if (p_time == 0) {
 		blend_times.erase(bk);
-	else
+	} else {
 		blend_times[bk] = p_time;
+	}
 }
 
 float AnimationPlayer::get_blend_time(const StringName &p_animation1, const StringName &p_animation2) const {
-
 	BlendKey bk;
 	bk.from = p_animation1;
 	bk.to = p_animation2;
 
-	if (blend_times.has(bk))
+	if (blend_times.has(bk)) {
 		return blend_times[bk];
-	else
+	} else {
 		return 0;
+	}
 }
 
 void AnimationPlayer::queue(const StringName &p_name) {
-
-	if (!is_playing())
+	if (!is_playing()) {
 		play(p_name);
-	else
+	} else {
 		queued.push_back(p_name);
+	}
 }
 
 Vector<String> AnimationPlayer::get_queue() {
@@ -1143,23 +1101,21 @@ void AnimationPlayer::clear_queue() {
 }
 
 void AnimationPlayer::play_backwards(const StringName &p_name, float p_custom_blend) {
-
 	play(p_name, p_custom_blend, -1, true);
 }
 
 void AnimationPlayer::play(const StringName &p_name, float p_custom_blend, float p_custom_scale, bool p_from_end) {
-
 	StringName name = p_name;
 
-	if (String(name) == "")
+	if (String(name) == "") {
 		name = playback.assigned;
+	}
 
 	ERR_FAIL_COND_MSG(!animation_set.has(name), "Animation not found: " + name + ".");
 
 	Playback &c = playback;
 
 	if (c.current.from) {
-
 		float blend_time = 0;
 		// find if it can blend
 		BlendKey bk;
@@ -1169,30 +1125,25 @@ void AnimationPlayer::play(const StringName &p_name, float p_custom_blend, float
 		if (p_custom_blend >= 0) {
 			blend_time = p_custom_blend;
 		} else if (blend_times.has(bk)) {
-
 			blend_time = blend_times[bk];
 		} else {
-
 			bk.from = "*";
 			if (blend_times.has(bk)) {
-
 				blend_time = blend_times[bk];
 			} else {
-
 				bk.from = c.current.from->name;
 				bk.to = "*";
 
 				if (blend_times.has(bk)) {
-
 					blend_time = blend_times[bk];
 				}
 			}
 		}
 
-		if (p_custom_blend < 0 && blend_time == 0 && default_blend_time)
+		if (p_custom_blend < 0 && blend_time == 0 && default_blend_time) {
 			blend_time = default_blend_time;
+		}
 		if (blend_time > 0) {
-
 			Blend b;
 			b.data = c.current;
 			b.blend_time = b.blend_left = blend_time;
@@ -1223,15 +1174,17 @@ void AnimationPlayer::play(const StringName &p_name, float p_custom_blend, float
 	c.seeked = false;
 	c.started = true;
 
-	if (!end_reached)
+	if (!end_reached) {
 		queued.clear();
+	}
 	_set_process(true); // always process when starting an animation
 	playing = true;
 
 	emit_signal(SceneStringNames::get_singleton()->animation_started, c.assigned);
 
-	if (is_inside_tree() && Engine::get_singleton()->is_editor_hint())
+	if (is_inside_tree() && Engine::get_singleton()->is_editor_hint()) {
 		return; // no next in this case
+	}
 
 	StringName next = animation_get_next(p_name);
 	if (next != StringName() && animation_set.has(next)) {
@@ -1240,12 +1193,10 @@ void AnimationPlayer::play(const StringName &p_name, float p_custom_blend, float
 }
 
 bool AnimationPlayer::is_playing() const {
-
 	return playing;
 }
 
 void AnimationPlayer::set_current_animation(const String &p_anim) {
-
 	if (p_anim == "[stop]" || p_anim == "") {
 		stop();
 	} else if (!is_playing() || playback.assigned != p_anim) {
@@ -1256,12 +1207,10 @@ void AnimationPlayer::set_current_animation(const String &p_anim) {
 }
 
 String AnimationPlayer::get_current_animation() const {
-
 	return (is_playing() ? playback.assigned : "");
 }
 
 void AnimationPlayer::set_assigned_animation(const String &p_anim) {
-
 	if (is_playing()) {
 		play(p_anim);
 	} else {
@@ -1273,12 +1222,10 @@ void AnimationPlayer::set_assigned_animation(const String &p_anim) {
 }
 
 String AnimationPlayer::get_assigned_animation() const {
-
 	return playback.assigned;
 }
 
 void AnimationPlayer::stop(bool p_reset) {
-
 	_stop_playing_caches();
 	Playback &c = playback;
 	c.blend.clear();
@@ -1293,15 +1240,14 @@ void AnimationPlayer::stop(bool p_reset) {
 }
 
 void AnimationPlayer::set_speed_scale(float p_speed) {
-
 	speed_scale = p_speed;
 }
-float AnimationPlayer::get_speed_scale() const {
 
+float AnimationPlayer::get_speed_scale() const {
 	return speed_scale;
 }
-float AnimationPlayer::get_playing_speed() const {
 
+float AnimationPlayer::get_playing_speed() const {
 	if (!playing) {
 		return 0;
 	}
@@ -1309,7 +1255,6 @@ float AnimationPlayer::get_playing_speed() const {
 }
 
 void AnimationPlayer::seek(float p_time, bool p_update) {
-
 	if (!playback.current.from) {
 		if (playback.assigned) {
 			ERR_FAIL_COND(!animation_set.has(playback.assigned));
@@ -1326,7 +1271,6 @@ void AnimationPlayer::seek(float p_time, bool p_update) {
 }
 
 void AnimationPlayer::seek_delta(float p_time, float p_delta) {
-
 	if (!playback.current.from) {
 		if (playback.assigned) {
 			ERR_FAIL_COND(!animation_set.has(playback.assigned));
@@ -1336,31 +1280,28 @@ void AnimationPlayer::seek_delta(float p_time, float p_delta) {
 	}
 
 	playback.current.pos = p_time - p_delta;
-	if (speed_scale != 0.0)
+	if (speed_scale != 0.0) {
 		p_delta /= speed_scale;
+	}
 	_animation_process(p_delta);
 	//playback.current.pos=p_time;
 }
 
 bool AnimationPlayer::is_valid() const {
-
 	return (playback.current.from);
 }
 
 float AnimationPlayer::get_current_animation_position() const {
-
 	ERR_FAIL_COND_V(!playback.current.from, 0);
 	return playback.current.pos;
 }
 
 float AnimationPlayer::get_current_animation_length() const {
-
 	ERR_FAIL_COND_V(!playback.current.from, 0);
 	return playback.current.from->animation->get_length();
 }
 
 void AnimationPlayer::_animation_changed() {
-
 	clear_caches();
 	emit_signal("caches_cleared");
 	if (is_playing()) {
@@ -1369,16 +1310,15 @@ void AnimationPlayer::_animation_changed() {
 }
 
 void AnimationPlayer::_stop_playing_caches() {
-
 	for (Set<TrackNodeCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
-
 		if (E->get()->node && E->get()->audio_playing) {
 			E->get()->node->call("stop");
 		}
 		if (E->get()->node && E->get()->animation_playing) {
 			AnimationPlayer *player = Object::cast_to<AnimationPlayer>(E->get()->node);
-			if (!player)
+			if (!player) {
 				continue;
+			}
 			player->stop();
 		}
 	}
@@ -1387,18 +1327,15 @@ void AnimationPlayer::_stop_playing_caches() {
 }
 
 void AnimationPlayer::_node_removed(Node *p_node) {
-
 	clear_caches(); // nodes contained here ar being removed, clear the caches
 }
 
 void AnimationPlayer::clear_caches() {
-
 	_stop_playing_caches();
 
 	node_cache_map.clear();
 
 	for (Map<StringName, AnimationData>::Element *E = animation_set.front(); E; E = E->next()) {
-
 		E->get().node_cache.clear();
 	}
 
@@ -1408,77 +1345,73 @@ void AnimationPlayer::clear_caches() {
 }
 
 void AnimationPlayer::set_active(bool p_active) {
-
-	if (active == p_active)
+	if (active == p_active) {
 		return;
+	}
 
 	active = p_active;
 	_set_process(processing, true);
 }
 
 bool AnimationPlayer::is_active() const {
-
 	return active;
 }
 
 StringName AnimationPlayer::find_animation(const Ref<Animation> &p_animation) const {
-
 	for (Map<StringName, AnimationData>::Element *E = animation_set.front(); E; E = E->next()) {
-
-		if (E->get().animation == p_animation)
+		if (E->get().animation == p_animation) {
 			return E->key();
+		}
 	}
 
 	return "";
 }
 
 void AnimationPlayer::set_autoplay(const String &p_name) {
-	if (is_inside_tree() && !Engine::get_singleton()->is_editor_hint())
+	if (is_inside_tree() && !Engine::get_singleton()->is_editor_hint()) {
 		WARN_PRINT("Setting autoplay after the node has been added to the scene has no effect.");
+	}
 
 	autoplay = p_name;
 }
 
 String AnimationPlayer::get_autoplay() const {
-
 	return autoplay;
 }
 
 void AnimationPlayer::set_animation_process_mode(AnimationProcessMode p_mode) {
-
-	if (animation_process_mode == p_mode)
+	if (animation_process_mode == p_mode) {
 		return;
+	}
 
 	bool pr = processing;
-	if (pr)
+	if (pr) {
 		_set_process(false);
+	}
 	animation_process_mode = p_mode;
-	if (pr)
+	if (pr) {
 		_set_process(true);
+	}
 }
 
 AnimationPlayer::AnimationProcessMode AnimationPlayer::get_animation_process_mode() const {
-
 	return animation_process_mode;
 }
 
 void AnimationPlayer::set_method_call_mode(AnimationMethodCallMode p_mode) {
-
 	method_call_mode = p_mode;
 }
 
 AnimationPlayer::AnimationMethodCallMode AnimationPlayer::get_method_call_mode() const {
-
 	return method_call_mode;
 }
 
 void AnimationPlayer::_set_process(bool p_process, bool p_force) {
-
-	if (processing == p_process && !p_force)
+	if (processing == p_process && !p_force) {
 		return;
+	}
 
 	switch (animation_process_mode) {
-
 		case ANIMATION_PROCESS_PHYSICS:
 			set_physics_process_internal(p_process && active);
 			break;
@@ -1493,41 +1426,35 @@ void AnimationPlayer::_set_process(bool p_process, bool p_force) {
 }
 
 void AnimationPlayer::animation_set_next(const StringName &p_animation, const StringName &p_next) {
-
 	ERR_FAIL_COND(!animation_set.has(p_animation));
 	animation_set[p_animation].next = p_next;
 }
 
 StringName AnimationPlayer::animation_get_next(const StringName &p_animation) const {
-
-	if (!animation_set.has(p_animation))
+	if (!animation_set.has(p_animation)) {
 		return StringName();
+	}
 	return animation_set[p_animation].next;
 }
 
 void AnimationPlayer::set_default_blend_time(float p_default) {
-
 	default_blend_time = p_default;
 }
 
 float AnimationPlayer::get_default_blend_time() const {
-
 	return default_blend_time;
 }
 
 void AnimationPlayer::set_root(const NodePath &p_root) {
-
 	root = p_root;
 	clear_caches();
 }
 
 NodePath AnimationPlayer::get_root() const {
-
 	return root;
 }
 
 void AnimationPlayer::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {
-
 #ifdef TOOLS_ENABLED
 	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", 0) ? "'" : "\"";
 #else
@@ -1539,7 +1466,6 @@ void AnimationPlayer::get_argument_options(const StringName &p_function, int p_i
 		List<StringName> al;
 		get_animation_list(&al);
 		for (List<StringName>::Element *E = al.front(); E; E = E->next()) {
-
 			r_options->push_back(quote_style + String(E->get()) + quote_style);
 		}
 	}
@@ -1548,9 +1474,9 @@ void AnimationPlayer::get_argument_options(const StringName &p_function, int p_i
 
 #ifdef TOOLS_ENABLED
 AnimatedValuesBackup AnimationPlayer::backup_animated_values() {
-
-	if (!playback.current.from)
+	if (!playback.current.from) {
 		return AnimatedValuesBackup();
+	}
 
 	_ensure_node_caches(playback.current.from);
 
@@ -1558,12 +1484,14 @@ AnimatedValuesBackup AnimationPlayer::backup_animated_values() {
 
 	for (int i = 0; i < playback.current.from->node_cache.size(); i++) {
 		TrackNodeCache *nc = playback.current.from->node_cache[i];
-		if (!nc)
+		if (!nc) {
 			continue;
+		}
 
 		if (nc->skeleton) {
-			if (nc->bone_idx == -1)
+			if (nc->bone_idx == -1) {
 				continue;
+			}
 
 			AnimatedValuesBackup::Entry entry;
 			entry.object = nc->skeleton;
@@ -1586,8 +1514,9 @@ AnimatedValuesBackup AnimationPlayer::backup_animated_values() {
 					bool valid;
 					entry.value = E->value().object->get_indexed(E->value().subpath, &valid);
 					entry.bone_idx = -1;
-					if (valid)
+					if (valid) {
 						backup.entries.push_back(entry);
+					}
 				}
 			}
 		}
@@ -1597,9 +1526,7 @@ AnimatedValuesBackup AnimationPlayer::backup_animated_values() {
 }
 
 void AnimationPlayer::restore_animated_values(const AnimatedValuesBackup &p_backup) {
-
 	for (int i = 0; i < p_backup.entries.size(); i++) {
-
 		const AnimatedValuesBackup::Entry *entry = &p_backup.entries[i];
 		if (entry->bone_idx == -1) {
 			entry->object->set_indexed(entry->subpath, entry->value);
@@ -1697,7 +1624,6 @@ void AnimationPlayer::_bind_methods() {
 }
 
 AnimationPlayer::AnimationPlayer() {
-
 	accum_pass = 1;
 	cache_update_size = 0;
 	cache_update_prop_size = 0;
diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h
index d709082f62..1a66665803 100644
--- a/scene/animation/animation_player.h
+++ b/scene/animation/animation_player.h
@@ -85,7 +85,6 @@ private:
 	};
 
 	struct TrackNodeCache {
-
 		NodePath path;
 		uint32_t id = 0;
 		RES resource;
@@ -108,7 +107,6 @@ private:
 		bool animation_playing = false;
 
 		struct PropertyAnim {
-
 			TrackNodeCache *owner = nullptr;
 			SpecialProperty special = SP_NONE; //small optimization
 			Vector<StringName> subpath;
@@ -123,7 +121,6 @@ private:
 		Map<StringName, PropertyAnim> property_anim;
 
 		struct BezierAnim {
-
 			Vector<StringName> bezier_property;
 			TrackNodeCache *owner = nullptr;
 			float bezier_accum = 0.0;
@@ -139,16 +136,15 @@ private:
 	};
 
 	struct TrackNodeCacheKey {
-
 		ObjectID id;
 		int bone_idx;
 
 		inline bool operator<(const TrackNodeCacheKey &p_right) const {
-
-			if (id == p_right.id)
+			if (id == p_right.id) {
 				return bone_idx < p_right.bone_idx;
-			else
+			} else {
 				return id < p_right.id;
+			}
 		}
 	};
 
@@ -175,7 +171,6 @@ private:
 
 	Map<StringName, AnimationData> animation_set;
 	struct BlendKey {
-
 		StringName from;
 		StringName to;
 		bool operator<(const BlendKey &bk) const { return from == bk.from ? String(to) < String(bk.to) : String(from) < String(bk.from); }
@@ -184,13 +179,11 @@ private:
 	Map<BlendKey, float> blend_times;
 
 	struct PlaybackData {
-
 		AnimationData *from;
 		float pos;
 		float speed_scale;
 
 		PlaybackData() {
-
 			pos = 0;
 			speed_scale = 1.0;
 			from = nullptr;
@@ -198,21 +191,18 @@ private:
 	};
 
 	struct Blend {
-
 		PlaybackData data;
 
 		float blend_time;
 		float blend_left;
 
 		Blend() {
-
 			blend_left = 0;
 			blend_time = 0;
 		}
 	};
 
 	struct Playback {
-
 		List<Blend> blend;
 		PlaybackData current;
 		StringName assigned;
@@ -246,12 +236,10 @@ private:
 
 	// bind helpers
 	Vector<String> _get_animation_list() const {
-
 		List<StringName> animations;
 		get_animation_list(&animations);
 		Vector<String> ret;
 		while (animations.size()) {
-
 			ret.push_back(animations.front()->get());
 			animations.pop_front();
 		}
diff --git a/scene/animation/animation_tree.cpp b/scene/animation/animation_tree.cpp
index 56e224819f..466536db10 100644
--- a/scene/animation/animation_tree.cpp
+++ b/scene/animation/animation_tree.cpp
@@ -73,7 +73,6 @@ Variant AnimationNode::get_parameter(const StringName &p_name) const {
 }
 
 void AnimationNode::get_child_nodes(List<ChildNode> *r_child_nodes) {
-
 	if (get_script_instance()) {
 		Dictionary cn = get_script_instance()->call("get_child_nodes");
 		List<Variant> keys;
@@ -88,14 +87,12 @@ void AnimationNode::get_child_nodes(List<ChildNode> *r_child_nodes) {
 }
 
 void AnimationNode::blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend) {
-
 	ERR_FAIL_COND(!state);
 	ERR_FAIL_COND(!state->player->has_animation(p_animation));
 
 	Ref<Animation> animation = state->player->get_animation(p_animation);
 
 	if (animation.is_null()) {
-
 		AnimationNodeBlendTree *btree = Object::cast_to<AnimationNodeBlendTree>(parent);
 		if (btree) {
 			String name = btree->get_node_name(Ref<AnimationNodeAnimation>(this));
@@ -120,7 +117,6 @@ void AnimationNode::blend_animation(const StringName &p_animation, float p_time,
 }
 
 float AnimationNode::_pre_process(const StringName &p_base_path, AnimationNode *p_parent, State *p_state, float p_time, bool p_seek, const Vector<StringName> &p_connections) {
-
 	base_path = p_base_path;
 	parent = p_parent;
 	connections = p_connections;
@@ -176,12 +172,10 @@ float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p
 }
 
 float AnimationNode::blend_node(const StringName &p_sub_path, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) {
-
 	return _blend_node(p_sub_path, Vector<StringName>(), this, p_node, p_time, p_seek, p_blend, p_filter, p_optimize);
 }
 
 float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<StringName> &p_connections, AnimationNode *p_new_parent, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize, float *r_max) {
-
 	ERR_FAIL_COND_V(!p_node.is_valid(), 0);
 	ERR_FAIL_COND_V(!state, 0);
 
@@ -197,7 +191,6 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 	bool any_valid = false;
 
 	if (has_filter() && is_filter_enabled() && p_filter != FILTER_IGNORE) {
-
 		for (int i = 0; i < blend_count; i++) {
 			blendw[i] = 0.0; //all to zero by default
 		}
@@ -217,8 +210,9 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 			case FILTER_PASS: {
 				//values filtered pass, the rest don't
 				for (int i = 0; i < blend_count; i++) {
-					if (blendw[i] == 0) //not filtered, does not pass
+					if (blendw[i] == 0) { //not filtered, does not pass
 						continue;
+					}
 
 					blendw[i] = blendr[i] * p_blend;
 					if (blendw[i] > CMP_EPSILON) {
@@ -228,12 +222,12 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 
 			} break;
 			case FILTER_STOP: {
-
 				//values filtered don't pass, the rest are blended
 
 				for (int i = 0; i < blend_count; i++) {
-					if (blendw[i] > 0) //filtered, does not pass
+					if (blendw[i] > 0) { //filtered, does not pass
 						continue;
+					}
 
 					blendw[i] = blendr[i] * p_blend;
 					if (blendw[i] > CMP_EPSILON) {
@@ -243,7 +237,6 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 
 			} break;
 			case FILTER_BLEND: {
-
 				//filtered values are blended, the rest are passed without blending
 
 				for (int i = 0; i < blend_count; i++) {
@@ -262,7 +255,6 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 		}
 	} else {
 		for (int i = 0; i < blend_count; i++) {
-
 			//regular blend
 			blendw[i] = blendr[i] * p_blend;
 			if (blendw[i] > CMP_EPSILON) {
@@ -278,8 +270,9 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 		}
 	}
 
-	if (!p_seek && p_optimize && !any_valid) //pointless to go on, all are zero
+	if (!p_seek && p_optimize && !any_valid) { //pointless to go on, all are zero
 		return 0;
+	}
 
 	String new_path;
 	AnimationNode *new_parent;
@@ -297,16 +290,15 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
 }
 
 int AnimationNode::get_input_count() const {
-
 	return inputs.size();
 }
+
 String AnimationNode::get_input_name(int p_input) {
 	ERR_FAIL_INDEX_V(p_input, inputs.size(), String());
 	return inputs[p_input].name;
 }
 
 String AnimationNode::get_caption() const {
-
 	if (get_script_instance()) {
 		return get_script_instance()->call("get_caption");
 	}
@@ -338,7 +330,6 @@ void AnimationNode::remove_input(int p_index) {
 }
 
 float AnimationNode::process(float p_time, bool p_seek) {
-
 	if (get_script_instance()) {
 		return get_script_instance()->call("process", p_time, p_seek);
 	}
@@ -371,7 +362,6 @@ bool AnimationNode::has_filter() const {
 }
 
 Array AnimationNode::_get_filters() const {
-
 	Array paths;
 
 	const NodePath *K = nullptr;
@@ -382,6 +372,7 @@ Array AnimationNode::_get_filters() const {
 
 	return paths;
 }
+
 void AnimationNode::_set_filters(const Array &p_filters) {
 	filter.clear();
 	for (int i = 0; i < p_filters.size(); i++) {
@@ -403,7 +394,6 @@ Ref<AnimationNode> AnimationNode::get_child_by_name(const StringName &p_name) {
 }
 
 void AnimationNode::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("get_input_count"), &AnimationNode::get_input_count);
 	ClassDB::bind_method(D_METHOD("get_input_name", "input"), &AnimationNode::get_input_name);
 
@@ -452,7 +442,6 @@ void AnimationNode::_bind_methods() {
 }
 
 AnimationNode::AnimationNode() {
-
 	state = nullptr;
 	parent = nullptr;
 	filter_enabled = false;
@@ -461,7 +450,6 @@ AnimationNode::AnimationNode() {
 ////////////////////
 
 void AnimationTree::set_tree_root(const Ref<AnimationNode> &p_root) {
-
 	if (root.is_valid()) {
 		root->disconnect("tree_changed", callable_mp(this, &AnimationTree::_tree_changed));
 	}
@@ -482,9 +470,9 @@ Ref<AnimationNode> AnimationTree::get_tree_root() const {
 }
 
 void AnimationTree::set_active(bool p_active) {
-
-	if (active == p_active)
+	if (active == p_active) {
 		return;
+	}
 
 	active = p_active;
 	started = active;
@@ -492,13 +480,11 @@ void AnimationTree::set_active(bool p_active) {
 	if (process_mode == ANIMATION_PROCESS_IDLE) {
 		set_process_internal(active);
 	} else {
-
 		set_physics_process_internal(active);
 	}
 
 	if (!active && is_inside_tree()) {
 		for (Set<TrackCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
-
 			if (ObjectDB::get_instance(E->get()->object_id)) {
 				E->get()->object->call("stop");
 			}
@@ -509,14 +495,13 @@ void AnimationTree::set_active(bool p_active) {
 }
 
 bool AnimationTree::is_active() const {
-
 	return active;
 }
 
 void AnimationTree::set_process_mode(AnimationProcessMode p_mode) {
-
-	if (process_mode == p_mode)
+	if (process_mode == p_mode) {
 		return;
+	}
 
 	bool was_active = is_active();
 	if (was_active) {
@@ -539,7 +524,6 @@ void AnimationTree::_node_removed(Node *p_node) {
 }
 
 bool AnimationTree::_update_caches(AnimationPlayer *player) {
-
 	setup_pass++;
 
 	if (!player->has_node(player->get_root())) {
@@ -572,7 +556,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 			}
 
 			if (!track) {
-
 				RES resource;
 				Vector<StringName> leftover_path;
 				Node *child = parent->get_node_and_resource(path, resource, leftover_path);
@@ -588,7 +571,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 
 				switch (track_type) {
 					case Animation::TYPE_VALUE: {
-
 						TrackCacheValue *track_value = memnew(TrackCacheValue);
 
 						if (resource.is_valid()) {
@@ -604,7 +586,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 
 					} break;
 					case Animation::TYPE_TRANSFORM: {
-
 						Node3D *spatial = Object::cast_to<Node3D>(child);
 
 						if (!spatial) {
@@ -619,11 +600,9 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 						track_xform->bone_idx = -1;
 
 						if (path.get_subname_count() == 1 && Object::cast_to<Skeleton3D>(spatial)) {
-
 							Skeleton3D *sk = Object::cast_to<Skeleton3D>(spatial);
 							int bone_idx = sk->find_bone(path.get_subname(0));
 							if (bone_idx != -1) {
-
 								track_xform->skeleton = sk;
 								track_xform->bone_idx = bone_idx;
 							}
@@ -636,7 +615,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 
 					} break;
 					case Animation::TYPE_METHOD: {
-
 						TrackCacheMethod *track_method = memnew(TrackCacheMethod);
 
 						if (resource.is_valid()) {
@@ -651,7 +629,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 
 					} break;
 					case Animation::TYPE_BEZIER: {
-
 						TrackCacheBezier *track_bezier = memnew(TrackCacheBezier);
 
 						if (resource.is_valid()) {
@@ -666,7 +643,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 						track = track_bezier;
 					} break;
 					case Animation::TYPE_AUDIO: {
-
 						TrackCacheAudio *track_audio = memnew(TrackCacheAudio);
 
 						track_audio->object = child;
@@ -676,7 +652,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 
 					} break;
 					case Animation::TYPE_ANIMATION: {
-
 						TrackCacheAnimation *track_animation = memnew(TrackCacheAnimation);
 
 						track_animation->object = child;
@@ -732,7 +707,6 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 }
 
 void AnimationTree::_clear_caches() {
-
 	const NodePath *K = nullptr;
 	while ((K = track_cache.next(K))) {
 		memdelete(track_cache[*K]);
@@ -744,7 +718,6 @@ void AnimationTree::_clear_caches() {
 }
 
 void AnimationTree::_process_graph(float p_delta) {
-
 	_update_properties(); //if properties need updating, update them
 
 	//check all tracks, see if they need modification
@@ -774,7 +747,6 @@ void AnimationTree::_process_graph(float p_delta) {
 	}
 
 	if (last_animation_player != current_animation_player) {
-
 		if (last_animation_player.is_valid()) {
 			Object *old_player = ObjectDB::get_instance(last_animation_player);
 			if (old_player) {
@@ -826,7 +798,6 @@ void AnimationTree::_process_graph(float p_delta) {
 	//process
 
 	{
-
 		if (started) {
 			//if started, seek
 			root->_pre_process(SceneStringNames::get_singleton()->parameters_base_path, nullptr, &state, 0, true, Vector<StringName>());
@@ -842,11 +813,9 @@ void AnimationTree::_process_graph(float p_delta) {
 	//apply value/transform/bezier blends to track caches and execute method/audio/animation tracks
 
 	{
-
 		bool can_call = is_inside_tree() && !Engine::get_singleton()->is_editor_hint();
 
 		for (List<AnimationNode::AnimationState>::Element *E = state.animation_states.front(); E; E = E->next()) {
-
 			const AnimationNode::AnimationState &as = E->get();
 
 			Ref<Animation> a = as.animation;
@@ -855,7 +824,6 @@ void AnimationTree::_process_graph(float p_delta) {
 			bool seeked = as.seeked;
 
 			for (int i = 0; i < a->get_track_count(); i++) {
-
 				NodePath path = a->track_get_path(i);
 
 				ERR_CONTINUE(!track_cache.has(path));
@@ -874,19 +842,16 @@ void AnimationTree::_process_graph(float p_delta) {
 
 				float blend = (*as.track_blends)[blend_idx];
 
-				if (blend < CMP_EPSILON)
+				if (blend < CMP_EPSILON) {
 					continue; //nothing to blend
+				}
 
 				switch (track->type) {
-
 					case Animation::TYPE_TRANSFORM: {
-
 						TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
 
 						if (track->root_motion) {
-
 							if (t->process_pass != process_pass) {
-
 								t->process_pass = process_pass;
 								t->loc = Vector3();
 								t->rot = Quat();
@@ -908,7 +873,6 @@ void AnimationTree::_process_graph(float p_delta) {
 							Vector3 scale[2];
 
 							if (prev_time > time) {
-
 								Error err = a->transform_track_interpolate(i, prev_time, &loc[0], &rot[0], &scale[0]);
 								if (err != OK) {
 									continue;
@@ -947,7 +911,6 @@ void AnimationTree::_process_graph(float p_delta) {
 							//ERR_CONTINUE(err!=OK); //used for testing, should be removed
 
 							if (t->process_pass != process_pass) {
-
 								t->process_pass = process_pass;
 								t->loc = loc;
 								t->rot = rot;
@@ -955,8 +918,9 @@ void AnimationTree::_process_graph(float p_delta) {
 								t->scale = scale;
 							}
 
-							if (err != OK)
+							if (err != OK) {
 								continue;
+							}
 
 							t->loc = t->loc.lerp(loc, blend);
 							if (t->rot_blend_accum == 0) {
@@ -972,7 +936,6 @@ void AnimationTree::_process_graph(float p_delta) {
 
 					} break;
 					case Animation::TYPE_VALUE: {
-
 						TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
 
 						Animation::UpdateMode update_mode = a->value_track_get_update_mode(i);
@@ -981,8 +944,9 @@ void AnimationTree::_process_graph(float p_delta) {
 
 							Variant value = a->value_track_interpolate(i, time);
 
-							if (value == Variant())
+							if (value == Variant()) {
 								continue;
+							}
 
 							if (t->process_pass != process_pass) {
 								t->value = value;
@@ -992,12 +956,10 @@ void AnimationTree::_process_graph(float p_delta) {
 							Variant::interpolate(t->value, value, blend, t->value);
 
 						} else if (delta != 0) {
-
 							List<int> indices;
 							a->value_track_get_key_indices(i, time, delta, &indices);
 
 							for (List<int>::Element *F = indices.front(); F; F = F->next()) {
-
 								Variant value = a->track_get_key_value(i, F->get());
 								t->object->set_indexed(t->subpath, value);
 							}
@@ -1005,7 +967,6 @@ void AnimationTree::_process_graph(float p_delta) {
 
 					} break;
 					case Animation::TYPE_METHOD: {
-
 						if (delta == 0) {
 							continue;
 						}
@@ -1016,7 +977,6 @@ void AnimationTree::_process_graph(float p_delta) {
 						a->method_track_get_key_indices(i, time, delta, &indices);
 
 						for (List<int>::Element *F = indices.front(); F; F = F->next()) {
-
 							StringName method = a->method_track_get_name(i, F->get());
 							Vector<Variant> params = a->method_track_get_params(i, F->get());
 
@@ -1036,7 +996,6 @@ void AnimationTree::_process_graph(float p_delta) {
 
 					} break;
 					case Animation::TYPE_BEZIER: {
-
 						TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
 
 						float bezier = a->bezier_track_interpolate(i, time);
@@ -1050,14 +1009,14 @@ void AnimationTree::_process_graph(float p_delta) {
 
 					} break;
 					case Animation::TYPE_AUDIO: {
-
 						TrackCacheAudio *t = static_cast<TrackCacheAudio *>(track);
 
 						if (seeked) {
 							//find whathever should be playing
 							int idx = a->track_find_key(i, time);
-							if (idx < 0)
+							if (idx < 0) {
 								continue;
+							}
 
 							Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
 							if (!stream.is_valid()) {
@@ -1122,7 +1081,6 @@ void AnimationTree::_process_graph(float p_delta) {
 									t->start = time;
 								}
 							} else if (t->playing) {
-
 								bool loop = a->has_loop();
 
 								bool stop = false;
@@ -1154,25 +1112,27 @@ void AnimationTree::_process_graph(float p_delta) {
 						}
 					} break;
 					case Animation::TYPE_ANIMATION: {
-
 						TrackCacheAnimation *t = static_cast<TrackCacheAnimation *>(track);
 
 						AnimationPlayer *player2 = Object::cast_to<AnimationPlayer>(t->object);
 
-						if (!player2)
+						if (!player2) {
 							continue;
+						}
 
 						if (delta == 0 || seeked) {
 							//seek
 							int idx = a->track_find_key(i, time);
-							if (idx < 0)
+							if (idx < 0) {
 								continue;
+							}
 
 							float pos = a->track_get_key_time(i, idx);
 
 							StringName anim_name = a->animation_track_get_key_animation(i, idx);
-							if (String(anim_name) == "[stop]" || !player2->has_animation(anim_name))
+							if (String(anim_name) == "[stop]" || !player2->has_animation(anim_name)) {
 								continue;
+							}
 
 							Ref<Animation> anim = player2->get_animation(anim_name);
 
@@ -1202,7 +1162,6 @@ void AnimationTree::_process_graph(float p_delta) {
 
 								StringName anim_name = a->animation_track_get_key_animation(i, idx);
 								if (String(anim_name) == "[stop]" || !player2->has_animation(anim_name)) {
-
 									if (playing_caches.has(t)) {
 										playing_caches.erase(t);
 										player2->stop();
@@ -1227,13 +1186,12 @@ void AnimationTree::_process_graph(float p_delta) {
 		const NodePath *K = nullptr;
 		while ((K = track_cache.next(K))) {
 			TrackCache *track = track_cache[*K];
-			if (track->process_pass != process_pass)
+			if (track->process_pass != process_pass) {
 				continue; //not processed, ignore
+			}
 
 			switch (track->type) {
-
 				case Animation::TYPE_TRANSFORM: {
-
 					TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
 
 					Transform xform;
@@ -1242,31 +1200,26 @@ void AnimationTree::_process_graph(float p_delta) {
 					xform.basis.set_quat_scale(t->rot, t->scale);
 
 					if (t->root_motion) {
-
 						root_motion_transform = xform;
 
 						if (t->skeleton && t->bone_idx >= 0) {
 							root_motion_transform = (t->skeleton->get_bone_rest(t->bone_idx) * root_motion_transform) * t->skeleton->get_bone_rest(t->bone_idx).affine_inverse();
 						}
 					} else if (t->skeleton && t->bone_idx >= 0) {
-
 						t->skeleton->set_bone_pose(t->bone_idx, xform);
 
 					} else {
-
 						t->spatial->set_transform(xform);
 					}
 
 				} break;
 				case Animation::TYPE_VALUE: {
-
 					TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
 
 					t->object->set_indexed(t->subpath, t->value);
 
 				} break;
 				case Animation::TYPE_BEZIER: {
-
 					TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
 
 					t->object->set_indexed(t->subpath, t->value);
@@ -1280,12 +1233,10 @@ void AnimationTree::_process_graph(float p_delta) {
 }
 
 void AnimationTree::advance(float p_time) {
-
 	_process_graph(p_time);
 }
 
 void AnimationTree::_notification(int p_what) {
-
 	if (active && p_what == NOTIFICATION_INTERNAL_PHYSICS_PROCESS && process_mode == ANIMATION_PROCESS_PHYSICS) {
 		_process_graph(get_physics_process_delta_time());
 	}
@@ -1297,7 +1248,6 @@ void AnimationTree::_notification(int p_what) {
 	if (p_what == NOTIFICATION_EXIT_TREE) {
 		_clear_caches();
 		if (last_animation_player.is_valid()) {
-
 			Object *player = ObjectDB::get_instance(last_animation_player);
 			if (player) {
 				player->disconnect("caches_cleared", callable_mp(this, &AnimationTree::_clear_caches));
@@ -1305,7 +1255,6 @@ void AnimationTree::_notification(int p_what) {
 		}
 	} else if (p_what == NOTIFICATION_ENTER_TREE) {
 		if (last_animation_player.is_valid()) {
-
 			Object *player = ObjectDB::get_instance(last_animation_player);
 			if (player) {
 				player->connect("caches_cleared", callable_mp(this, &AnimationTree::_clear_caches));
@@ -1324,11 +1273,10 @@ NodePath AnimationTree::get_animation_player() const {
 }
 
 bool AnimationTree::is_state_invalid() const {
-
 	return !state.valid;
 }
-String AnimationTree::get_invalid_state_reason() const {
 
+String AnimationTree::get_invalid_state_reason() const {
 	return state.invalid_reasons;
 }
 
@@ -1337,7 +1285,6 @@ uint64_t AnimationTree::get_last_process_pass() const {
 }
 
 String AnimationTree::get_configuration_warning() const {
-
 	String warning = Node::get_configuration_warning();
 
 	if (!root.is_valid()) {
@@ -1348,7 +1295,6 @@ String AnimationTree::get_configuration_warning() const {
 	}
 
 	if (!has_node(animation_player)) {
-
 		if (warning != String()) {
 			warning += "\n\n";
 		}
@@ -1402,13 +1348,11 @@ void AnimationTree::_tree_changed() {
 }
 
 void AnimationTree::_update_properties_for_node(const String &p_base_path, Ref<AnimationNode> node) {
-
 	if (!property_parent_map.has(p_base_path)) {
 		property_parent_map[p_base_path] = HashMap<StringName, StringName>();
 	}
 
 	if (node->get_input_count() && !input_activity_map.has(p_base_path)) {
-
 		Vector<Activity> activity;
 		for (int i = 0; i < node->get_input_count(); i++) {
 			Activity a;
@@ -1492,6 +1436,7 @@ bool AnimationTree::_get(const StringName &p_name, Variant &r_ret) const {
 
 	return false;
 }
+
 void AnimationTree::_get_property_list(List<PropertyInfo> *p_list) const {
 	if (properties_dirty) {
 		const_cast<AnimationTree *>(this)->_update_properties();
@@ -1503,7 +1448,6 @@ void AnimationTree::_get_property_list(List<PropertyInfo> *p_list) const {
 }
 
 void AnimationTree::rename_parameter(const String &p_base, const String &p_new_base) {
-
 	//rename values first
 	for (const List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
 		if (E->get().name.begins_with(p_base)) {
@@ -1518,7 +1462,6 @@ void AnimationTree::rename_parameter(const String &p_base, const String &p_new_b
 }
 
 float AnimationTree::get_connection_activity(const StringName &p_path, int p_connection) const {
-
 	if (!input_activity_map_get.has(p_path)) {
 		return 0;
 	}
@@ -1572,7 +1515,6 @@ void AnimationTree::_bind_methods() {
 }
 
 AnimationTree::AnimationTree() {
-
 	process_mode = ANIMATION_PROCESS_IDLE;
 	active = false;
 	cache_valid = false;
diff --git a/scene/animation/animation_tree.h b/scene/animation/animation_tree.h
index d558170f23..8fe01fac8f 100644
--- a/scene/animation/animation_tree.h
+++ b/scene/animation/animation_tree.h
@@ -52,7 +52,6 @@ public:
 	};
 
 	struct Input {
-
 		String name;
 	};
 
@@ -63,7 +62,6 @@ public:
 	friend class AnimationTree;
 
 	struct AnimationState {
-
 		Ref<Animation> animation;
 		float time;
 		float delta;
@@ -73,7 +71,6 @@ public:
 	};
 
 	struct State {
-
 		int track_count;
 		HashMap<NodePath, int> track_map;
 		List<AnimationState> animation_states;
@@ -174,7 +171,6 @@ public:
 
 private:
 	struct TrackCache {
-
 		bool root_motion;
 		uint64_t setup_pass;
 		uint64_t process_pass;
@@ -209,19 +205,16 @@ private:
 	};
 
 	struct TrackCacheValue : public TrackCache {
-
 		Variant value;
 		Vector<StringName> subpath;
 		TrackCacheValue() { type = Animation::TYPE_VALUE; }
 	};
 
 	struct TrackCacheMethod : public TrackCache {
-
 		TrackCacheMethod() { type = Animation::TYPE_METHOD; }
 	};
 
 	struct TrackCacheBezier : public TrackCache {
-
 		float value;
 		Vector<StringName> subpath;
 		TrackCacheBezier() {
@@ -231,7 +224,6 @@ private:
 	};
 
 	struct TrackCacheAudio : public TrackCache {
-
 		bool playing;
 		float start;
 		float len;
@@ -245,7 +237,6 @@ private:
 	};
 
 	struct TrackCacheAnimation : public TrackCache {
-
 		bool playing;
 
 		TrackCacheAnimation() {
diff --git a/scene/animation/root_motion_view.cpp b/scene/animation/root_motion_view.cpp
index f993127b07..cbf2e4a6ff 100644
--- a/scene/animation/root_motion_view.cpp
+++ b/scene/animation/root_motion_view.cpp
@@ -76,9 +76,7 @@ bool RootMotionView::get_zero_y() const {
 }
 
 void RootMotionView::_notification(int p_what) {
-
 	if (p_what == NOTIFICATION_ENTER_TREE) {
-
 		RS::get_singleton()->immediate_set_material(immediate, StandardMaterial3D::get_material_rid_for_2d(false, true, false, false, false));
 		first = true;
 	}
@@ -87,7 +85,6 @@ void RootMotionView::_notification(int p_what) {
 		Transform transform;
 
 		if (has_node(path)) {
-
 			Node *node = get_node(path);
 
 			AnimationTree *tree = Object::cast_to<AnimationTree>(node);
@@ -129,7 +126,6 @@ void RootMotionView::_notification(int p_what) {
 		RS::get_singleton()->immediate_begin(immediate, RS::PRIMITIVE_LINES);
 		for (int i = -cells_in_radius; i < cells_in_radius; i++) {
 			for (int j = -cells_in_radius; j < cells_in_radius; j++) {
-
 				Vector3 from(i * cell_size, 0, j * cell_size);
 				Vector3 from_i((i + 1) * cell_size, 0, j * cell_size);
 				Vector3 from_j(i * cell_size, 0, (j + 1) * cell_size);
@@ -161,15 +157,14 @@ void RootMotionView::_notification(int p_what) {
 }
 
 AABB RootMotionView::get_aabb() const {
-
 	return AABB(Vector3(-radius, 0, -radius), Vector3(radius * 2, 0.001, radius * 2));
 }
+
 Vector<Face3> RootMotionView::get_faces(uint32_t p_usage_flags) const {
 	return Vector<Face3>();
 }
 
 void RootMotionView::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_animation_path", "path"), &RootMotionView::set_animation_path);
 	ClassDB::bind_method(D_METHOD("get_animation_path"), &RootMotionView::get_animation_path);
 
diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp
index b826907a3a..854db5fee2 100644
--- a/scene/animation/tween.cpp
+++ b/scene/animation/tween.cpp
@@ -33,7 +33,6 @@
 #include "core/method_bind_ext.gen.inc"
 
 void Tween::_add_pending_command(StringName p_key, const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5, const Variant &p_arg6, const Variant &p_arg7, const Variant &p_arg8, const Variant &p_arg9, const Variant &p_arg10) {
-
 	// Add a new pending command and reference it
 	pending_commands.push_back(PendingCommand());
 	PendingCommand &cmd = pending_commands.back()->get();
@@ -43,57 +42,66 @@ void Tween::_add_pending_command(StringName p_key, const Variant &p_arg1, const
 
 	// Determine command argument count
 	int &count = cmd.args;
-	if (p_arg10.get_type() != Variant::NIL)
+	if (p_arg10.get_type() != Variant::NIL) {
 		count = 10;
-	else if (p_arg9.get_type() != Variant::NIL)
+	} else if (p_arg9.get_type() != Variant::NIL) {
 		count = 9;
-	else if (p_arg8.get_type() != Variant::NIL)
+	} else if (p_arg8.get_type() != Variant::NIL) {
 		count = 8;
-	else if (p_arg7.get_type() != Variant::NIL)
+	} else if (p_arg7.get_type() != Variant::NIL) {
 		count = 7;
-	else if (p_arg6.get_type() != Variant::NIL)
+	} else if (p_arg6.get_type() != Variant::NIL) {
 		count = 6;
-	else if (p_arg5.get_type() != Variant::NIL)
+	} else if (p_arg5.get_type() != Variant::NIL) {
 		count = 5;
-	else if (p_arg4.get_type() != Variant::NIL)
+	} else if (p_arg4.get_type() != Variant::NIL) {
 		count = 4;
-	else if (p_arg3.get_type() != Variant::NIL)
+	} else if (p_arg3.get_type() != Variant::NIL) {
 		count = 3;
-	else if (p_arg2.get_type() != Variant::NIL)
+	} else if (p_arg2.get_type() != Variant::NIL) {
 		count = 2;
-	else if (p_arg1.get_type() != Variant::NIL)
+	} else if (p_arg1.get_type() != Variant::NIL) {
 		count = 1;
-	else
+	} else {
 		count = 0;
+	}
 
 	// Add the specified arguments to the command
-	if (count > 0)
+	if (count > 0) {
 		cmd.arg[0] = p_arg1;
-	if (count > 1)
+	}
+	if (count > 1) {
 		cmd.arg[1] = p_arg2;
-	if (count > 2)
+	}
+	if (count > 2) {
 		cmd.arg[2] = p_arg3;
-	if (count > 3)
+	}
+	if (count > 3) {
 		cmd.arg[3] = p_arg4;
-	if (count > 4)
+	}
+	if (count > 4) {
 		cmd.arg[4] = p_arg5;
-	if (count > 5)
+	}
+	if (count > 5) {
 		cmd.arg[5] = p_arg6;
-	if (count > 6)
+	}
+	if (count > 6) {
 		cmd.arg[6] = p_arg7;
-	if (count > 7)
+	}
+	if (count > 7) {
 		cmd.arg[7] = p_arg8;
-	if (count > 8)
+	}
+	if (count > 8) {
 		cmd.arg[8] = p_arg9;
-	if (count > 9)
+	}
+	if (count > 9) {
 		cmd.arg[9] = p_arg10;
+	}
 }
 
 void Tween::_process_pending_commands() {
-
 	// For each pending command...
 	for (List<PendingCommand>::Element *E = pending_commands.front(); E; E = E->next()) {
-
 		// Get the command
 		PendingCommand &cmd = E->get();
 		Callable::CallError err;
@@ -121,7 +129,6 @@ void Tween::_process_pending_commands() {
 }
 
 bool Tween::_set(const StringName &p_name, const Variant &p_value) {
-
 	// Set the correct attribute based on the given name
 	String name = p_name;
 	if (name == "playback/speed" || name == "speed") { // Backwards compatibility
@@ -140,7 +147,6 @@ bool Tween::_set(const StringName &p_name, const Variant &p_value) {
 }
 
 bool Tween::_get(const StringName &p_name, Variant &r_ret) const {
-
 	// Get the correct attribute based on the given name
 	String name = p_name;
 	if (name == "playback/speed") { // Backwards compatibility
@@ -168,7 +174,6 @@ void Tween::_get_property_list(List<PropertyInfo> *p_list) const {
 void Tween::_notification(int p_what) {
 	// What notification did we receive?
 	switch (p_what) {
-
 		case NOTIFICATION_ENTER_TREE: {
 			// Are we not already active?
 			if (!is_active()) {
@@ -185,26 +190,30 @@ void Tween::_notification(int p_what) {
 
 		case NOTIFICATION_INTERNAL_PROCESS: {
 			// Are we processing during physics time?
-			if (tween_process_mode == TWEEN_PROCESS_PHYSICS)
+			if (tween_process_mode == TWEEN_PROCESS_PHYSICS) {
 				// Do nothing since we aren't aligned with physics when we should be
 				break;
+			}
 
 			// Should we update?
-			if (is_active())
+			if (is_active()) {
 				// Update the tweens
 				_tween_process(get_process_delta_time());
+			}
 		} break;
 
 		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
 			// Are we processing during 'regular' time?
-			if (tween_process_mode == TWEEN_PROCESS_IDLE)
+			if (tween_process_mode == TWEEN_PROCESS_IDLE) {
 				// Do nothing since we would only process during idle time
 				break;
+			}
 
 			// Should we update?
-			if (is_active())
+			if (is_active()) {
 				// Update the tweens
 				_tween_process(get_physics_process_delta_time());
+			}
 		} break;
 
 		case NOTIFICATION_EXIT_TREE: {
@@ -289,7 +298,6 @@ void Tween::_bind_methods() {
 }
 
 Variant Tween::_get_initial_val(const InterpolateData &p_data) const {
-
 	// What type of data are we interpolating?
 	switch (p_data.type) {
 		case INTER_PROPERTY:
@@ -353,8 +361,9 @@ Variant Tween::_get_final_val(const InterpolateData &p_data) const {
 
 			// If we're looking at an INT value, instead convert it to a FLOAT
 			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT)
+			if (final_val.get_type() == Variant::INT) {
 				final_val = final_val.operator real_t();
+			}
 
 			return final_val;
 		}
@@ -366,7 +375,6 @@ Variant Tween::_get_final_val(const InterpolateData &p_data) const {
 }
 
 Variant &Tween::_get_delta_val(InterpolateData &p_data) {
-
 	// What kind of data are we interpolating?
 	switch (p_data.type) {
 		case INTER_PROPERTY:
@@ -396,8 +404,9 @@ Variant &Tween::_get_delta_val(InterpolateData &p_data) {
 
 			// If we're looking at an INT value, instead convert it to a FLOAT
 			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT)
+			if (final_val.get_type() == Variant::INT) {
 				final_val = final_val.operator real_t();
+			}
 
 			// Calculate the delta based on the initial value and the final value
 			_calc_delta_val(p_data.initial_val, final_val, p_data.delta_val);
@@ -411,8 +420,9 @@ Variant &Tween::_get_delta_val(InterpolateData &p_data) {
 
 			// If we're looking at an INT value, instead convert it to a FLOAT
 			// This is better for interpolation
-			if (initial_val.get_type() == Variant::INT)
+			if (initial_val.get_type() == Variant::INT) {
 				initial_val = initial_val.operator real_t();
+			}
 
 			// Calculate the delta based on the initial value and the final value
 			_calc_delta_val(initial_val, p_data.final_val, p_data.delta_val);
@@ -438,7 +448,6 @@ Variant Tween::_run_equation(InterpolateData &p_data) {
 
 	// What type of data are we interpolating?
 	switch (initial_val.get_type()) {
-
 		case Variant::BOOL:
 			// Run the boolean specific equation (checking if it is at least 0.5)
 			result = (_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, initial_val, delta_val, p_data.duration)) >= 0.5;
@@ -613,14 +622,12 @@ Variant Tween::_run_equation(InterpolateData &p_data) {
 }
 
 bool Tween::_apply_tween_value(InterpolateData &p_data, Variant &value) {
-
 	// Get the object we want to apply the new value to
 	Object *object = ObjectDB::get_instance(p_data.id);
 	ERR_FAIL_COND_V(object == nullptr, false);
 
 	// What kind of data are we mutating?
 	switch (p_data.type) {
-
 		case INTER_PROPERTY:
 		case FOLLOW_PROPERTY:
 		case TARGETING_PROPERTY: {
@@ -663,8 +670,9 @@ void Tween::_tween_process(float p_delta) {
 	_process_pending_commands();
 
 	// If the scale is 0, make no progress on the tweens
-	if (speed_scale == 0)
+	if (speed_scale == 0) {
 		return;
+	}
 
 	// Update the delta and whether we are pending an update
 	p_delta *= speed_scale;
@@ -687,8 +695,9 @@ void Tween::_tween_process(float p_delta) {
 		}
 
 		// If we are all finished, we can reset all of the tweens
-		if (repeats_finished)
+		if (repeats_finished) {
 			reset_all();
+		}
 	}
 
 	// Are all of the tweens complete?
@@ -696,7 +705,6 @@ void Tween::_tween_process(float p_delta) {
 
 	// For each tween we wish to interpolate...
 	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-
 		// Get the data from it
 		InterpolateData &data = E->get();
 
@@ -704,20 +712,22 @@ void Tween::_tween_process(float p_delta) {
 		all_finished = all_finished && data.finish;
 
 		// Is the data not active or already finished? No need to go any further
-		if (!data.active || data.finish)
+		if (!data.active || data.finish) {
 			continue;
+		}
 
 		// Get the target object for this interpolation
 		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr)
+		if (object == nullptr) {
 			continue;
+		}
 
 		// Are we still delaying this tween?
 		bool prev_delaying = data.elapsed <= data.delay;
 		data.elapsed += p_delta;
-		if (data.elapsed < data.delay)
+		if (data.elapsed < data.delay) {
 			continue;
-		else if (prev_delaying) {
+		} else if (prev_delaying) {
 			// We can apply the tween's value to the data and emit that the tween has started
 			_apply_tween_value(data, data.initial_val);
 			emit_signal("tween_started", object, NodePath(Vector<StringName>(), data.key, false));
@@ -790,8 +800,9 @@ void Tween::_tween_process(float p_delta) {
 			emit_signal("tween_completed", object, NodePath(Vector<StringName>(), data.key, false));
 
 			// If we are not repeating the tween, remove it
-			if (!repeat)
+			if (!repeat) {
 				call_deferred("_remove_by_uid", data.uid);
+			}
 		} else if (!repeat) {
 			// Check whether all tweens are finished
 			all_finished = all_finished && data.finish;
@@ -821,8 +832,9 @@ bool Tween::is_active() const {
 
 void Tween::set_active(bool p_active) {
 	// Do nothing if it's the same active mode that we currently are
-	if (is_active() == p_active)
+	if (is_active() == p_active) {
 		return;
+	}
 
 	// Depending on physics or idle, set processing
 	switch (tween_process_mode) {
@@ -852,7 +864,6 @@ float Tween::get_speed_scale() const {
 }
 
 void Tween::start() {
-
 	ERR_FAIL_COND_MSG(!is_inside_tree(), "Tween was not added to the SceneTree!");
 
 	// Are there any pending updates?
@@ -873,8 +884,9 @@ void Tween::reset(Object *p_object, StringName p_key) {
 		// Get the target object
 		InterpolateData &data = E->get();
 		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr)
+		if (object == nullptr) {
 			continue;
+		}
 
 		// Do we have the correct object and key?
 		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
@@ -883,8 +895,9 @@ void Tween::reset(Object *p_object, StringName p_key) {
 			data.finish = false;
 
 			// Also apply the initial state if there isn't a delay
-			if (data.delay == 0)
+			if (data.delay == 0) {
 				_apply_tween_value(data, data.initial_val);
+			}
 		}
 	}
 	pending_update--;
@@ -900,8 +913,9 @@ void Tween::reset_all() {
 		data.finish = false;
 
 		// If there isn't a delay, apply the value to the object
-		if (data.delay == 0)
+		if (data.delay == 0) {
 			_apply_tween_value(data, data.initial_val);
+		}
 	}
 	pending_update--;
 }
@@ -910,17 +924,18 @@ void Tween::stop(Object *p_object, StringName p_key) {
 	// Find the tween that has the given target object and string key
 	pending_update++;
 	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
-
 		// Get the object the tween is targeting
 		InterpolateData &data = E->get();
 		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr)
+		if (object == nullptr) {
 			continue;
+		}
 
 		// Is this the correct object and does it have the given key?
-		if (object == p_object && (data.concatenated_key == p_key || p_key == ""))
+		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
 			// Disable the tween
 			data.active = false;
+		}
 	}
 	pending_update--;
 }
@@ -950,12 +965,14 @@ void Tween::resume(Object *p_object, StringName p_key) {
 		// Grab the object
 		InterpolateData &data = E->get();
 		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr)
+		if (object == nullptr) {
 			continue;
+		}
 
 		// If the object and string key match, activate it
-		if (object == p_object && (data.concatenated_key == p_key || p_key == ""))
+		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
 			data.active = true;
+		}
 	}
 	pending_update--;
 }
@@ -988,8 +1005,9 @@ void Tween::remove(Object *p_object, StringName p_key) {
 		// Get the target object
 		InterpolateData &data = E->get();
 		Object *object = ObjectDB::get_instance(data.id);
-		if (object == nullptr)
+		if (object == nullptr) {
 			continue;
+		}
 
 		// If the target object and string key match, queue it for removal
 		if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
@@ -1090,9 +1108,10 @@ real_t Tween::tell() const {
 	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
 		// Get the data and figure out if it's position is further along than the previous ones
 		const InterpolateData &data = E->get();
-		if (data.elapsed > pos)
+		if (data.elapsed > pos) {
 			// Save it if so
 			pos = data.elapsed;
+		}
 	}
 	pending_update--;
 	return pos;
@@ -1112,9 +1131,10 @@ real_t Tween::get_runtime() const {
 		// Get the tween data and see if it's runtime is greater than the previous tweens
 		const InterpolateData &data = E->get();
 		real_t t = data.delay + data.duration;
-		if (t > runtime)
+		if (t > runtime) {
 			// This is the longest running tween
 			runtime = t;
+		}
 	}
 	pending_update--;
 
@@ -1123,7 +1143,6 @@ real_t Tween::get_runtime() const {
 }
 
 bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val) {
-
 	// Get the initial, final, and delta values
 	const Variant &initial_val = p_initial_val;
 	const Variant &final_val = p_final_val;
@@ -1131,7 +1150,6 @@ bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final
 
 	// What kind of data are we interpolating?
 	switch (initial_val.get_type()) {
-
 		case Variant::BOOL:
 			// We'll treat booleans just like integers
 		case Variant::INT:
@@ -1263,7 +1281,6 @@ bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final
 }
 
 void Tween::_build_interpolation(InterpolateType p_interpolation_type, Object *p_object, NodePath *p_property, StringName *p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
-
 	// TODO: Add initialization+implementation for remaining interpolation types
 	// TODO: Fix this method's organization to take advantage of the type
 
@@ -1322,8 +1339,9 @@ void Tween::_build_interpolation(InterpolateType p_interpolation_type, Object *p
 	}
 
 	// Is there not a valid delta?
-	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val))
+	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) {
 		return;
+	}
 
 	// Add this interpolation to the total
 	_push_interpolate_data(data);
@@ -1341,14 +1359,17 @@ void Tween::interpolate_property(Object *p_object, NodePath p_property, Variant
 
 	// If no initial value given, grab the initial value from the object
 	// TODO: Is this documented? This is very useful and removes a lot of clutter from tweens!
-	if (p_initial_val.get_type() == Variant::NIL)
+	if (p_initial_val.get_type() == Variant::NIL) {
 		p_initial_val = p_object->get_indexed(p_property.get_subnames());
+	}
 
 	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT)
+	if (p_initial_val.get_type() == Variant::INT) {
 		p_initial_val = p_initial_val.operator real_t();
-	if (p_final_val.get_type() == Variant::INT)
+	}
+	if (p_final_val.get_type() == Variant::INT) {
 		p_final_val = p_final_val.operator real_t();
+	}
 
 	// Build the interpolation data
 	_build_interpolation(INTER_PROPERTY, p_object, &p_property, nullptr, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
@@ -1362,10 +1383,12 @@ void Tween::interpolate_method(Object *p_object, StringName p_method, Variant p_
 	}
 
 	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT)
+	if (p_initial_val.get_type() == Variant::INT) {
 		p_initial_val = p_initial_val.operator real_t();
-	if (p_final_val.get_type() == Variant::INT)
+	}
+	if (p_final_val.get_type() == Variant::INT) {
 		p_final_val = p_final_val.operator real_t();
+	}
 
 	// Build the interpolation data
 	_build_interpolation(INTER_METHOD, p_object, nullptr, &p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
@@ -1404,18 +1427,19 @@ void Tween::interpolate_callback(Object *p_object, real_t p_duration, String p_c
 
 	// Add arguments to the interpolation
 	int args = 0;
-	if (p_arg5.get_type() != Variant::NIL)
+	if (p_arg5.get_type() != Variant::NIL) {
 		args = 5;
-	else if (p_arg4.get_type() != Variant::NIL)
+	} else if (p_arg4.get_type() != Variant::NIL) {
 		args = 4;
-	else if (p_arg3.get_type() != Variant::NIL)
+	} else if (p_arg3.get_type() != Variant::NIL) {
 		args = 3;
-	else if (p_arg2.get_type() != Variant::NIL)
+	} else if (p_arg2.get_type() != Variant::NIL) {
 		args = 2;
-	else if (p_arg1.get_type() != Variant::NIL)
+	} else if (p_arg1.get_type() != Variant::NIL) {
 		args = 1;
-	else
+	} else {
 		args = 0;
+	}
 
 	data.args = args;
 	data.arg[0] = p_arg1;
@@ -1461,18 +1485,19 @@ void Tween::interpolate_deferred_callback(Object *p_object, real_t p_duration, S
 
 	// Collect arguments for the callback
 	int args = 0;
-	if (p_arg5.get_type() != Variant::NIL)
+	if (p_arg5.get_type() != Variant::NIL) {
 		args = 5;
-	else if (p_arg4.get_type() != Variant::NIL)
+	} else if (p_arg4.get_type() != Variant::NIL) {
 		args = 4;
-	else if (p_arg3.get_type() != Variant::NIL)
+	} else if (p_arg3.get_type() != Variant::NIL) {
 		args = 3;
-	else if (p_arg2.get_type() != Variant::NIL)
+	} else if (p_arg2.get_type() != Variant::NIL) {
 		args = 2;
-	else if (p_arg1.get_type() != Variant::NIL)
+	} else if (p_arg1.get_type() != Variant::NIL) {
 		args = 1;
-	else
+	} else {
 		args = 0;
+	}
 
 	data.args = args;
 	data.arg[0] = p_arg1;
@@ -1498,12 +1523,14 @@ void Tween::follow_property(Object *p_object, NodePath p_property, Variant p_ini
 
 	// If no initial value is given, grab it from the source object
 	// TODO: Is this documented? It's really helpful for decluttering tweens
-	if (p_initial_val.get_type() == Variant::NIL)
+	if (p_initial_val.get_type() == Variant::NIL) {
 		p_initial_val = p_object->get_indexed(p_property.get_subnames());
+	}
 
 	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT)
+	if (p_initial_val.get_type() == Variant::INT) {
 		p_initial_val = p_initial_val.operator real_t();
+	}
 
 	// Confirm the source and target objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1529,8 +1556,9 @@ void Tween::follow_property(Object *p_object, NodePath p_property, Variant p_ini
 	ERR_FAIL_COND(!target_prop_valid);
 
 	// Convert target INT to FLOAT since it is better for interpolation
-	if (target_val.get_type() == Variant::INT)
+	if (target_val.get_type() == Variant::INT) {
 		target_val = target_val.operator real_t();
+	}
 
 	// Verify that the target value and initial value are the same type
 	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
@@ -1565,8 +1593,9 @@ void Tween::follow_method(Object *p_object, StringName p_method, Variant p_initi
 		return;
 	}
 	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT)
+	if (p_initial_val.get_type() == Variant::INT) {
 		p_initial_val = p_initial_val.operator real_t();
+	}
 
 	// Verify the source and target objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1592,8 +1621,9 @@ void Tween::follow_method(Object *p_object, StringName p_method, Variant p_initi
 	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
 
 	// Convert target INT values to FLOAT as they are better for interpolation
-	if (target_val.get_type() == Variant::INT)
+	if (target_val.get_type() == Variant::INT) {
 		target_val = target_val.operator real_t();
+	}
 	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
 
 	// Make the new InterpolateData for the method follow
@@ -1630,8 +1660,9 @@ void Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_
 	p_initial_property = p_initial_property.get_as_property_path();
 
 	// Convert the initial INT values to FLOAT as they are better for Interpolation
-	if (p_final_val.get_type() == Variant::INT)
+	if (p_final_val.get_type() == Variant::INT) {
 		p_final_val = p_final_val.operator real_t();
+	}
 
 	// Verify both objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1657,8 +1688,9 @@ void Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_
 	ERR_FAIL_COND(!initial_prop_valid);
 
 	// Convert the initial INT value to FLOAT as it is better for interpolation
-	if (initial_val.get_type() == Variant::INT)
+	if (initial_val.get_type() == Variant::INT) {
 		initial_val = initial_val.operator real_t();
+	}
 	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
 
 	// Build the InterpolateData object
@@ -1698,8 +1730,9 @@ void Tween::targeting_method(Object *p_object, StringName p_method, Object *p_in
 	}
 
 	// Convert final INT values to FLOAT as they are better for interpolation
-	if (p_final_val.get_type() == Variant::INT)
+	if (p_final_val.get_type() == Variant::INT) {
 		p_final_val = p_final_val.operator real_t();
+	}
 
 	// Make sure the given objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1725,8 +1758,9 @@ void Tween::targeting_method(Object *p_object, StringName p_method, Object *p_in
 	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
 
 	// Convert initial INT values to FLOAT as they aer better for interpolation
-	if (initial_val.get_type() == Variant::INT)
+	if (initial_val.get_type() == Variant::INT) {
 		initial_val = initial_val.operator real_t();
+	}
 	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
 
 	// Build the new InterpolateData object
diff --git a/scene/animation/tween.h b/scene/animation/tween.h
index f74df50f68..668870c526 100644
--- a/scene/animation/tween.h
+++ b/scene/animation/tween.h
@@ -34,7 +34,6 @@
 #include "scene/main/node.h"
 
 class Tween : public Node {
-
 	GDCLASS(Tween, Node);
 
 public: