Style: Enforce braces around if blocks and loops

Using clang-tidy's `readability-braces-around-statements`.
https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html

13 files changed, 187 insertions, 97 deletions

diff --git a/modules/bullet/area_bullet.cpp b/modules/bullet/area_bullet.cpp
index d5b03015a9..79d8e252f0 100644
--- a/modules/bullet/area_bullet.cpp
+++ b/modules/bullet/area_bullet.cpp
@@ -52,19 +52,22 @@ AreaBullet::AreaBullet() :
 	/// In order to use collision objects as trigger, you have to disable the collision response.
 	set_collision_enabled(false);
 
-	for (int i = 0; i < 5; ++i)
+	for (int i = 0; i < 5; ++i) {
 		call_event_res_ptr[i] = &call_event_res[i];
+	}
 }
 
 AreaBullet::~AreaBullet() {
 	// signal are handled by godot, so just clear without notify
-	for (int i = overlappingObjects.size() - 1; 0 <= i; --i)
+	for (int i = overlappingObjects.size() - 1; 0 <= i; --i) {
 		overlappingObjects[i].object->on_exit_area(this);
+	}
 }
 
 void AreaBullet::dispatch_callbacks() {
-	if (!isScratched)
+	if (!isScratched) {
 		return;
+	}
 	isScratched = false;
 
 	// Reverse order because I've to remove EXIT objects
@@ -109,15 +112,17 @@ void AreaBullet::call_event(CollisionObjectBullet *p_otherObject, PhysicsServer3
 }
 
 void AreaBullet::scratch() {
-	if (isScratched)
+	if (isScratched) {
 		return;
+	}
 	isScratched = true;
 }
 
 void AreaBullet::clear_overlaps(bool p_notify) {
 	for (int i = overlappingObjects.size() - 1; 0 <= i; --i) {
-		if (p_notify)
+		if (p_notify) {
 			call_event(overlappingObjects[i].object, PhysicsServer3D::AREA_BODY_REMOVED);
+		}
 		overlappingObjects[i].object->on_exit_area(this);
 	}
 	overlappingObjects.clear();
@@ -126,8 +131,9 @@ void AreaBullet::clear_overlaps(bool p_notify) {
 void AreaBullet::remove_overlap(CollisionObjectBullet *p_object, bool p_notify) {
 	for (int i = overlappingObjects.size() - 1; 0 <= i; --i) {
 		if (overlappingObjects[i].object == p_object) {
-			if (p_notify)
+			if (p_notify) {
 				call_event(overlappingObjects[i].object, PhysicsServer3D::AREA_BODY_REMOVED);
+			}
 			overlappingObjects[i].object->on_exit_area(this);
 			overlappingObjects.remove(i);
 			break;
diff --git a/modules/bullet/btRayShape.cpp b/modules/bullet/btRayShape.cpp
index ee84354315..a754ca6a89 100644
--- a/modules/bullet/btRayShape.cpp
+++ b/modules/bullet/btRayShape.cpp
@@ -68,10 +68,11 @@ btVector3 btRayShape::localGetSupportingVertex(const btVector3 &vec) const {
 }
 
 btVector3 btRayShape::localGetSupportingVertexWithoutMargin(const btVector3 &vec) const {
-	if (vec.z() > 0)
+	if (vec.z() > 0) {
 		return m_shapeAxis * m_cacheScaledLength;
-	else
+	} else {
 		return btVector3(0, 0, 0);
+	}
 }
 
 void btRayShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3 *vectors, btVector3 *supportVerticesOut, int numVectors) const {
diff --git a/modules/bullet/bullet_physics_server.cpp b/modules/bullet/bullet_physics_server.cpp
index c20fade011..55686543f3 100644
--- a/modules/bullet/bullet_physics_server.cpp
+++ b/modules/bullet/bullet_physics_server.cpp
@@ -326,8 +326,9 @@ void BulletPhysicsServer3D::area_clear_shapes(RID p_area) {
 	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
-	for (int i = area->get_shape_count(); 0 < i; --i)
+	for (int i = area->get_shape_count(); 0 < i; --i) {
 		area->remove_shape_full(0);
+	}
 }
 
 void BulletPhysicsServer3D::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) {
@@ -443,8 +444,9 @@ RID BulletPhysicsServer3D::body_create(BodyMode p_mode, bool p_init_sleeping) {
 	body->set_mode(p_mode);
 	body->set_collision_layer(1);
 	body->set_collision_mask(1);
-	if (p_init_sleeping)
+	if (p_init_sleeping) {
 		body->set_state(BODY_STATE_SLEEPING, p_init_sleeping);
+	}
 	CreateThenReturnRID(rigid_body_owner, body);
 }
 
@@ -458,8 +460,9 @@ void BulletPhysicsServer3D::body_set_space(RID p_body, RID p_space) {
 		ERR_FAIL_COND(!space);
 	}
 
-	if (body->get_space() == space)
+	if (body->get_space() == space) {
 		return; //pointles
+	}
 
 	body->set_space(space);
 }
@@ -469,8 +472,9 @@ RID BulletPhysicsServer3D::body_get_space(RID p_body) const {
 	ERR_FAIL_COND_V(!body, RID());
 
 	SpaceBullet *space = body->get_space();
-	if (!space)
+	if (!space) {
 		return RID();
+	}
 	return space->get_self();
 }
 
@@ -870,8 +874,9 @@ RID BulletPhysicsServer3D::soft_body_create(bool p_init_sleeping) {
 	SoftBodyBullet *body = bulletnew(SoftBodyBullet);
 	body->set_collision_layer(1);
 	body->set_collision_mask(1);
-	if (p_init_sleeping)
+	if (p_init_sleeping) {
 		body->set_activation_state(false);
+	}
 	CreateThenReturnRID(soft_body_owner, body);
 }
 
@@ -892,8 +897,9 @@ void BulletPhysicsServer3D::soft_body_set_space(RID p_body, RID p_space) {
 		ERR_FAIL_COND(!space);
 	}
 
-	if (body->get_space() == space)
+	if (body->get_space() == space) {
 		return; //pointles
+	}
 
 	body->set_space(space);
 }
@@ -903,8 +909,9 @@ RID BulletPhysicsServer3D::soft_body_get_space(RID p_body) const {
 	ERR_FAIL_COND_V(!body, RID());
 
 	SpaceBullet *space = body->get_space();
-	if (!space)
+	if (!space) {
 		return RID();
+	}
 	return space->get_self();
 }
 
@@ -1535,8 +1542,9 @@ void BulletPhysicsServer3D::init() {
 }
 
 void BulletPhysicsServer3D::step(float p_deltaTime) {
-	if (!active)
+	if (!active) {
 		return;
+	}
 
 	BulletPhysicsDirectBodyState3D::singleton_setDeltaTime(p_deltaTime);
 
diff --git a/modules/bullet/collision_object_bullet.cpp b/modules/bullet/collision_object_bullet.cpp
index 0d456a155a..a3158a15e5 100644
--- a/modules/bullet/collision_object_bullet.cpp
+++ b/modules/bullet/collision_object_bullet.cpp
@@ -80,10 +80,11 @@ btTransform CollisionObjectBullet::ShapeWrapper::get_adjusted_transform() const
 
 void CollisionObjectBullet::ShapeWrapper::claim_bt_shape(const btVector3 &body_scale) {
 	if (!bt_shape) {
-		if (active)
+		if (active) {
 			bt_shape = shape->create_bt_shape(scale * body_scale);
-		else
+		} else {
 			bt_shape = ShapeBullet::create_shape_empty();
+		}
 	}
 }
 
@@ -136,18 +137,21 @@ void CollisionObjectBullet::setupBulletCollisionObject(btCollisionObject *p_coll
 
 void CollisionObjectBullet::add_collision_exception(const CollisionObjectBullet *p_ignoreCollisionObject) {
 	exceptions.insert(p_ignoreCollisionObject->get_self());
-	if (!bt_collision_object)
+	if (!bt_collision_object) {
 		return;
+	}
 	bt_collision_object->setIgnoreCollisionCheck(p_ignoreCollisionObject->bt_collision_object, true);
-	if (space)
+	if (space) {
 		space->get_broadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bt_collision_object->getBroadphaseHandle(), space->get_dispatcher());
+	}
 }
 
 void CollisionObjectBullet::remove_collision_exception(const CollisionObjectBullet *p_ignoreCollisionObject) {
 	exceptions.erase(p_ignoreCollisionObject->get_self());
 	bt_collision_object->setIgnoreCollisionCheck(p_ignoreCollisionObject->bt_collision_object, false);
-	if (space)
+	if (space) {
 		space->get_broadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bt_collision_object->getBroadphaseHandle(), space->get_dispatcher());
+	}
 }
 
 bool CollisionObjectBullet::has_collision_exception(const CollisionObjectBullet *p_otherCollisionObject) const {
@@ -249,8 +253,9 @@ btCollisionShape *RigidCollisionObjectBullet::get_bt_shape(int p_index) const {
 int RigidCollisionObjectBullet::find_shape(ShapeBullet *p_shape) const {
 	const int size = shapes.size();
 	for (int i = 0; i < size; ++i) {
-		if (shapes[i].shape == p_shape)
+		if (shapes[i].shape == p_shape) {
 			return i;
+		}
 	}
 	return -1;
 }
@@ -280,8 +285,9 @@ void RigidCollisionObjectBullet::remove_all_shapes(bool p_permanentlyFromThisBod
 		internal_shape_destroy(i, p_permanentlyFromThisBody);
 	}
 	shapes.clear();
-	if (!p_force_not_reload)
+	if (!p_force_not_reload) {
 		reload_shapes();
+	}
 }
 
 void RigidCollisionObjectBullet::set_shape_transform(int p_index, const Transform &p_transform) {
@@ -302,8 +308,9 @@ Transform RigidCollisionObjectBullet::get_shape_transform(int p_index) const {
 }
 
 void RigidCollisionObjectBullet::set_shape_disabled(int p_index, bool p_disabled) {
-	if (shapes[p_index].active != p_disabled)
+	if (shapes[p_index].active != p_disabled) {
 		return;
+	}
 	shapes.write[p_index].active = !p_disabled;
 	shape_changed(p_index);
 }
diff --git a/modules/bullet/godot_ray_world_algorithm.cpp b/modules/bullet/godot_ray_world_algorithm.cpp
index fbb336ca56..a84f3511ba 100644
--- a/modules/bullet/godot_ray_world_algorithm.cpp
+++ b/modules/bullet/godot_ray_world_algorithm.cpp
@@ -98,12 +98,13 @@ void GodotRayWorldAlgorithm::processCollision(const btCollisionObjectWrapper *bo
 	if (btResult.hasHit()) {
 		btScalar depth(ray_shape->getScaledLength() * (btResult.m_closestHitFraction - 1));
 
-		if (depth > -RAY_PENETRATION_DEPTH_EPSILON)
+		if (depth > -RAY_PENETRATION_DEPTH_EPSILON) {
 			depth = 0.0;
+		}
 
-		if (ray_shape->getSlipsOnSlope())
+		if (ray_shape->getSlipsOnSlope()) {
 			resultOut->addContactPoint(btResult.m_hitNormalWorld, btResult.m_hitPointWorld, depth);
-		else {
+		} else {
 			resultOut->addContactPoint((ray_transform.getOrigin() - to.getOrigin()).normalize(), btResult.m_hitPointWorld, depth);
 		}
 	}
diff --git a/modules/bullet/godot_ray_world_algorithm.h b/modules/bullet/godot_ray_world_algorithm.h
index 45344186f5..9786732d40 100644
--- a/modules/bullet/godot_ray_world_algorithm.h
+++ b/modules/bullet/godot_ray_world_algorithm.h
@@ -56,8 +56,9 @@ public:
 
 	virtual void getAllContactManifolds(btManifoldArray &manifoldArray) {
 		///should we use m_ownManifold to avoid adding duplicates?
-		if (m_manifoldPtr && m_ownManifold)
+		if (m_manifoldPtr && m_ownManifold) {
 			manifoldArray.push_back(m_manifoldPtr);
+		}
 	}
 	struct CreateFunc : public btCollisionAlgorithmCreateFunc {
 		const btDiscreteDynamicsWorld *m_world;
diff --git a/modules/bullet/godot_result_callbacks.cpp b/modules/bullet/godot_result_callbacks.cpp
index b9c2a00b34..f82648d6ff 100644
--- a/modules/bullet/godot_result_callbacks.cpp
+++ b/modules/bullet/godot_result_callbacks.cpp
@@ -62,11 +62,13 @@ bool GodotClosestRayResultCallback::needsCollision(btBroadphaseProxy *proxy0) co
 		CollisionObjectBullet *gObj = static_cast<CollisionObjectBullet *>(btObj->getUserPointer());
 
 		if (CollisionObjectBullet::TYPE_AREA == gObj->getType()) {
-			if (!collide_with_areas)
+			if (!collide_with_areas) {
 				return false;
+			}
 		} else {
-			if (!collide_with_bodies)
+			if (!collide_with_bodies) {
 				return false;
+			}
 		}
 
 		if (m_pickRay && !gObj->is_ray_pickable()) {
@@ -84,8 +86,9 @@ bool GodotClosestRayResultCallback::needsCollision(btBroadphaseProxy *proxy0) co
 }
 
 bool GodotAllConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {
-	if (count >= m_resultMax)
+	if (count >= m_resultMax) {
 		return false;
+	}
 
 	const bool needs = GodotFilterCallback::test_collision_filters(m_collisionFilterGroup, m_collisionFilterMask, proxy0->m_collisionFilterGroup, proxy0->m_collisionFilterMask);
 	if (needs) {
@@ -102,8 +105,9 @@ bool GodotAllConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0) con
 }
 
 btScalar GodotAllConvexResultCallback::addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace) {
-	if (count >= m_resultMax)
+	if (count >= m_resultMax) {
 		return 1; // not used by bullet
+	}
 
 	CollisionObjectBullet *gObj = static_cast<CollisionObjectBullet *>(convexResult.m_hitCollisionObject->getUserPointer());
 
@@ -127,14 +131,17 @@ bool GodotKinClosestConvexResultCallback::needsCollision(btBroadphaseProxy *prox
 			return false;
 		} else {
 			// A kinematic body can't be stopped by a rigid body since the mass of kinematic body is infinite
-			if (m_infinite_inertia && !btObj->isStaticOrKinematicObject())
+			if (m_infinite_inertia && !btObj->isStaticOrKinematicObject()) {
 				return false;
+			}
 
-			if (gObj->getType() == CollisionObjectBullet::TYPE_AREA)
+			if (gObj->getType() == CollisionObjectBullet::TYPE_AREA) {
 				return false;
+			}
 
-			if (m_self_object->has_collision_exception(gObj) || gObj->has_collision_exception(m_self_object))
+			if (m_self_object->has_collision_exception(gObj) || gObj->has_collision_exception(m_self_object)) {
 				return false;
+			}
 		}
 		return true;
 	} else {
@@ -149,11 +156,13 @@ bool GodotClosestConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0)
 		CollisionObjectBullet *gObj = static_cast<CollisionObjectBullet *>(btObj->getUserPointer());
 
 		if (CollisionObjectBullet::TYPE_AREA == gObj->getType()) {
-			if (!collide_with_areas)
+			if (!collide_with_areas) {
 				return false;
+			}
 		} else {
-			if (!collide_with_bodies)
+			if (!collide_with_bodies) {
 				return false;
+			}
 		}
 
 		if (m_exclude->has(gObj->get_self())) {
@@ -166,16 +175,18 @@ bool GodotClosestConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0)
 }
 
 btScalar GodotClosestConvexResultCallback::addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace) {
-	if (convexResult.m_localShapeInfo)
+	if (convexResult.m_localShapeInfo) {
 		m_shapeId = convexResult.m_localShapeInfo->m_triangleIndex; // "m_triangleIndex" Is a odd name but contains the compound shape ID
-	else
+	} else {
 		m_shapeId = 0;
+	}
 	return btCollisionWorld::ClosestConvexResultCallback::addSingleResult(convexResult, normalInWorldSpace);
 }
 
 bool GodotAllContactResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {
-	if (m_count >= m_resultMax)
+	if (m_count >= m_resultMax) {
 		return false;
+	}
 
 	const bool needs = GodotFilterCallback::test_collision_filters(m_collisionFilterGroup, m_collisionFilterMask, proxy0->m_collisionFilterGroup, proxy0->m_collisionFilterMask);
 	if (needs) {
@@ -183,11 +194,13 @@ bool GodotAllContactResultCallback::needsCollision(btBroadphaseProxy *proxy0) co
 		CollisionObjectBullet *gObj = static_cast<CollisionObjectBullet *>(btObj->getUserPointer());
 
 		if (CollisionObjectBullet::TYPE_AREA == gObj->getType()) {
-			if (!collide_with_areas)
+			if (!collide_with_areas) {
 				return false;
+			}
 		} else {
-			if (!collide_with_bodies)
+			if (!collide_with_bodies) {
 				return false;
+			}
 		}
 
 		if (m_exclude->has(gObj->get_self())) {
@@ -200,8 +213,9 @@ bool GodotAllContactResultCallback::needsCollision(btBroadphaseProxy *proxy0) co
 }
 
 btScalar GodotAllContactResultCallback::addSingleResult(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1) {
-	if (m_count >= m_resultMax)
+	if (m_count >= m_resultMax) {
 		return cp.getDistance();
+	}
 
 	if (cp.getDistance() <= 0) {
 		PhysicsDirectSpaceState3D::ShapeResult &result = m_results[m_count];
@@ -226,8 +240,9 @@ btScalar GodotAllContactResultCallback::addSingleResult(btManifoldPoint &cp, con
 }
 
 bool GodotContactPairContactResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {
-	if (m_count >= m_resultMax)
+	if (m_count >= m_resultMax) {
 		return false;
+	}
 
 	const bool needs = GodotFilterCallback::test_collision_filters(m_collisionFilterGroup, m_collisionFilterMask, proxy0->m_collisionFilterGroup, proxy0->m_collisionFilterMask);
 	if (needs) {
@@ -235,11 +250,13 @@ bool GodotContactPairContactResultCallback::needsCollision(btBroadphaseProxy *pr
 		CollisionObjectBullet *gObj = static_cast<CollisionObjectBullet *>(btObj->getUserPointer());
 
 		if (CollisionObjectBullet::TYPE_AREA == gObj->getType()) {
-			if (!collide_with_areas)
+			if (!collide_with_areas) {
 				return false;
+			}
 		} else {
-			if (!collide_with_bodies)
+			if (!collide_with_bodies) {
 				return false;
+			}
 		}
 
 		if (m_exclude->has(gObj->get_self())) {
@@ -252,8 +269,9 @@ bool GodotContactPairContactResultCallback::needsCollision(btBroadphaseProxy *pr
 }
 
 btScalar GodotContactPairContactResultCallback::addSingleResult(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1) {
-	if (m_count >= m_resultMax)
+	if (m_count >= m_resultMax) {
 		return 1; // not used by bullet
+	}
 
 	if (m_self_object == colObj0Wrap->getCollisionObject()) {
 		B_TO_G(cp.m_localPointA, m_results[m_count * 2 + 0]); // Local contact
@@ -275,11 +293,13 @@ bool GodotRestInfoContactResultCallback::needsCollision(btBroadphaseProxy *proxy
 		CollisionObjectBullet *gObj = static_cast<CollisionObjectBullet *>(btObj->getUserPointer());
 
 		if (CollisionObjectBullet::TYPE_AREA == gObj->getType()) {
-			if (!collide_with_areas)
+			if (!collide_with_areas) {
 				return false;
+			}
 		} else {
-			if (!collide_with_bodies)
+			if (!collide_with_bodies) {
 				return false;
+			}
 		}
 
 		if (m_exclude->has(gObj->get_self())) {
diff --git a/modules/bullet/godot_result_callbacks.h b/modules/bullet/godot_result_callbacks.h
index 8636ca8eb6..1325542973 100644
--- a/modules/bullet/godot_result_callbacks.h
+++ b/modules/bullet/godot_result_callbacks.h
@@ -72,10 +72,11 @@ public:
 	virtual bool needsCollision(btBroadphaseProxy *proxy0) const;
 
 	virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult &rayResult, bool normalInWorldSpace) {
-		if (rayResult.m_localShapeInfo)
+		if (rayResult.m_localShapeInfo) {
 			m_shapeId = rayResult.m_localShapeInfo->m_triangleIndex; // "m_triangleIndex" Is a odd name but contains the compound shape ID
-		else
+		} else {
 			m_shapeId = 0;
+		}
 		return btCollisionWorld::ClosestRayResultCallback::addSingleResult(rayResult, normalInWorldSpace);
 	}
 };
diff --git a/modules/bullet/rigid_body_bullet.cpp b/modules/bullet/rigid_body_bullet.cpp
index f263893287..2fca7fe633 100644
--- a/modules/bullet/rigid_body_bullet.cpp
+++ b/modules/bullet/rigid_body_bullet.cpp
@@ -283,8 +283,9 @@ RigidBodyBullet::RigidBodyBullet() :
 RigidBodyBullet::~RigidBodyBullet() {
 	bulletdelete(godotMotionState);
 
-	if (force_integration_callback)
+	if (force_integration_callback) {
 		memdelete(force_integration_callback);
+	}
 
 	destroy_kinematic_utilities();
 }
@@ -309,8 +310,9 @@ void RigidBodyBullet::main_shape_changed() {
 void RigidBodyBullet::reload_body() {
 	if (space) {
 		space->remove_rigid_body(this);
-		if (get_main_shape())
+		if (get_main_shape()) {
 			space->add_rigid_body(this);
+		}
 	}
 }
 
@@ -336,8 +338,9 @@ void RigidBodyBullet::set_space(SpaceBullet *p_space) {
 void RigidBodyBullet::dispatch_callbacks() {
 	/// The check isFirstTransformChanged is necessary in order to call integrated forces only when the first transform is sent
 	if ((btBody->isKinematicObject() || btBody->isActive() || previousActiveState != btBody->isActive()) && force_integration_callback && can_integrate_forces) {
-		if (omit_forces_integration)
+		if (omit_forces_integration) {
 			btBody->clearForces();
+		}
 
 		BulletPhysicsDirectBodyState3D *bodyDirect = BulletPhysicsDirectBodyState3D::get_singleton(this);
 
@@ -431,8 +434,9 @@ bool RigidBodyBullet::add_collision_object(RigidBodyBullet *p_otherObject, const
 
 bool RigidBodyBullet::was_colliding(RigidBodyBullet *p_other_object) {
 	for (int i = prev_collision_count - 1; 0 <= i; --i) {
-		if ((*prev_collision_traces)[i] == p_other_object)
+		if ((*prev_collision_traces)[i] == p_other_object) {
 			return true;
+		}
 	}
 	return false;
 }
@@ -607,8 +611,9 @@ Variant RigidBodyBullet::get_state(PhysicsServer3D::BodyState p_state) const {
 void RigidBodyBullet::apply_central_impulse(const Vector3 &p_impulse) {
 	btVector3 btImpu;
 	G_TO_B(p_impulse, btImpu);
-	if (Vector3() != p_impulse)
+	if (Vector3() != p_impulse) {
 		btBody->activate();
+	}
 	btBody->applyCentralImpulse(btImpu);
 }
 
@@ -617,16 +622,18 @@ void RigidBodyBullet::apply_impulse(const Vector3 &p_pos, const Vector3 &p_impul
 	btVector3 btPos;
 	G_TO_B(p_impulse, btImpu);
 	G_TO_B(p_pos, btPos);
-	if (Vector3() != p_impulse)
+	if (Vector3() != p_impulse) {
 		btBody->activate();
+	}
 	btBody->applyImpulse(btImpu, btPos);
 }
 
 void RigidBodyBullet::apply_torque_impulse(const Vector3 &p_impulse) {
 	btVector3 btImp;
 	G_TO_B(p_impulse, btImp);
-	if (Vector3() != p_impulse)
+	if (Vector3() != p_impulse) {
 		btBody->activate();
+	}
 	btBody->applyTorqueImpulse(btImp);
 }
 
@@ -635,32 +642,36 @@ void RigidBodyBullet::apply_force(const Vector3 &p_force, const Vector3 &p_pos)
 	btVector3 btPos;
 	G_TO_B(p_force, btForce);
 	G_TO_B(p_pos, btPos);
-	if (Vector3() != p_force)
+	if (Vector3() != p_force) {
 		btBody->activate();
+	}
 	btBody->applyForce(btForce, btPos);
 }
 
 void RigidBodyBullet::apply_central_force(const Vector3 &p_force) {
 	btVector3 btForce;
 	G_TO_B(p_force, btForce);
-	if (Vector3() != p_force)
+	if (Vector3() != p_force) {
 		btBody->activate();
+	}
 	btBody->applyCentralForce(btForce);
 }
 
 void RigidBodyBullet::apply_torque(const Vector3 &p_torque) {
 	btVector3 btTorq;
 	G_TO_B(p_torque, btTorq);
-	if (Vector3() != p_torque)
+	if (Vector3() != p_torque) {
 		btBody->activate();
+	}
 	btBody->applyTorque(btTorq);
 }
 
 void RigidBodyBullet::set_applied_force(const Vector3 &p_force) {
 	btVector3 btVec = btBody->getTotalTorque();
 
-	if (Vector3() != p_force)
+	if (Vector3() != p_force) {
 		btBody->activate();
+	}
 
 	btBody->clearForces();
 	btBody->applyTorque(btVec);
@@ -678,8 +689,9 @@ Vector3 RigidBodyBullet::get_applied_force() const {
 void RigidBodyBullet::set_applied_torque(const Vector3 &p_torque) {
 	btVector3 btVec = btBody->getTotalForce();
 
-	if (Vector3() != p_torque)
+	if (Vector3() != p_torque) {
 		btBody->activate();
+	}
 
 	btBody->clearForces();
 	btBody->applyCentralForce(btVec);
@@ -747,8 +759,9 @@ bool RigidBodyBullet::is_continuous_collision_detection_enabled() const {
 void RigidBodyBullet::set_linear_velocity(const Vector3 &p_velocity) {
 	btVector3 btVec;
 	G_TO_B(p_velocity, btVec);
-	if (Vector3() != p_velocity)
+	if (Vector3() != p_velocity) {
 		btBody->activate();
+	}
 	btBody->setLinearVelocity(btVec);
 }
 
@@ -761,8 +774,9 @@ Vector3 RigidBodyBullet::get_linear_velocity() const {
 void RigidBodyBullet::set_angular_velocity(const Vector3 &p_velocity) {
 	btVector3 btVec;
 	G_TO_B(p_velocity, btVec);
-	if (Vector3() != p_velocity)
+	if (Vector3() != p_velocity) {
 		btBody->activate();
+	}
 	btBody->setAngularVelocity(btVec);
 }
 
@@ -774,8 +788,9 @@ Vector3 RigidBodyBullet::get_angular_velocity() const {
 
 void RigidBodyBullet::set_transform__bullet(const btTransform &p_global_transform) {
 	if (mode == PhysicsServer3D::BODY_MODE_KINEMATIC) {
-		if (space && space->get_delta_time() != 0)
+		if (space && space->get_delta_time() != 0) {
 			btBody->setLinearVelocity((p_global_transform.getOrigin() - btBody->getWorldTransform().getOrigin()) / space->get_delta_time());
+		}
 		// The kinematic use MotionState class
 		godotMotionState->moveBody(p_global_transform);
 	} else {
@@ -804,8 +819,9 @@ void RigidBodyBullet::reload_shapes() {
 		// shapes incorrectly do not set the vector in calculateLocalIntertia.
 		// Arbitrary zero is preferable to undefined behaviour.
 		btVector3 inertia(0, 0, 0);
-		if (EMPTY_SHAPE_PROXYTYPE != mainShape->getShapeType()) // Necessary to avoid assertion of the empty shape
+		if (EMPTY_SHAPE_PROXYTYPE != mainShape->getShapeType()) { // Necessary to avoid assertion of the empty shape
 			mainShape->calculateLocalInertia(mass, inertia);
+		}
 		btBody->setMassProps(mass, inertia);
 	}
 	btBody->updateInertiaTensor();
@@ -879,8 +895,9 @@ void RigidBodyBullet::on_exit_area(AreaBullet *p_area) {
 
 void RigidBodyBullet::reload_space_override_modificator() {
 	// Make sure that kinematic bodies have their total gravity calculated
-	if (!is_active() && PhysicsServer3D::BODY_MODE_KINEMATIC != mode)
+	if (!is_active() && PhysicsServer3D::BODY_MODE_KINEMATIC != mode) {
 		return;
+	}
 
 	Vector3 newGravity(0.0, 0.0, 0.0);
 	real_t newLinearDamp = MAX(0.0, linearDamp);
@@ -1001,12 +1018,14 @@ void RigidBodyBullet::_internal_set_mass(real_t p_mass) {
 	// Rigidbody is dynamic if and only if mass is non Zero, otherwise static
 	const bool isDynamic = p_mass != 0.f;
 	if (isDynamic) {
-		if (PhysicsServer3D::BODY_MODE_RIGID != mode && PhysicsServer3D::BODY_MODE_CHARACTER != mode)
+		if (PhysicsServer3D::BODY_MODE_RIGID != mode && PhysicsServer3D::BODY_MODE_CHARACTER != mode) {
 			return;
+		}
 
 		m_isStatic = false;
-		if (mainShape)
+		if (mainShape) {
 			mainShape->calculateLocalInertia(p_mass, localInertia);
+		}
 
 		if (PhysicsServer3D::BODY_MODE_RIGID == mode) {
 			btBody->setCollisionFlags(clearedCurrentFlags); // Just set the flags without Kin and Static
@@ -1020,8 +1039,9 @@ void RigidBodyBullet::_internal_set_mass(real_t p_mass) {
 			btBody->forceActivationState(DISABLE_DEACTIVATION); // DISABLE_DEACTIVATION 4
 		}
 	} else {
-		if (PhysicsServer3D::BODY_MODE_STATIC != mode && PhysicsServer3D::BODY_MODE_KINEMATIC != mode)
+		if (PhysicsServer3D::BODY_MODE_STATIC != mode && PhysicsServer3D::BODY_MODE_KINEMATIC != mode) {
 			return;
+		}
 
 		m_isStatic = true;
 		if (PhysicsServer3D::BODY_MODE_STATIC == mode) {
diff --git a/modules/bullet/shape_bullet.cpp b/modules/bullet/shape_bullet.cpp
index 424daf7726..d53f1e7d17 100644
--- a/modules/bullet/shape_bullet.cpp
+++ b/modules/bullet/shape_bullet.cpp
@@ -80,8 +80,9 @@ void ShapeBullet::add_owner(ShapeOwnerBullet *p_owner) {
 
 void ShapeBullet::remove_owner(ShapeOwnerBullet *p_owner, bool p_permanentlyFromThisBody) {
 	Map<ShapeOwnerBullet *, int>::Element *E = owners.find(p_owner);
-	if (!E)
+	if (!E) {
 		return;
+	}
 	E->get()--;
 	if (p_permanentlyFromThisBody || 0 >= E->get()) {
 		owners.erase(E);
@@ -150,8 +151,9 @@ btHeightfieldTerrainShape *ShapeBullet::create_shape_height_field(Vector<real_t>
 	btHeightfieldTerrainShape *heightfield = bulletnew(btHeightfieldTerrainShape(p_width, p_depth, heightsPtr, ignoredHeightScale, p_min_height, p_max_height, YAxis, PHY_FLOAT, flipQuadEdges));
 
 	// The shape can be created without params when you do PhysicsServer3D.shape_create(PhysicsServer3D.SHAPE_HEIGHTMAP)
-	if (heightsPtr)
+	if (heightsPtr) {
 		heightfield->buildAccelerator(16);
+	}
 
 	return heightfield;
 }
@@ -348,9 +350,10 @@ void ConvexPolygonShapeBullet::setup(const Vector<Vector3> &p_vertices) {
 }
 
 btCollisionShape *ConvexPolygonShapeBullet::create_bt_shape(const btVector3 &p_implicit_scale, real_t p_extra_edge) {
-	if (!vertices.size())
+	if (!vertices.size()) {
 		// This is necessary since 0 vertices
 		return prepare(ShapeBullet::create_shape_empty());
+	}
 	btCollisionShape *cs(ShapeBullet::create_shape_convex(vertices));
 	cs->setLocalScaling(p_implicit_scale);
 	prepare(cs);
@@ -430,9 +433,10 @@ void ConcavePolygonShapeBullet::setup(Vector<Vector3> p_faces) {
 
 btCollisionShape *ConcavePolygonShapeBullet::create_bt_shape(const btVector3 &p_implicit_scale, real_t p_extra_edge) {
 	btCollisionShape *cs = ShapeBullet::create_shape_concave(meshShape);
-	if (!cs)
+	if (!cs) {
 		// This is necessary since if 0 faces the creation of concave return null
 		cs = ShapeBullet::create_shape_empty();
+	}
 	cs->setLocalScaling(p_implicit_scale);
 	prepare(cs);
 	cs->setMargin(0);
@@ -455,10 +459,12 @@ void HeightMapShapeBullet::set_data(const Variant &p_data) {
 	real_t l_max_height = 0.0;
 
 	// If specified, min and max height will be used as precomputed values
-	if (d.has("min_height"))
+	if (d.has("min_height")) {
 		l_min_height = d["min_height"];
-	if (d.has("max_height"))
+	}
+	if (d.has("max_height")) {
 		l_max_height = d["max_height"];
+	}
 
 	ERR_FAIL_COND(l_min_height > l_max_height);
 
diff --git a/modules/bullet/soft_body_bullet.cpp b/modules/bullet/soft_body_bullet.cpp
index 3047a3eed1..6794d6c313 100644
--- a/modules/bullet/soft_body_bullet.cpp
+++ b/modules/bullet/soft_body_bullet.cpp
@@ -66,8 +66,9 @@ void SoftBodyBullet::on_enter_area(AreaBullet *p_area) {}
 void SoftBodyBullet::on_exit_area(AreaBullet *p_area) {}
 
 void SoftBodyBullet::update_rendering_server(SoftBodyRenderingServerHandler *p_rendering_server_handler) {
-	if (!bt_soft_body)
+	if (!bt_soft_body) {
 		return;
+	}
 
 	/// Update visual server vertices
 	const btSoftBody::tNodeArray &nodes(bt_soft_body->m_nodes);
@@ -105,10 +106,11 @@ void SoftBodyBullet::update_rendering_server(SoftBodyRenderingServerHandler *p_r
 }
 
 void SoftBodyBullet::set_soft_mesh(const Ref<Mesh> &p_mesh) {
-	if (p_mesh.is_null())
+	if (p_mesh.is_null()) {
 		soft_mesh.unref();
-	else
+	} else {
 		soft_mesh = p_mesh;
+	}
 
 	if (soft_mesh.is_null()) {
 		destroy_soft_body();
@@ -121,8 +123,9 @@ void SoftBodyBullet::set_soft_mesh(const Ref<Mesh> &p_mesh) {
 }
 
 void SoftBodyBullet::destroy_soft_body() {
-	if (!bt_soft_body)
+	if (!bt_soft_body) {
 		return;
+	}
 
 	if (space) {
 		/// Remove from world before deletion
@@ -139,8 +142,9 @@ void SoftBodyBullet::set_soft_transform(const Transform &p_transform) {
 }
 
 void SoftBodyBullet::move_all_nodes(const Transform &p_transform) {
-	if (!bt_soft_body)
+	if (!bt_soft_body) {
 		return;
+	}
 	btTransform bt_transf;
 	G_TO_B(p_transform, bt_transf);
 	bt_soft_body->transform(bt_transf);
@@ -166,8 +170,9 @@ void SoftBodyBullet::get_node_position(int p_node_index, Vector3 &r_position) co
 }
 
 void SoftBodyBullet::get_node_offset(int p_node_index, Vector3 &r_offset) const {
-	if (soft_mesh.is_null())
+	if (soft_mesh.is_null()) {
 		return;
+	}
 
 	Array arrays = soft_mesh->surface_get_arrays(0);
 	Vector<Vector3> vertices(arrays[RS::ARRAY_VERTEX]);
@@ -212,8 +217,9 @@ void SoftBodyBullet::reset_all_node_mass() {
 }
 
 void SoftBodyBullet::reset_all_node_positions() {
-	if (soft_mesh.is_null())
+	if (soft_mesh.is_null()) {
 		return;
+	}
 
 	Array arrays = soft_mesh->surface_get_arrays(0);
 	Vector<Vector3> vs_vertices(arrays[RS::ARRAY_VERTEX]);
@@ -382,8 +388,9 @@ void SoftBodyBullet::set_trimesh_body_shape(Vector<int> p_indices, Vector<Vector
 }
 
 void SoftBodyBullet::setup_soft_body() {
-	if (!bt_soft_body)
+	if (!bt_soft_body) {
 		return;
+	}
 
 	// Soft body setup
 	setupBulletCollisionObject(bt_soft_body);
diff --git a/modules/bullet/space_bullet.cpp b/modules/bullet/space_bullet.cpp
index 433f1109c9..99f58e7059 100644
--- a/modules/bullet/space_bullet.cpp
+++ b/modules/bullet/space_bullet.cpp
@@ -63,8 +63,9 @@ BulletPhysicsDirectSpaceState::BulletPhysicsDirectSpaceState(SpaceBullet *p_spac
 		space(p_space) {}
 
 int BulletPhysicsDirectSpaceState::intersect_point(const Vector3 &p_point, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return 0;
+	}
 
 	btVector3 bt_point;
 	G_TO_B(p_point, bt_point);
@@ -117,8 +118,9 @@ bool BulletPhysicsDirectSpaceState::intersect_ray(const Vector3 &p_from, const V
 }
 
 int BulletPhysicsDirectSpaceState::intersect_shape(const RID &p_shape, const Transform &p_xform, float p_margin, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return 0;
+	}
 
 	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
 
@@ -202,8 +204,9 @@ bool BulletPhysicsDirectSpaceState::cast_motion(const RID &p_shape, const Transf
 
 /// Returns the list of contacts pairs in this order: Local contact, other body contact
 bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform &p_shape_xform, float p_margin, Vector3 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return false;
+	}
 
 	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
 
@@ -650,8 +653,9 @@ void SpaceBullet::check_ghost_overlaps() {
 
 		btVector3 area_scale(area->get_bt_body_scale());
 
-		if (!area->is_monitoring())
+		if (!area->is_monitoring()) {
 			continue;
+		}
 
 		/// 1. Reset all states
 		for (i = area->overlappingObjects.size() - 1; 0 <= i; --i) {
@@ -680,15 +684,18 @@ void SpaceBullet::check_ghost_overlaps() {
 			}
 
 			if (overlapped_bt_co->getUserIndex() == CollisionObjectBullet::TYPE_AREA) {
-				if (!static_cast<AreaBullet *>(overlapped_bt_co->getUserPointer())->is_monitorable())
+				if (!static_cast<AreaBullet *>(overlapped_bt_co->getUserPointer())->is_monitorable()) {
 					continue;
-			} else if (overlapped_bt_co->getUserIndex() != CollisionObjectBullet::TYPE_RIGID_BODY)
+				}
+			} else if (overlapped_bt_co->getUserIndex() != CollisionObjectBullet::TYPE_RIGID_BODY) {
 				continue;
+			}
 
 			// For each area shape
 			for (y = area->get_shape_count() - 1; 0 <= y; --y) {
-				if (!area->get_bt_shape(y)->isConvex())
+				if (!area->get_bt_shape(y)->isConvex()) {
 					continue;
+				}
 
 				btTransform area_shape_treansform(area->get_bt_shape_transform(y));
 				area_shape_treansform.getOrigin() *= area_scale;
@@ -730,8 +737,9 @@ void SpaceBullet::check_ghost_overlaps() {
 
 						btCollisionAlgorithm *algorithm = dispatcher->findAlgorithm(&obA, &obB, nullptr, BT_CONTACT_POINT_ALGORITHMS);
 
-						if (!algorithm)
+						if (!algorithm) {
 							continue;
+						}
 
 						GodotDeepPenetrationContactResultCallback contactPointResult(&obA, &obB);
 						algorithm->processCollision(&obA, &obB, dynamicsWorld->getDispatchInfo(), &contactPointResult);
@@ -749,8 +757,9 @@ void SpaceBullet::check_ghost_overlaps() {
 			} // ~For each area shape
 
 		collision_found:
-			if (!hasOverlap)
+			if (!hasOverlap) {
 				continue;
+			}
 
 			indexOverlap = area->find_overlapping_object(otherObject);
 			if (-1 == indexOverlap) {
@@ -1195,8 +1204,9 @@ bool SpaceBullet::recover_from_penetration(RigidBodyBullet *p_body, const btTran
 			if (p_infinite_inertia && !otherObject->isStaticOrKinematicObject()) {
 				otherObject->activate(); // Force activation of hitten rigid, soft body
 				continue;
-			} else if (!p_body->get_bt_collision_object()->checkCollideWith(otherObject) || !otherObject->checkCollideWith(p_body->get_bt_collision_object()))
+			} else if (!p_body->get_bt_collision_object()->checkCollideWith(otherObject) || !otherObject->checkCollideWith(p_body->get_bt_collision_object())) {
 				continue;
+			}
 
 			if (otherObject->getCollisionShape()->isCompound()) {
 				const btCompoundShape *cs = static_cast<const btCompoundShape *>(otherObject->getCollisionShape());
@@ -1384,8 +1394,9 @@ int SpaceBullet::recover_from_penetration_ray(RigidBodyBullet *p_body, const btT
 			if (p_infinite_inertia && !otherObject->isStaticOrKinematicObject()) {
 				otherObject->activate(); // Force activation of hitten rigid, soft body
 				continue;
-			} else if (!p_body->get_bt_collision_object()->checkCollideWith(otherObject) || !otherObject->checkCollideWith(p_body->get_bt_collision_object()))
+			} else if (!p_body->get_bt_collision_object()->checkCollideWith(otherObject) || !otherObject->checkCollideWith(p_body->get_bt_collision_object())) {
 				continue;
+			}
 
 			if (otherObject->getCollisionShape()->isCompound()) {
 				const btCompoundShape *cs = static_cast<const btCompoundShape *>(otherObject->getCollisionShape());
diff --git a/modules/bullet/space_bullet.h b/modules/bullet/space_bullet.h
index 2dad965de8..5ff421ef52 100644
--- a/modules/bullet/space_bullet.h
+++ b/modules/bullet/space_bullet.h
@@ -169,8 +169,9 @@ public:
 		contactDebugCount = 0;
 	}
 	_FORCE_INLINE_ void add_debug_contact(const Vector3 &p_contact) {
-		if (contactDebugCount < contactDebug.size())
+		if (contactDebugCount < contactDebug.size()) {
 			contactDebug.write[contactDebugCount++] = p_contact;
+		}
 	}
 	_FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contactDebug; }
 	_FORCE_INLINE_ int get_debug_contact_count() { return contactDebugCount; }