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

2 files changed, 134 insertions, 70 deletions

diff --git a/modules/gridmap/grid_map.cpp b/modules/gridmap/grid_map.cpp
index 02258d706a..2975a97bfe 100644
--- a/modules/gridmap/grid_map.cpp
+++ b/modules/gridmap/grid_map.cpp
@@ -118,8 +118,9 @@ bool GridMap::_get(const StringName &p_name, Variant &r_ret) const {
 		}
 		r_ret = ret;
 
-	} else
+	} else {
 		return false;
+	}
 
 	return true;
 }
@@ -152,10 +153,11 @@ uint32_t GridMap::get_collision_mask() const {
 
 void GridMap::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);
 }
 
@@ -165,10 +167,11 @@ bool GridMap::get_collision_mask_bit(int p_bit) const {
 
 void GridMap::set_collision_layer_bit(int p_bit, bool p_value) {
 	uint32_t mask = get_collision_layer();
-	if (p_value)
+	if (p_value) {
 		mask |= 1 << p_bit;
-	else
+	} else {
 		mask &= ~(1 << p_bit);
+	}
 	set_collision_layer(mask);
 }
 
@@ -177,11 +180,13 @@ bool GridMap::get_collision_layer_bit(int p_bit) const {
 }
 
 void GridMap::set_mesh_library(const Ref<MeshLibrary> &p_mesh_library) {
-	if (!mesh_library.is_null())
+	if (!mesh_library.is_null()) {
 		mesh_library->unregister_owner(this);
+	}
 	mesh_library = p_mesh_library;
-	if (!mesh_library.is_null())
+	if (!mesh_library.is_null()) {
 		mesh_library->register_owner(this);
+	}
 
 	_recreate_octant_data();
 	_change_notify("mesh_library");
@@ -323,8 +328,9 @@ int GridMap::get_cell_item(int p_x, int p_y, int p_z) const {
 	key.y = p_y;
 	key.z = p_z;
 
-	if (!cell_map.has(key))
+	if (!cell_map.has(key)) {
 		return INVALID_CELL_ITEM;
+	}
 	return cell_map[key].item;
 }
 
@@ -338,8 +344,9 @@ int GridMap::get_cell_item_orientation(int p_x, int p_y, int p_z) const {
 	key.y = p_y;
 	key.z = p_z;
 
-	if (!cell_map.has(key))
+	if (!cell_map.has(key)) {
 		return -1;
+	}
 	return cell_map[key].rot;
 }
 
@@ -377,8 +384,9 @@ void GridMap::_octant_transform(const OctantKey &p_key) {
 bool GridMap::_octant_update(const OctantKey &p_key) {
 	ERR_FAIL_COND_V(!octant_map.has(p_key), false);
 	Octant &g = *octant_map[p_key];
-	if (!g.dirty)
+	if (!g.dirty) {
 		return false;
+	}
 
 	//erase body shapes
 	PhysicsServer3D::get_singleton()->body_clear_shapes(g.static_body);
@@ -422,8 +430,9 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 		ERR_CONTINUE(!cell_map.has(E->get()));
 		const Cell &c = cell_map[E->get()];
 
-		if (!mesh_library.is_valid() || !mesh_library->has_item(c.item))
+		if (!mesh_library.is_valid() || !mesh_library->has_item(c.item)) {
 			continue;
+		}
 
 		Vector3 cellpos = Vector3(E->get().x, E->get().y, E->get().z);
 		Vector3 ofs = _get_offset();
@@ -450,8 +459,9 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 		// add the item's shape at given xform to octant's static_body
 		for (int i = 0; i < shapes.size(); i++) {
 			// add the item's shape
-			if (!shapes[i].shape.is_valid())
+			if (!shapes[i].shape.is_valid()) {
 				continue;
+			}
 			PhysicsServer3D::get_singleton()->body_add_shape(g.static_body, shapes[i].shape->get_rid(), xform * shapes[i].local_transform);
 			if (g.collision_debug.is_valid()) {
 				shapes.write[i].shape->add_vertices_to_array(col_debug, xform * shapes[i].local_transform);
@@ -598,10 +608,12 @@ void GridMap::_octant_clean_up(const OctantKey &p_key) {
 	ERR_FAIL_COND(!octant_map.has(p_key));
 	Octant &g = *octant_map[p_key];
 
-	if (g.collision_debug.is_valid())
+	if (g.collision_debug.is_valid()) {
 		RS::get_singleton()->free(g.collision_debug);
-	if (g.collision_debug_instance.is_valid())
+	}
+	if (g.collision_debug_instance.is_valid()) {
 		RS::get_singleton()->free(g.collision_debug_instance);
+	}
 
 	PhysicsServer3D::get_singleton()->free(g.static_body);
 
@@ -647,8 +659,9 @@ void GridMap::_notification(int p_what) {
 		} break;
 		case NOTIFICATION_TRANSFORM_CHANGED: {
 			Transform new_xform = get_global_transform();
-			if (new_xform == last_transform)
+			if (new_xform == last_transform) {
 				break;
+			}
 			//update run
 			for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 				_octant_transform(E->key());
@@ -683,8 +696,9 @@ void GridMap::_notification(int p_what) {
 }
 
 void GridMap::_update_visibility() {
-	if (!is_inside_tree())
+	if (!is_inside_tree()) {
 		return;
+	}
 
 	_change_notify("visible");
 
@@ -698,8 +712,9 @@ void GridMap::_update_visibility() {
 }
 
 void GridMap::_queue_octants_dirty() {
-	if (awaiting_update)
+	if (awaiting_update) {
 		return;
+	}
 
 	MessageQueue::get_singleton()->push_call(this, "_update_octants_callback");
 	awaiting_update = true;
@@ -717,8 +732,9 @@ void GridMap::_recreate_octant_data() {
 
 void GridMap::_clear_internal() {
 	for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
-		if (is_inside_world())
+		if (is_inside_world()) {
 			_octant_exit_world(E->key());
+		}
 
 		_octant_clean_up(E->key());
 		memdelete(E->get());
@@ -738,8 +754,9 @@ void GridMap::resource_changed(const RES &p_res) {
 }
 
 void GridMap::_update_octants_callback() {
-	if (!awaiting_update)
+	if (!awaiting_update) {
 		return;
+	}
 
 	List<OctantKey> to_delete;
 	for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
@@ -830,10 +847,12 @@ void GridMap::_bind_methods() {
 }
 
 void GridMap::set_clip(bool p_enabled, bool p_clip_above, int p_floor, Vector3::Axis p_axis) {
-	if (!p_enabled && !clip)
+	if (!p_enabled && !clip) {
 		return;
-	if (clip && p_enabled && clip_floor == p_floor && p_clip_above == clip_above && p_axis == clip_axis)
+	}
+	if (clip && p_enabled && clip_floor == p_floor && p_clip_above == clip_above && p_axis == clip_axis) {
 		return;
+	}
 
 	clip = p_enabled;
 	clip_floor = p_floor;
@@ -871,19 +890,22 @@ Array GridMap::get_used_cells() const {
 }
 
 Array GridMap::get_meshes() {
-	if (mesh_library.is_null())
+	if (mesh_library.is_null()) {
 		return Array();
+	}
 
 	Vector3 ofs = _get_offset();
 	Array meshes;
 
 	for (Map<IndexKey, Cell>::Element *E = cell_map.front(); E; E = E->next()) {
 		int id = E->get().item;
-		if (!mesh_library->has_item(id))
+		if (!mesh_library->has_item(id)) {
 			continue;
+		}
 		Ref<Mesh> mesh = mesh_library->get_item_mesh(id);
-		if (mesh.is_null())
+		if (mesh.is_null()) {
 			continue;
+		}
 
 		IndexKey ik = E->key();
 
@@ -920,8 +942,9 @@ void GridMap::clear_baked_meshes() {
 }
 
 void GridMap::make_baked_meshes(bool p_gen_lightmap_uv, float p_lightmap_uv_texel_size) {
-	if (!mesh_library.is_valid())
+	if (!mesh_library.is_valid()) {
 		return;
+	}
 
 	//generate
 	Map<OctantKey, Map<Ref<Material>, Ref<SurfaceTool>>> surface_map;
@@ -930,12 +953,14 @@ void GridMap::make_baked_meshes(bool p_gen_lightmap_uv, float p_lightmap_uv_texe
 		IndexKey key = E->key();
 
 		int item = E->get().item;
-		if (!mesh_library->has_item(item))
+		if (!mesh_library->has_item(item)) {
 			continue;
+		}
 
 		Ref<Mesh> mesh = mesh_library->get_item_mesh(item);
-		if (!mesh.is_valid())
+		if (!mesh.is_valid()) {
 			continue;
+		}
 
 		Vector3 cellpos = Vector3(key.x, key.y, key.z);
 		Vector3 ofs = _get_offset();
@@ -958,8 +983,9 @@ void GridMap::make_baked_meshes(bool p_gen_lightmap_uv, float p_lightmap_uv_texe
 		Map<Ref<Material>, Ref<SurfaceTool>> &mat_map = surface_map[ok];
 
 		for (int i = 0; i < mesh->get_surface_count(); i++) {
-			if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES)
+			if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
 				continue;
+			}
 
 			Ref<Material> surf_mat = mesh->surface_get_material(i);
 			if (!mat_map.has(surf_mat)) {
@@ -1043,8 +1069,9 @@ GridMap::GridMap() {
 }
 
 GridMap::~GridMap() {
-	if (!mesh_library.is_null())
+	if (!mesh_library.is_null()) {
 		mesh_library->unregister_owner(this);
+	}
 
 	clear();
 }
diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp
index e8f7d09bb2..2bae43510a 100644
--- a/modules/gridmap/grid_map_editor_plugin.cpp
+++ b/modules/gridmap/grid_map_editor_plugin.cpp
@@ -40,13 +40,15 @@
 #include "scene/main/window.h"
 
 void GridMapEditor::_node_removed(Node *p_node) {
-	if (p_node == node)
+	if (p_node == node) {
 		node = nullptr;
+	}
 }
 
 void GridMapEditor::_configure() {
-	if (!node)
+	if (!node) {
 		return;
+	}
 
 	update_grid();
 }
@@ -213,8 +215,9 @@ void GridMapEditor::_menu_option(int p_option) {
 
 		case MENU_OPTION_SELECTION_DUPLICATE:
 		case MENU_OPTION_SELECTION_CUT: {
-			if (!(selection.active && input_action == INPUT_NONE))
+			if (!(selection.active && input_action == INPUT_NONE)) {
 				break;
+			}
 
 			_set_clipboard_data();
 
@@ -231,15 +234,17 @@ void GridMapEditor::_menu_option(int p_option) {
 			_update_paste_indicator();
 		} break;
 		case MENU_OPTION_SELECTION_CLEAR: {
-			if (!selection.active)
+			if (!selection.active) {
 				break;
+			}
 
 			_delete_selection();
 
 		} break;
 		case MENU_OPTION_SELECTION_FILL: {
-			if (!selection.active)
+			if (!selection.active) {
 				return;
+			}
 
 			_fill_selection();
 
@@ -303,17 +308,21 @@ void GridMapEditor::_update_selection_transform() {
 }
 
 void GridMapEditor::_validate_selection() {
-	if (!selection.active)
+	if (!selection.active) {
 		return;
+	}
 	selection.begin = selection.click;
 	selection.end = selection.current;
 
-	if (selection.begin.x > selection.end.x)
+	if (selection.begin.x > selection.end.x) {
 		SWAP(selection.begin.x, selection.end.x);
-	if (selection.begin.y > selection.end.y)
+	}
+	if (selection.begin.y > selection.end.y) {
 		SWAP(selection.begin.y, selection.end.y);
-	if (selection.begin.z > selection.end.z)
+	}
+	if (selection.begin.z > selection.end.z) {
 		SWAP(selection.begin.z, selection.end.z);
+	}
 
 	_update_selection_transform();
 }
@@ -336,16 +345,20 @@ void GridMapEditor::_set_selection(bool p_active, const Vector3 &p_begin, const
 }
 
 bool GridMapEditor::do_input_action(Camera3D *p_camera, const Point2 &p_point, bool p_click) {
-	if (!spatial_editor)
+	if (!spatial_editor) {
 		return false;
+	}
 
-	if (selected_palette < 0 && input_action != INPUT_PICK && input_action != INPUT_SELECT && input_action != INPUT_PASTE)
+	if (selected_palette < 0 && input_action != INPUT_PICK && input_action != INPUT_SELECT && input_action != INPUT_PASTE) {
 		return false;
+	}
 	Ref<MeshLibrary> mesh_library = node->get_mesh_library();
-	if (mesh_library.is_null())
+	if (mesh_library.is_null()) {
 		return false;
-	if (input_action != INPUT_PICK && input_action != INPUT_SELECT && input_action != INPUT_PASTE && !mesh_library->has_item(selected_palette))
+	}
+	if (input_action != INPUT_PICK && input_action != INPUT_SELECT && input_action != INPUT_PASTE && !mesh_library->has_item(selected_palette)) {
 		return false;
+	}
 
 	Camera3D *camera = p_camera;
 	Vector3 from = camera->project_ray_origin(p_point);
@@ -360,27 +373,30 @@ bool GridMapEditor::do_input_action(Camera3D *p_camera, const Point2 &p_point, b
 	p.d = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
 
 	Vector3 inters;
-	if (!p.intersects_segment(from, from + normal * settings_pick_distance->get_value(), &inters))
+	if (!p.intersects_segment(from, from + normal * settings_pick_distance->get_value(), &inters)) {
 		return false;
+	}
 
 	// Make sure the intersection is inside the frustum planes, to avoid
 	// Painting on invisible regions.
 	for (int i = 0; i < planes.size(); i++) {
 		Plane fp = local_xform.xform(planes[i]);
-		if (fp.is_point_over(inters))
+		if (fp.is_point_over(inters)) {
 			return false;
+		}
 	}
 
 	int cell[3];
 	float cell_size[3] = { node->get_cell_size().x, node->get_cell_size().y, node->get_cell_size().z };
 
 	for (int i = 0; i < 3; i++) {
-		if (i == edit_axis)
+		if (i == edit_axis) {
 			cell[i] = edit_floor[i];
-		else {
+		} else {
 			cell[i] = inters[i] / node->get_cell_size()[i];
-			if (inters[i] < 0)
+			if (inters[i] < 0) {
 				cell[i] -= 1; // Compensate negative.
+			}
 			grid_ofs[i] = cell[i] * cell_size[i];
 		}
 	}
@@ -404,8 +420,9 @@ bool GridMapEditor::do_input_action(Camera3D *p_camera, const Point2 &p_point, b
 
 	} else if (input_action == INPUT_SELECT) {
 		selection.current = Vector3(cell[0], cell[1], cell[2]);
-		if (p_click)
+		if (p_click) {
 			selection.click = selection.current;
+		}
 		selection.active = true;
 		_validate_selection();
 
@@ -446,8 +463,9 @@ bool GridMapEditor::do_input_action(Camera3D *p_camera, const Point2 &p_point, b
 }
 
 void GridMapEditor::_delete_selection() {
-	if (!selection.active)
+	if (!selection.active) {
 		return;
+	}
 
 	undo_redo->create_action(TTR("GridMap Delete Selection"));
 	for (int i = selection.begin.x; i <= selection.end.x; i++) {
@@ -464,8 +482,9 @@ void GridMapEditor::_delete_selection() {
 }
 
 void GridMapEditor::_fill_selection() {
-	if (!selection.active)
+	if (!selection.active) {
 		return;
+	}
 
 	undo_redo->create_action(TTR("GridMap Fill Selection"));
 	for (int i = selection.begin.x; i <= selection.end.x; i++) {
@@ -498,8 +517,9 @@ void GridMapEditor::_set_clipboard_data() {
 		for (int j = selection.begin.y; j <= selection.end.y; j++) {
 			for (int k = selection.begin.z; k <= selection.end.z; k++) {
 				int itm = node->get_cell_item(i, j, k);
-				if (itm == GridMap::INVALID_CELL_ITEM)
+				if (itm == GridMap::INVALID_CELL_ITEM) {
 					continue;
+				}
 
 				Ref<Mesh> mesh = meshLibrary->get_item_mesh(itm);
 
@@ -593,13 +613,15 @@ bool GridMapEditor::forward_spatial_input_event(Camera3D *p_camera, const Ref<In
 
 	if (mb.is_valid()) {
 		if (mb->get_button_index() == BUTTON_WHEEL_UP && (mb->get_command() || mb->get_shift())) {
-			if (mb->is_pressed())
+			if (mb->is_pressed()) {
 				floor->set_value(floor->get_value() + mb->get_factor());
+			}
 
 			return true; // Eaten.
 		} else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && (mb->get_command() || mb->get_shift())) {
-			if (mb->is_pressed())
+			if (mb->is_pressed()) {
 				floor->set_value(floor->get_value() - mb->get_factor());
+			}
 			return true;
 		}
 
@@ -859,8 +881,9 @@ void GridMapEditor::update_palette() {
 			name = "#" + itos(id);
 		}
 
-		if (filter != "" && !filter.is_subsequence_ofi(name))
+		if (filter != "" && !filter.is_subsequence_ofi(name)) {
 			continue;
+		}
 
 		mesh_library_palette->add_item("");
 		if (!preview.is_null()) {
@@ -881,8 +904,9 @@ void GridMapEditor::update_palette() {
 }
 
 void GridMapEditor::edit(GridMap *p_gridmap) {
-	if (!p_gridmap && node)
+	if (!p_gridmap && node) {
 		node->disconnect("cell_size_changed", callable_mp(this, &GridMapEditor::_draw_grids));
+	}
 
 	node = p_gridmap;
 
@@ -921,10 +945,11 @@ void GridMapEditor::edit(GridMap *p_gridmap) {
 
 void GridMapEditor::_update_clip() {
 	node->set_meta("_editor_clip_", clip_mode);
-	if (clip_mode == CLIP_DISABLED)
+	if (clip_mode == CLIP_DISABLED) {
 		node->set_clip(false);
-	else
+	} else {
 		node->set_clip(true, clip_mode == CLIP_ABOVE, edit_floor[edit_axis], edit_axis);
+	}
 }
 
 void GridMapEditor::update_grid() {
@@ -1045,8 +1070,9 @@ void GridMapEditor::_notification(int p_what) {
 				grid_xform = xf;
 			}
 			Ref<MeshLibrary> cgmt = node->get_mesh_library();
-			if (cgmt.operator->() != last_mesh_library)
+			if (cgmt.operator->() != last_mesh_library) {
 				update_palette();
+			}
 
 			if (lock_view) {
 				EditorNode *editor = Object::cast_to<EditorNode>(get_tree()->get_root()->get_child(0));
@@ -1057,8 +1083,9 @@ void GridMapEditor::_notification(int p_what) {
 				p = node->get_transform().xform(p); // plane to snap
 
 				Node3DEditorPlugin *sep = Object::cast_to<Node3DEditorPlugin>(editor->get_editor_plugin_screen());
-				if (sep)
+				if (sep) {
 					sep->snap_cursor_to_plane(p);
+				}
 			}
 		} break;
 
@@ -1074,8 +1101,9 @@ void GridMapEditor::_update_cursor_instance() {
 		return;
 	}
 
-	if (cursor_instance.is_valid())
+	if (cursor_instance.is_valid()) {
 		RenderingServer::get_singleton()->free(cursor_instance);
+	}
 	cursor_instance = RID();
 
 	if (selected_palette >= 0) {
@@ -1096,8 +1124,9 @@ void GridMapEditor::_item_selected_cbk(int idx) {
 }
 
 void GridMapEditor::_floor_changed(float p_value) {
-	if (updating)
+	if (updating) {
 		return;
+	}
 
 	edit_floor[edit_axis] = p_value;
 	node->set_meta("_editor_floor_", Vector3(edit_floor[0], edit_floor[1], edit_floor[2]));
@@ -1284,10 +1313,11 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 				v[2] = v[1] * (1 - 2 * (j & 1));
 
 				for (int k = 0; k < 3; k++) {
-					if (i < 3)
+					if (i < 3) {
 						face_points[j][(i + k) % 3] = v[k];
-					else
+					} else {
 						face_points[3 - j][(i + k) % 3] = -v[k];
+					}
 				}
 			}
 
@@ -1395,25 +1425,32 @@ GridMapEditor::~GridMapEditor() {
 	_clear_clipboard_data();
 
 	for (int i = 0; i < 3; i++) {
-		if (grid[i].is_valid())
+		if (grid[i].is_valid()) {
 			RenderingServer::get_singleton()->free(grid[i]);
-		if (grid_instance[i].is_valid())
+		}
+		if (grid_instance[i].is_valid()) {
 			RenderingServer::get_singleton()->free(grid_instance[i]);
-		if (cursor_instance.is_valid())
+		}
+		if (cursor_instance.is_valid()) {
 			RenderingServer::get_singleton()->free(cursor_instance);
-		if (selection_level_instance[i].is_valid())
+		}
+		if (selection_level_instance[i].is_valid()) {
 			RenderingServer::get_singleton()->free(selection_level_instance[i]);
-		if (selection_level_mesh[i].is_valid())
+		}
+		if (selection_level_mesh[i].is_valid()) {
 			RenderingServer::get_singleton()->free(selection_level_mesh[i]);
+		}
 	}
 
 	RenderingServer::get_singleton()->free(selection_mesh);
-	if (selection_instance.is_valid())
+	if (selection_instance.is_valid()) {
 		RenderingServer::get_singleton()->free(selection_instance);
+	}
 
 	RenderingServer::get_singleton()->free(paste_mesh);
-	if (paste_instance.is_valid())
+	if (paste_instance.is_valid()) {
 		RenderingServer::get_singleton()->free(paste_instance);
+	}
 }
 
 void GridMapEditorPlugin::_notification(int p_what) {