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

1 files changed, 54 insertions, 63 deletions

diff --git a/scene/3d/ray_cast_3d.cpp b/scene/3d/ray_cast_3d.cpp
index 304a5e1254..68f4b3132c 100644
--- a/scene/3d/ray_cast_3d.cpp
+++ b/scene/3d/ray_cast_3d.cpp
@@ -36,151 +36,149 @@
 #include "servers/physics_server_3d.h"
 
 void RayCast3D::set_cast_to(const Vector3 &p_point) {
-
 	cast_to = p_point;
-	if (is_inside_tree() && (Engine::get_singleton()->is_editor_hint() || get_tree()->is_debugging_collisions_hint()))
+	if (is_inside_tree() && (Engine::get_singleton()->is_editor_hint() || get_tree()->is_debugging_collisions_hint())) {
 		update_gizmo();
-	if (is_inside_tree() && get_tree()->is_debugging_collisions_hint())
+	}
+	if (is_inside_tree() && get_tree()->is_debugging_collisions_hint()) {
 		_update_debug_shape();
+	}
 }
 
 Vector3 RayCast3D::get_cast_to() const {
-
 	return cast_to;
 }
 
 void RayCast3D::set_collision_mask(uint32_t p_mask) {
-
 	collision_mask = p_mask;
 }
 
 uint32_t RayCast3D::get_collision_mask() const {
-
 	return collision_mask;
 }
 
 void RayCast3D::set_collision_mask_bit(int p_bit, bool p_value) {
-
 	uint32_t mask = get_collision_mask();
-	if (p_value)
+	if (p_value) {
 		mask |= 1 << p_bit;
-	else
+	} else {
 		mask &= ~(1 << p_bit);
+	}
 	set_collision_mask(mask);
 }
 
 bool RayCast3D::get_collision_mask_bit(int p_bit) const {
-
 	return get_collision_mask() & (1 << p_bit);
 }
 
 bool RayCast3D::is_colliding() const {
-
 	return collided;
 }
-Object *RayCast3D::get_collider() const {
 
-	if (against.is_null())
+Object *RayCast3D::get_collider() const {
+	if (against.is_null()) {
 		return nullptr;
+	}
 
 	return ObjectDB::get_instance(against);
 }
 
 int RayCast3D::get_collider_shape() const {
-
 	return against_shape;
 }
-Vector3 RayCast3D::get_collision_point() const {
 
+Vector3 RayCast3D::get_collision_point() const {
 	return collision_point;
 }
-Vector3 RayCast3D::get_collision_normal() const {
 
+Vector3 RayCast3D::get_collision_normal() const {
 	return collision_normal;
 }
 
 void RayCast3D::set_enabled(bool p_enabled) {
-
 	enabled = p_enabled;
 	update_gizmo();
 
-	if (is_inside_tree() && !Engine::get_singleton()->is_editor_hint())
+	if (is_inside_tree() && !Engine::get_singleton()->is_editor_hint()) {
 		set_physics_process_internal(p_enabled);
-	if (!p_enabled)
+	}
+	if (!p_enabled) {
 		collided = false;
+	}
 
 	if (is_inside_tree() && get_tree()->is_debugging_collisions_hint()) {
-		if (p_enabled)
+		if (p_enabled) {
 			_update_debug_shape();
-		else
+		} else {
 			_clear_debug_shape();
+		}
 	}
 }
 
 bool RayCast3D::is_enabled() const {
-
 	return enabled;
 }
 
 void RayCast3D::set_exclude_parent_body(bool p_exclude_parent_body) {
-
-	if (exclude_parent_body == p_exclude_parent_body)
+	if (exclude_parent_body == p_exclude_parent_body) {
 		return;
+	}
 
 	exclude_parent_body = p_exclude_parent_body;
 
-	if (!is_inside_tree())
+	if (!is_inside_tree()) {
 		return;
+	}
 
 	if (Object::cast_to<CollisionObject3D>(get_parent())) {
-		if (exclude_parent_body)
+		if (exclude_parent_body) {
 			exclude.insert(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
-		else
+		} else {
 			exclude.erase(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+		}
 	}
 }
 
 bool RayCast3D::get_exclude_parent_body() const {
-
 	return exclude_parent_body;
 }
 
 void RayCast3D::_notification(int p_what) {
-
 	switch (p_what) {
-
 		case NOTIFICATION_ENTER_TREE: {
-
 			if (enabled && !Engine::get_singleton()->is_editor_hint()) {
 				set_physics_process_internal(true);
 
-				if (get_tree()->is_debugging_collisions_hint())
+				if (get_tree()->is_debugging_collisions_hint()) {
 					_update_debug_shape();
-			} else
+				}
+			} else {
 				set_physics_process_internal(false);
+			}
 
 			if (Object::cast_to<CollisionObject3D>(get_parent())) {
-				if (exclude_parent_body)
+				if (exclude_parent_body) {
 					exclude.insert(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
-				else
+				} else {
 					exclude.erase(Object::cast_to<CollisionObject3D>(get_parent())->get_rid());
+				}
 			}
 
 		} break;
 		case NOTIFICATION_EXIT_TREE: {
-
 			if (enabled) {
 				set_physics_process_internal(false);
 			}
 
-			if (debug_shape)
+			if (debug_shape) {
 				_clear_debug_shape();
+			}
 
 		} break;
 		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
-
-			if (!enabled)
+			if (!enabled) {
 				break;
+			}
 
 			bool prev_collision_state = collided;
 			_update_raycast_state();
@@ -205,13 +203,13 @@ void RayCast3D::_update_raycast_state() {
 	Transform gt = get_global_transform();
 
 	Vector3 to = cast_to;
-	if (to == Vector3())
+	if (to == Vector3()) {
 		to = Vector3(0, 0.01, 0);
+	}
 
 	PhysicsDirectSpaceState3D::RayResult rr;
 
 	if (dss->intersect_ray(gt.get_origin(), gt.xform(to), rr, exclude, collision_mask, collide_with_bodies, collide_with_areas)) {
-
 		collided = true;
 		against = rr.collider_id;
 		collision_point = rr.position;
@@ -229,60 +227,52 @@ void RayCast3D::force_raycast_update() {
 }
 
 void RayCast3D::add_exception_rid(const RID &p_rid) {
-
 	exclude.insert(p_rid);
 }
 
 void RayCast3D::add_exception(const Object *p_object) {
-
 	ERR_FAIL_NULL(p_object);
 	const CollisionObject3D *co = Object::cast_to<CollisionObject3D>(p_object);
-	if (!co)
+	if (!co) {
 		return;
+	}
 	add_exception_rid(co->get_rid());
 }
 
 void RayCast3D::remove_exception_rid(const RID &p_rid) {
-
 	exclude.erase(p_rid);
 }
 
 void RayCast3D::remove_exception(const Object *p_object) {
-
 	ERR_FAIL_NULL(p_object);
 	const CollisionObject3D *co = Object::cast_to<CollisionObject3D>(p_object);
-	if (!co)
+	if (!co) {
 		return;
+	}
 	remove_exception_rid(co->get_rid());
 }
 
 void RayCast3D::clear_exceptions() {
-
 	exclude.clear();
 }
 
 void RayCast3D::set_collide_with_areas(bool p_clip) {
-
 	collide_with_areas = p_clip;
 }
 
 bool RayCast3D::is_collide_with_areas_enabled() const {
-
 	return collide_with_areas;
 }
 
 void RayCast3D::set_collide_with_bodies(bool p_clip) {
-
 	collide_with_bodies = p_clip;
 }
 
 bool RayCast3D::is_collide_with_bodies_enabled() const {
-
 	return collide_with_bodies;
 }
 
 void RayCast3D::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &RayCast3D::set_enabled);
 	ClassDB::bind_method(D_METHOD("is_enabled"), &RayCast3D::is_enabled);
 
@@ -331,7 +321,6 @@ void RayCast3D::_bind_methods() {
 }
 
 void RayCast3D::_create_debug_shape() {
-
 	if (!debug_material.is_valid()) {
 		debug_material = Ref<StandardMaterial3D>(memnew(StandardMaterial3D));
 
@@ -350,16 +339,18 @@ void RayCast3D::_create_debug_shape() {
 }
 
 void RayCast3D::_update_debug_shape() {
-
-	if (!enabled)
+	if (!enabled) {
 		return;
+	}
 
-	if (!debug_shape)
+	if (!debug_shape) {
 		_create_debug_shape();
+	}
 
 	MeshInstance3D *mi = static_cast<MeshInstance3D *>(debug_shape);
-	if (!mi->get_mesh().is_valid())
+	if (!mi->get_mesh().is_valid()) {
 		return;
+	}
 
 	Ref<ArrayMesh> mesh = mi->get_mesh();
 	mesh->clear_surfaces();
@@ -377,21 +368,21 @@ void RayCast3D::_update_debug_shape() {
 }
 
 void RayCast3D::_clear_debug_shape() {
-
-	if (!debug_shape)
+	if (!debug_shape) {
 		return;
+	}
 
 	MeshInstance3D *mi = static_cast<MeshInstance3D *>(debug_shape);
-	if (mi->is_inside_tree())
+	if (mi->is_inside_tree()) {
 		mi->queue_delete();
-	else
+	} else {
 		memdelete(mi);
+	}
 
 	debug_shape = nullptr;
 }
 
 RayCast3D::RayCast3D() {
-
 	enabled = false;
 
 	collided = false;