Style: clang-format: Disable KeepEmptyLinesAtTheStartOfBlocks

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

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

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

Part of #33027.

7 files changed, 0 insertions, 182 deletions

diff --git a/modules/csg/csg.cpp b/modules/csg/csg.cpp
index a6951a9320..ccd1b89fb5 100644
--- a/modules/csg/csg.cpp
+++ b/modules/csg/csg.cpp
@@ -37,12 +37,10 @@
 // Static helper functions.
 
 inline static bool is_snapable(const Vector3 &p_point1, const Vector3 &p_point2, real_t p_distance) {
-
 	return (p_point1 - p_point2).length_squared() < p_distance * p_distance;
 }
 
 inline static Vector2 interpolate_segment_uv(const Vector2 p_segement_points[2], const Vector2 p_uvs[2], const Vector2 &p_interpolation_point) {
-
 	float segment_length = (p_segement_points[1] - p_segement_points[0]).length();
 	if (segment_length < CMP_EPSILON)
 		return p_uvs[0];
@@ -54,7 +52,6 @@ inline static Vector2 interpolate_segment_uv(const Vector2 p_segement_points[2],
 }
 
 inline static Vector2 interpolate_triangle_uv(const Vector2 p_vertices[3], const Vector2 p_uvs[3], const Vector2 &p_interpolation_point) {
-
 	if (p_interpolation_point.distance_squared_to(p_vertices[0]) < CMP_EPSILON2)
 		return p_uvs[0];
 	if (p_interpolation_point.distance_squared_to(p_vertices[1]) < CMP_EPSILON2)
@@ -83,7 +80,6 @@ inline static Vector2 interpolate_triangle_uv(const Vector2 p_vertices[3], const
 }
 
 static inline bool ray_intersects_triangle(const Vector3 &p_from, const Vector3 &p_dir, const Vector3 p_vertices[3], float p_tolerance, Vector3 &r_intersection_point) {
-
 	Vector3 edge1 = p_vertices[1] - p_vertices[0];
 	Vector3 edge2 = p_vertices[2] - p_vertices[0];
 	Vector3 h = p_dir.cross(edge2);
@@ -115,7 +111,6 @@ static inline bool ray_intersects_triangle(const Vector3 &p_from, const Vector3
 }
 
 inline bool is_point_in_triangle(const Vector3 &p_point, const Vector3 p_vertices[3], int p_shifted = 0) {
-
 	real_t det = p_vertices[0].dot(p_vertices[1].cross(p_vertices[2]));
 
 	// If determinant is, zero try shift the triangle and the point.
@@ -149,7 +144,6 @@ inline bool is_point_in_triangle(const Vector3 &p_point, const Vector3 p_vertice
 }
 
 inline static bool are_segements_parallel(const Vector2 p_segment1_points[2], const Vector2 p_segment2_points[2], float p_vertex_snap2) {
-
 	Vector2 segment1 = p_segment1_points[1] - p_segment1_points[0];
 	Vector2 segment2 = p_segment2_points[1] - p_segment2_points[0];
 	real_t segment1_length2 = segment1.dot(segment1);
@@ -172,7 +166,6 @@ inline static bool are_segements_parallel(const Vector2 p_segment1_points[2], co
 // CSGBrush
 
 void CSGBrush::_regen_face_aabbs() {
-
 	for (int i = 0; i < faces.size(); i++) {
 		faces.write[i].aabb = AABB();
 		faces.write[i].aabb.position = faces[i].vertices[0];
@@ -182,7 +175,6 @@ void CSGBrush::_regen_face_aabbs() {
 }
 
 void CSGBrush::build_from_faces(const Vector<Vector3> &p_vertices, const Vector<Vector2> &p_uvs, const Vector<bool> &p_smooth, const Vector<Ref<Material>> &p_materials, const Vector<bool> &p_invert_faces) {
-
 	faces.clear();
 
 	int vc = p_vertices.size();
@@ -204,7 +196,6 @@ void CSGBrush::build_from_faces(const Vector<Vector3> &p_vertices, const Vector<
 	faces.resize(p_vertices.size() / 3);
 
 	for (int i = 0; i < faces.size(); i++) {
-
 		Face &f = faces.write[i];
 		f.vertices[0] = rv[i * 3 + 0];
 		f.vertices[1] = rv[i * 3 + 1];
@@ -227,10 +218,8 @@ void CSGBrush::build_from_faces(const Vector<Vector3> &p_vertices, const Vector<
 			f.invert = false;
 
 		if (mc == vc / 3) {
-
 			Ref<Material> mat = rm[i];
 			if (mat.is_valid()) {
-
 				const Map<Ref<Material>, int>::Element *E = material_map.find(mat);
 
 				if (E) {
@@ -255,7 +244,6 @@ void CSGBrush::build_from_faces(const Vector<Vector3> &p_vertices, const Vector<
 }
 
 void CSGBrush::copy_from(const CSGBrush &p_brush, const Transform &p_xform) {
-
 	faces = p_brush.faces;
 	materials = p_brush.materials;
 
@@ -271,7 +259,6 @@ void CSGBrush::copy_from(const CSGBrush &p_brush, const Transform &p_xform) {
 // CSGBrushOperation
 
 void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_brush_a, const CSGBrush &p_brush_b, CSGBrush &r_merged_brush, float p_vertex_snap) {
-
 	// Check for face collisions and add necessary faces.
 	Build2DFaceCollection build2DFaceCollection;
 	for (int i = 0; i < p_brush_a.faces.size(); i++) {
@@ -287,7 +274,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 	mesh_merge.vertex_snap = p_vertex_snap;
 
 	for (int i = 0; i < p_brush_a.faces.size(); i++) {
-
 		Ref<Material> material;
 		if (p_brush_a.faces[i].material != -1) {
 			material = p_brush_a.materials[p_brush_a.faces[i].material];
@@ -307,7 +293,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 	}
 
 	for (int i = 0; i < p_brush_b.faces.size(); i++) {
-
 		Ref<Material> material;
 		if (p_brush_b.faces[i].material != -1) {
 			material = p_brush_b.materials[p_brush_b.faces[i].material];
@@ -333,9 +318,7 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 	r_merged_brush.faces.clear();
 
 	switch (p_operation) {
-
 		case OPERATION_UNION: {
-
 			int outside_count = 0;
 
 			for (int i = 0; i < mesh_merge.faces.size(); i++) {
@@ -349,7 +332,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 			outside_count = 0;
 
 			for (int i = 0; i < mesh_merge.faces.size(); i++) {
-
 				if (mesh_merge.faces[i].inside)
 					continue;
 
@@ -369,7 +351,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 		} break;
 
 		case OPERATION_INTERSECTION: {
-
 			int inside_count = 0;
 
 			for (int i = 0; i < mesh_merge.faces.size(); i++) {
@@ -383,7 +364,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 			inside_count = 0;
 
 			for (int i = 0; i < mesh_merge.faces.size(); i++) {
-
 				if (!mesh_merge.faces[i].inside)
 					continue;
 
@@ -403,7 +383,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 		} break;
 
 		case OPERATION_SUBSTRACTION: {
-
 			int face_count = 0;
 
 			for (int i = 0; i < mesh_merge.faces.size(); i++) {
@@ -419,7 +398,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 			face_count = 0;
 
 			for (int i = 0; i < mesh_merge.faces.size(); i++) {
-
 				if (mesh_merge.faces[i].from_b && !mesh_merge.faces[i].inside)
 					continue;
 				if (!mesh_merge.faces[i].from_b && mesh_merge.faces[i].inside)
@@ -460,7 +438,6 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 #define BVH_LIMIT 8
 
 int CSGBrushOperation::MeshMerge::_create_bvh(FaceBVH *facebvhptr, FaceBVH **facebvhptrptr, int p_from, int p_size, int p_depth, int &r_max_depth, int &r_max_alloc) {
-
 	if (p_depth > r_max_depth) {
 		r_max_depth = p_depth;
 	}
@@ -485,7 +462,6 @@ int CSGBrushOperation::MeshMerge::_create_bvh(FaceBVH *facebvhptr, FaceBVH **fac
 	int li = aabb.get_longest_axis_index();
 
 	switch (li) {
-
 		case Vector3::AXIS_X: {
 			SortArray<FaceBVH *, FaceBVHCmpX> sort_x;
 			sort_x.nth_element(0, p_size, p_size / 2, &facebvhptrptr[p_from]);
@@ -521,7 +497,6 @@ int CSGBrushOperation::MeshMerge::_create_bvh(FaceBVH *facebvhptr, FaceBVH **fac
 }
 
 void CSGBrushOperation::MeshMerge::_add_distance(List<real_t> &r_intersectionsA, List<real_t> &r_intersectionsB, bool p_from_B, real_t p_distance) const {
-
 	List<real_t> &intersections = p_from_B ? r_intersectionsB : r_intersectionsA;
 
 	// Check if distance exists.
@@ -533,7 +508,6 @@ void CSGBrushOperation::MeshMerge::_add_distance(List<real_t> &r_intersectionsA,
 }
 
 bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_depth, int p_bvh_first, int p_face_idx) const {
-
 	Face face = faces[p_face_idx];
 	Vector3 face_points[3] = {
 		points[face.points[0]],
@@ -563,22 +537,16 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
 	stack[0] = pos;
 
 	while (true) {
-
 		uint32_t node = stack[level] & NODE_IDX_MASK;
 		const FaceBVH *current_facebvhptr = &(facebvhptr[node]);
 		bool done = false;
 
 		switch (stack[level] >> VISITED_BIT_SHIFT) {
-
 			case TEST_AABB_BIT: {
-
 				if (current_facebvhptr->face >= 0) {
-
 					while (current_facebvhptr) {
-
 						if (p_face_idx != current_facebvhptr->face &&
 								current_facebvhptr->aabb.intersects_ray(face_center, face_normal)) {
-
 							const Face &current_face = faces[current_facebvhptr->face];
 							Vector3 current_points[3] = {
 								points[current_face.points[0]],
@@ -610,7 +578,6 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
 					stack[level] = (VISIT_DONE_BIT << VISITED_BIT_SHIFT) | node;
 
 				} else {
-
 					bool valid = current_facebvhptr->aabb.intersects_ray(face_center, face_normal);
 
 					if (!valid) {
@@ -623,7 +590,6 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
 			}
 
 			case VISIT_LEFT_BIT: {
-
 				stack[level] = (VISIT_RIGHT_BIT << VISITED_BIT_SHIFT) | node;
 				stack[level + 1] = current_facebvhptr->left | TEST_AABB_BIT;
 				level++;
@@ -631,7 +597,6 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
 			}
 
 			case VISIT_RIGHT_BIT: {
-
 				stack[level] = (VISIT_DONE_BIT << VISITED_BIT_SHIFT) | node;
 				stack[level + 1] = current_facebvhptr->right | TEST_AABB_BIT;
 				level++;
@@ -639,7 +604,6 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
 			}
 
 			case VISIT_DONE_BIT: {
-
 				if (level == 0) {
 					done = true;
 					break;
@@ -658,7 +622,6 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
 }
 
 void CSGBrushOperation::MeshMerge::mark_inside_faces() {
-
 	// Mark faces that are inside. This helps later do the boolean ops when merging.
 	// This approach is very brute force with a bunch of optimizations,
 	// such as BVH and pre AABB intersection test.
@@ -719,7 +682,6 @@ void CSGBrushOperation::MeshMerge::mark_inside_faces() {
 	_create_bvh(facebvh, bvhptr, 0, faces.size(), 1, max_depth, max_alloc);
 
 	for (int i = 0; i < faces.size(); i++) {
-
 		// Check if face AABB intersects the intersection AABB.
 		if (!intersection_aabb.intersects_inclusive(facebvh[i].aabb))
 			continue;
@@ -730,10 +692,8 @@ void CSGBrushOperation::MeshMerge::mark_inside_faces() {
 }
 
 void CSGBrushOperation::MeshMerge::add_face(const Vector3 p_points[], const Vector2 p_uvs[], bool p_smooth, bool p_invert, const Ref<Material> &p_material, bool p_from_b) {
-
 	int indices[3];
 	for (int i = 0; i < 3; i++) {
-
 		VertexKey vk;
 		vk.x = int((double(p_points[i].x) + double(vertex_snap) * 0.31234) / double(vertex_snap));
 		vk.y = int((double(p_points[i].y) + double(vertex_snap) * 0.31234) / double(vertex_snap));
@@ -781,7 +741,6 @@ void CSGBrushOperation::MeshMerge::add_face(const Vector3 p_points[], const Vect
 // CSGBrushOperation::Build2DFaces
 
 int CSGBrushOperation::Build2DFaces::_get_point_idx(const Vector2 &p_point) {
-
 	for (int vertex_idx = 0; vertex_idx < vertices.size(); ++vertex_idx) {
 		if ((p_point - vertices[vertex_idx].point).length_squared() < vertex_snap2)
 			return vertex_idx;
@@ -790,7 +749,6 @@ int CSGBrushOperation::Build2DFaces::_get_point_idx(const Vector2 &p_point) {
 }
 
 int CSGBrushOperation::Build2DFaces::_add_vertex(const Vertex2D &p_vertex) {
-
 	// Check if vertex exists.
 	int vertex_id = _get_point_idx(p_vertex.point);
 	if (vertex_id != -1)
@@ -801,7 +759,6 @@ int CSGBrushOperation::Build2DFaces::_add_vertex(const Vertex2D &p_vertex) {
 }
 
 void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vertex_indices, int p_new_vertex_index) {
-
 	if (p_new_vertex_index >= 0 && r_vertex_indices.find(p_new_vertex_index) == -1) {
 		ERR_FAIL_COND_MSG(p_new_vertex_index >= vertices.size(), "Invalid vertex index.");
 
@@ -814,7 +771,6 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
 
 		// The second vertex.
 		if (r_vertex_indices.size() == 1) {
-
 			Vector2 first_point = vertices[r_vertex_indices[0]].point;
 			Vector2 new_point = vertices[p_new_vertex_index].point;
 
@@ -857,14 +813,12 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
 }
 
 void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_indices) {
-
 	int segments = p_segment_indices.size() - 1;
 	if (segments < 2)
 		return;
 
 	// Faces around an inner vertex are merged by moving the inner vertex to the first vertex.
 	for (int sorted_idx = 1; sorted_idx < segments; ++sorted_idx) {
-
 		int closest_idx = 0;
 		int inner_idx = p_segment_indices[sorted_idx];
 
@@ -893,7 +847,6 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 
 		// Create the new faces.
 		for (int merge_idx = 0; merge_idx < merge_faces.size(); ++merge_idx) {
-
 			int outer_edge_idx[2];
 			outer_edge_idx[0] = merge_faces[merge_idx].vertex_idx[(merge_faces_inner_vertex_idx[merge_idx] + 1) % 3];
 			outer_edge_idx[1] = merge_faces[merge_idx].vertex_idx[(merge_faces_inner_vertex_idx[merge_idx] + 2) % 3];
@@ -937,7 +890,6 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 
 		// Split faces using degenerate points.
 		for (int face_idx = 0; face_idx < faces.size(); ++face_idx) {
-
 			Face2D face = faces[face_idx];
 			Vertex2D face_vertices[3] = {
 				vertices[face.vertex_idx[0]],
@@ -951,7 +903,6 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 			};
 
 			for (int point_idx = 0; point_idx < degenerate_points.size(); ++point_idx) {
-
 				int degenerate_idx = degenerate_points[point_idx];
 				Vector2 point_2D = vertices[degenerate_idx].point;
 
@@ -968,7 +919,6 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 
 				// Check if point is on an each edge.
 				for (int face_edge_idx = 0; face_edge_idx < 3; ++face_edge_idx) {
-
 					Vector2 edge_points[2] = {
 						face_points[face_edge_idx],
 						face_points[(face_edge_idx + 1) % 3]
@@ -976,7 +926,6 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 					Vector2 closest_point = Geometry::get_closest_point_to_segment_2d(point_2D, edge_points);
 
 					if ((closest_point - point_2D).length_squared() < vertex_snap2) {
-
 						int opposite_vertex_idx = face.vertex_idx[(face_edge_idx + 2) % 3];
 
 						// If new vertex snaps to degenerate vertex, just delete this face.
@@ -1014,10 +963,8 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 }
 
 void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_segment_points[2], Vector<int> &r_segment_indices) {
-
 	// For each face.
 	for (int face_idx = 0; face_idx < faces.size(); ++face_idx) {
-
 		Face2D face = faces[face_idx];
 		Vertex2D face_vertices[3] = {
 			vertices[face.vertex_idx[0]],
@@ -1027,7 +974,6 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
 
 		// Check each edge.
 		for (int face_edge_idx = 0; face_edge_idx < 3; ++face_edge_idx) {
-
 			Vector2 edge_points[2] = {
 				face_vertices[face_edge_idx].point,
 				face_vertices[(face_edge_idx + 1) % 3].point
@@ -1050,7 +996,6 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
 
 			// Else check if the segment intersects the edge.
 			if (on_edge || Geometry::segment_intersects_segment_2d(p_segment_points[0], p_segment_points[1], edge_points[0], edge_points[1], &intersection_point)) {
-
 				// Check if intersection point is an edge point.
 				if ((intersection_point - edge_points[0]).length_squared() < vertex_snap2 ||
 						(intersection_point - edge_points[1]).length_squared() < vertex_snap2)
@@ -1113,11 +1058,9 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
 }
 
 int CSGBrushOperation::Build2DFaces::_insert_point(const Vector2 &p_point) {
-
 	int new_vertex_idx = -1;
 
 	for (int face_idx = 0; face_idx < faces.size(); ++face_idx) {
-
 		Face2D face = faces[face_idx];
 		Vertex2D face_vertices[3] = {
 			vertices[face.vertex_idx[0]],
@@ -1144,7 +1087,6 @@ int CSGBrushOperation::Build2DFaces::_insert_point(const Vector2 &p_point) {
 		// Check if point is on an each edge.
 		bool on_edge = false;
 		for (int face_edge_idx = 0; face_edge_idx < 3; ++face_edge_idx) {
-
 			Vector2 edge_points[2] = {
 				points[face_edge_idx],
 				points[(face_edge_idx + 1) % 3]
@@ -1206,7 +1148,6 @@ int CSGBrushOperation::Build2DFaces::_insert_point(const Vector2 &p_point) {
 
 		// If not on an edge, check if the point is inside the face.
 		if (!on_edge && Geometry::is_point_in_triangle(p_point, face_vertices[0].point, face_vertices[1].point, face_vertices[2].point)) {
-
 			// Add the point as a new vertex.
 			Vertex2D new_vertex;
 			new_vertex.point = p_point;
@@ -1216,7 +1157,6 @@ int CSGBrushOperation::Build2DFaces::_insert_point(const Vector2 &p_point) {
 			// Create three new faces around this point and remove this face.
 			// The new vertex is the last vertex.
 			for (int i = 0; i < 3; ++i) {
-
 				// Don't create degenerate triangles.
 				Vector2 edge[2] = { points[i], points[(i + 1) % 3] };
 				Vector2 new_edge1[2] = { vertices[new_vertex_idx].point, points[i] };
@@ -1243,7 +1183,6 @@ int CSGBrushOperation::Build2DFaces::_insert_point(const Vector2 &p_point) {
 }
 
 void CSGBrushOperation::Build2DFaces::insert(const CSGBrush &p_brush, int p_face_idx) {
-
 	// Find edge points that cross the plane and face points that are in the plane.
 	// Map those points to 2D.
 	// Create new faces from those points.
@@ -1252,7 +1191,6 @@ void CSGBrushOperation::Build2DFaces::insert(const CSGBrush &p_brush, int p_face
 	int points_count = 0;
 
 	for (int i = 0; i < 3; i++) {
-
 		Vector3 point_3D = p_brush.faces[p_face_idx].vertices[i];
 
 		if (plane.has_point(point_3D)) {
@@ -1262,7 +1200,6 @@ void CSGBrushOperation::Build2DFaces::insert(const CSGBrush &p_brush, int p_face
 			points_2D[points_count++] = Vector2(point_2D.x, point_2D.y);
 
 		} else {
-
 			Vector3 next_point_3D = p_brush.faces[p_face_idx].vertices[(i + 1) % 3];
 
 			if (plane.has_point(next_point_3D))
@@ -1315,7 +1252,6 @@ void CSGBrushOperation::Build2DFaces::insert(const CSGBrush &p_brush, int p_face
 }
 
 void CSGBrushOperation::Build2DFaces::addFacesToMesh(MeshMerge &r_mesh_merge, bool p_smooth, bool p_invert, const Ref<Material> &p_material, bool p_from_b) {
-
 	for (int face_idx = 0; face_idx < faces.size(); ++face_idx) {
 		Face2D face = faces[face_idx];
 		Vertex2D fv[3] = {
@@ -1339,7 +1275,6 @@ void CSGBrushOperation::Build2DFaces::addFacesToMesh(MeshMerge &r_mesh_merge, bo
 
 CSGBrushOperation::Build2DFaces::Build2DFaces(const CSGBrush &p_brush, int p_face_idx, float p_vertex_snap2) :
 		vertex_snap2(p_vertex_snap2 * p_vertex_snap2) {
-
 	// Convert 3D vertex points to 2D.
 	Vector3 points_3D[3] = {
 		p_brush.faces[p_face_idx].vertices[0],
@@ -1368,7 +1303,6 @@ CSGBrushOperation::Build2DFaces::Build2DFaces(const CSGBrush &p_brush, int p_fac
 }
 
 void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face_idx_a, const CSGBrush &p_brush_b, const int p_face_idx_b, Build2DFaceCollection &p_collection, float p_vertex_snap) {
-
 	Vector3 vertices_a[3] = {
 		p_brush_a.faces[p_face_idx_a].vertices[0],
 		p_brush_a.faces[p_face_idx_a].vertices[1],
@@ -1437,14 +1371,11 @@ void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face
 
 	// Check for intersection using the SAT theorem.
 	{
-
 		// Edge pair cross product combinations.
 		for (int i = 0; i < 3; i++) {
-
 			Vector3 axis_a = (vertices_a[i] - vertices_a[(i + 1) % 3]).normalized();
 
 			for (int j = 0; j < 3; j++) {
-
 				Vector3 axis_b = (vertices_b[j] - vertices_b[(j + 1) % 3]).normalized();
 
 				Vector3 sep_axis = axis_a.cross(axis_b);
diff --git a/modules/csg/csg.h b/modules/csg/csg.h
index d389cbc283..34ee239c17 100644
--- a/modules/csg/csg.h
+++ b/modules/csg/csg.h
@@ -44,7 +44,6 @@
 #include "scene/resources/material.h"
 
 struct CSGBrush {
-
 	struct Face {
 		Vector3 vertices[3];
 		Vector2 uvs[3];
@@ -65,7 +64,6 @@ struct CSGBrush {
 };
 
 struct CSGBrushOperation {
-
 	enum Operation {
 		OPERATION_UNION,
 		OPERATION_INTERSECTION,
@@ -75,7 +73,6 @@ struct CSGBrushOperation {
 	void merge_brushes(Operation p_operation, const CSGBrush &p_brush_a, const CSGBrush &p_brush_b, CSGBrush &r_merged_brush, float p_vertex_snap);
 
 	struct MeshMerge {
-
 		struct Face {
 			bool from_b;
 			bool inside;
@@ -156,7 +153,6 @@ struct CSGBrushOperation {
 	};
 
 	struct Build2DFaces {
-
 		struct Vertex2D {
 			Vector2 point;
 			Vector2 uv;
diff --git a/modules/csg/csg_gizmos.cpp b/modules/csg/csg_gizmos.cpp
index a859ef80a6..ad04d9941b 100644
--- a/modules/csg/csg_gizmos.cpp
+++ b/modules/csg/csg_gizmos.cpp
@@ -33,7 +33,6 @@
 ///////////
 
 CSGShape3DGizmoPlugin::CSGShape3DGizmoPlugin() {
-
 	Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/csg", Color(0.0, 0.4, 1, 0.15));
 	create_material("shape_union_material", gizmo_color);
 	create_material("shape_union_solid_material", gizmo_color);
@@ -50,44 +49,36 @@ CSGShape3DGizmoPlugin::CSGShape3DGizmoPlugin() {
 }
 
 String CSGShape3DGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gizmo, int p_idx) const {
-
 	CSGShape3D *cs = Object::cast_to<CSGShape3D>(p_gizmo->get_spatial_node());
 
 	if (Object::cast_to<CSGSphere3D>(cs)) {
-
 		return "Radius";
 	}
 
 	if (Object::cast_to<CSGBox3D>(cs)) {
-
 		static const char *hname[3] = { "Width", "Height", "Depth" };
 		return hname[p_idx];
 	}
 
 	if (Object::cast_to<CSGCylinder3D>(cs)) {
-
 		return p_idx == 0 ? "Radius" : "Height";
 	}
 
 	if (Object::cast_to<CSGTorus3D>(cs)) {
-
 		return p_idx == 0 ? "InnerRadius" : "OuterRadius";
 	}
 
 	return "";
 }
 Variant CSGShape3DGizmoPlugin::get_handle_value(EditorNode3DGizmo *p_gizmo, int p_idx) const {
-
 	CSGShape3D *cs = Object::cast_to<CSGShape3D>(p_gizmo->get_spatial_node());
 
 	if (Object::cast_to<CSGSphere3D>(cs)) {
-
 		CSGSphere3D *s = Object::cast_to<CSGSphere3D>(cs);
 		return s->get_radius();
 	}
 
 	if (Object::cast_to<CSGBox3D>(cs)) {
-
 		CSGBox3D *s = Object::cast_to<CSGBox3D>(cs);
 		switch (p_idx) {
 			case 0:
@@ -100,13 +91,11 @@ Variant CSGShape3DGizmoPlugin::get_handle_value(EditorNode3DGizmo *p_gizmo, int
 	}
 
 	if (Object::cast_to<CSGCylinder3D>(cs)) {
-
 		CSGCylinder3D *s = Object::cast_to<CSGCylinder3D>(cs);
 		return p_idx == 0 ? s->get_radius() : s->get_height();
 	}
 
 	if (Object::cast_to<CSGTorus3D>(cs)) {
-
 		CSGTorus3D *s = Object::cast_to<CSGTorus3D>(cs);
 		return p_idx == 0 ? s->get_inner_radius() : s->get_outer_radius();
 	}
@@ -114,7 +103,6 @@ Variant CSGShape3DGizmoPlugin::get_handle_value(EditorNode3DGizmo *p_gizmo, int
 	return Variant();
 }
 void CSGShape3DGizmoPlugin::set_handle(EditorNode3DGizmo *p_gizmo, int p_idx, Camera3D *p_camera, const Point2 &p_point) {
-
 	CSGShape3D *cs = Object::cast_to<CSGShape3D>(p_gizmo->get_spatial_node());
 
 	Transform gt = cs->get_global_transform();
@@ -127,7 +115,6 @@ void CSGShape3DGizmoPlugin::set_handle(EditorNode3DGizmo *p_gizmo, int p_idx, Ca
 	Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 16384) };
 
 	if (Object::cast_to<CSGSphere3D>(cs)) {
-
 		CSGSphere3D *s = Object::cast_to<CSGSphere3D>(cs);
 
 		Vector3 ra, rb;
@@ -144,7 +131,6 @@ void CSGShape3DGizmoPlugin::set_handle(EditorNode3DGizmo *p_gizmo, int p_idx, Ca
 	}
 
 	if (Object::cast_to<CSGBox3D>(cs)) {
-
 		CSGBox3D *s = Object::cast_to<CSGBox3D>(cs);
 
 		Vector3 axis;
@@ -173,7 +159,6 @@ void CSGShape3DGizmoPlugin::set_handle(EditorNode3DGizmo *p_gizmo, int p_idx, Ca
 	}
 
 	if (Object::cast_to<CSGCylinder3D>(cs)) {
-
 		CSGCylinder3D *s = Object::cast_to<CSGCylinder3D>(cs);
 
 		Vector3 axis;
@@ -195,7 +180,6 @@ void CSGShape3DGizmoPlugin::set_handle(EditorNode3DGizmo *p_gizmo, int p_idx, Ca
 	}
 
 	if (Object::cast_to<CSGTorus3D>(cs)) {
-
 		CSGTorus3D *s = Object::cast_to<CSGTorus3D>(cs);
 
 		Vector3 axis;
@@ -217,7 +201,6 @@ void CSGShape3DGizmoPlugin::set_handle(EditorNode3DGizmo *p_gizmo, int p_idx, Ca
 	}
 }
 void CSGShape3DGizmoPlugin::commit_handle(EditorNode3DGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
-
 	CSGShape3D *cs = Object::cast_to<CSGShape3D>(p_gizmo->get_spatial_node());
 
 	if (Object::cast_to<CSGSphere3D>(cs)) {
@@ -337,7 +320,6 @@ bool CSGShape3DGizmoPlugin::is_selectable_when_hidden() const {
 }
 
 void CSGShape3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
-
 	CSGShape3D *cs = Object::cast_to<CSGShape3D>(p_gizmo->get_spatial_node());
 
 	p_gizmo->clear();
diff --git a/modules/csg/csg_gizmos.h b/modules/csg/csg_gizmos.h
index 7763989b2a..48a414d9c7 100644
--- a/modules/csg/csg_gizmos.h
+++ b/modules/csg/csg_gizmos.h
@@ -36,7 +36,6 @@
 #include "editor/node_3d_editor_gizmos.h"
 
 class CSGShape3DGizmoPlugin : public EditorNode3DGizmoPlugin {
-
 	GDCLASS(CSGShape3DGizmoPlugin, EditorNode3DGizmoPlugin);
 
 public:
diff --git a/modules/csg/csg_shape.cpp b/modules/csg/csg_shape.cpp
index a5b664eeab..8a0e1097c2 100644
--- a/modules/csg/csg_shape.cpp
+++ b/modules/csg/csg_shape.cpp
@@ -32,7 +32,6 @@
 #include "scene/3d/path_3d.h"
 
 void CSGShape3D::set_use_collision(bool p_enable) {
-
 	if (use_collision == p_enable)
 		return;
 
@@ -71,12 +70,10 @@ void CSGShape3D::set_collision_layer(uint32_t p_layer) {
 }
 
 uint32_t CSGShape3D::get_collision_layer() const {
-
 	return collision_layer;
 }
 
 void CSGShape3D::set_collision_mask(uint32_t p_mask) {
-
 	collision_mask = p_mask;
 	if (root_collision_instance.is_valid()) {
 		PhysicsServer3D::get_singleton()->body_set_collision_mask(root_collision_instance, p_mask);
@@ -84,12 +81,10 @@ void CSGShape3D::set_collision_mask(uint32_t p_mask) {
 }
 
 uint32_t CSGShape3D::get_collision_mask() const {
-
 	return collision_mask;
 }
 
 void CSGShape3D::set_collision_mask_bit(int p_bit, bool p_value) {
-
 	uint32_t mask = get_collision_mask();
 	if (p_value)
 		mask |= 1 << p_bit;
@@ -99,12 +94,10 @@ void CSGShape3D::set_collision_mask_bit(int p_bit, bool p_value) {
 }
 
 bool CSGShape3D::get_collision_mask_bit(int p_bit) const {
-
 	return get_collision_mask() & (1 << p_bit);
 }
 
 void CSGShape3D::set_collision_layer_bit(int p_bit, bool p_value) {
-
 	uint32_t mask = get_collision_layer();
 	if (p_value)
 		mask |= 1 << p_bit;
@@ -114,12 +107,10 @@ void CSGShape3D::set_collision_layer_bit(int p_bit, bool p_value) {
 }
 
 bool CSGShape3D::get_collision_layer_bit(int p_bit) const {
-
 	return get_collision_layer() & (1 << p_bit);
 }
 
 bool CSGShape3D::is_root_shape() const {
-
 	return !parent;
 }
 
@@ -132,7 +123,6 @@ float CSGShape3D::get_snap() const {
 }
 
 void CSGShape3D::_make_dirty() {
-
 	if (!is_inside_tree())
 		return;
 
@@ -151,7 +141,6 @@ void CSGShape3D::_make_dirty() {
 }
 
 CSGBrush *CSGShape3D::_get_brush() {
-
 	if (dirty) {
 		if (brush) {
 			memdelete(brush);
@@ -161,7 +150,6 @@ CSGBrush *CSGShape3D::_get_brush() {
 		CSGBrush *n = _build_brush();
 
 		for (int i = 0; i < get_child_count(); i++) {
-
 			CSGShape3D *child = Object::cast_to<CSGShape3D>(get_child(i));
 			if (!child)
 				continue;
@@ -177,7 +165,6 @@ CSGBrush *CSGShape3D::_get_brush() {
 				n->copy_from(*n2, child->get_transform());
 
 			} else {
-
 				CSGBrush *nn = memnew(CSGBrush);
 				CSGBrush *nn2 = memnew(CSGBrush);
 				nn2->copy_from(*n2, child->get_transform());
@@ -263,7 +250,6 @@ void CSGShape3D::mikktGetTexCoord(const SMikkTSpaceContext *pContext, float fvTe
 
 void CSGShape3D::mikktSetTSpaceDefault(const SMikkTSpaceContext *pContext, const float fvTangent[], const float fvBiTangent[], const float fMagS, const float fMagT,
 		const tbool bIsOrientationPreserving, const int iFace, const int iVert) {
-
 	ShapeUpdateSurface &surface = *((ShapeUpdateSurface *)pContext->m_pUserData);
 
 	int i = iFace * 3 + iVert;
@@ -280,7 +266,6 @@ void CSGShape3D::mikktSetTSpaceDefault(const SMikkTSpaceContext *pContext, const
 }
 
 void CSGShape3D::_update_shape() {
-
 	if (parent)
 		return;
 
@@ -325,7 +310,6 @@ void CSGShape3D::_update_shape() {
 
 	//create arrays
 	for (int i = 0; i < surfaces.size(); i++) {
-
 		surfaces.write[i].vertices.resize(face_count[i] * 3);
 		surfaces.write[i].normals.resize(face_count[i] * 3);
 		surfaces.write[i].uvs.resize(face_count[i] * 3);
@@ -348,13 +332,11 @@ void CSGShape3D::_update_shape() {
 
 	// Update collision faces.
 	if (root_collision_shape.is_valid()) {
-
 		Vector<Vector3> physics_faces;
 		physics_faces.resize(n->faces.size() * 3);
 		Vector3 *physicsw = physics_faces.ptrw();
 
 		for (int i = 0; i < n->faces.size(); i++) {
-
 			int order[3] = { 0, 1, 2 };
 
 			if (n->faces[i].invert) {
@@ -372,7 +354,6 @@ void CSGShape3D::_update_shape() {
 	//fill arrays
 	{
 		for (int i = 0; i < n->faces.size(); i++) {
-
 			int order[3] = { 0, 1, 2 };
 
 			if (n->faces[i].invert) {
@@ -388,7 +369,6 @@ void CSGShape3D::_update_shape() {
 			Plane p(n->faces[i].vertices[0], n->faces[i].vertices[1], n->faces[i].vertices[2]);
 
 			for (int j = 0; j < 3; j++) {
-
 				Vector3 v = n->faces[i].vertices[j];
 
 				Vector3 normal = p.normal;
@@ -398,7 +378,6 @@ void CSGShape3D::_update_shape() {
 				}
 
 				if (n->faces[i].invert) {
-
 					normal = -normal;
 				}
 
@@ -491,14 +470,11 @@ Vector<Vector3> CSGShape3D::get_brush_faces() {
 }
 
 Vector<Face3> CSGShape3D::get_faces(uint32_t p_usage_flags) const {
-
 	return Vector<Face3>();
 }
 
 void CSGShape3D::_notification(int p_what) {
-
 	if (p_what == NOTIFICATION_ENTER_TREE) {
-
 		Node *parentn = get_parent();
 		if (parentn) {
 			parent = Object::cast_to<CSGShape3D>(parentn);
@@ -523,21 +499,18 @@ void CSGShape3D::_notification(int p_what) {
 	}
 
 	if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {
-
 		if (parent) {
 			parent->_make_dirty();
 		}
 	}
 
 	if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
-
 		if (parent) {
 			parent->_make_dirty();
 		}
 	}
 
 	if (p_what == NOTIFICATION_EXIT_TREE) {
-
 		if (parent)
 			parent->_make_dirty();
 		parent = nullptr;
@@ -552,7 +525,6 @@ void CSGShape3D::_notification(int p_what) {
 }
 
 void CSGShape3D::set_operation(Operation p_operation) {
-
 	operation = p_operation;
 	_make_dirty();
 	update_gizmo();
@@ -582,7 +554,6 @@ void CSGShape3D::_validate_property(PropertyInfo &property) const {
 }
 
 Array CSGShape3D::get_meshes() const {
-
 	if (root_mesh.is_valid()) {
 		Array arr;
 		arr.resize(2);
@@ -594,7 +565,6 @@ Array CSGShape3D::get_meshes() const {
 	return Array();
 }
 void CSGShape3D::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("_update_shape"), &CSGShape3D::_update_shape);
 	ClassDB::bind_method(D_METHOD("is_root_shape"), &CSGShape3D::is_root_shape);
 
@@ -660,7 +630,6 @@ CSGShape3D::~CSGShape3D() {
 //////////////////////////////////
 
 CSGBrush *CSGCombiner3D::_build_brush() {
-
 	return nullptr; //does not build anything
 }
 
@@ -670,7 +639,6 @@ CSGCombiner3D::CSGCombiner3D() {
 /////////////////////
 
 CSGBrush *CSGPrimitive3D::_create_brush_from_arrays(const Vector<Vector3> &p_vertices, const Vector<Vector2> &p_uv, const Vector<bool> &p_smooth, const Vector<Ref<Material>> &p_materials) {
-
 	CSGBrush *brush = memnew(CSGBrush);
 
 	Vector<bool> invert;
@@ -688,7 +656,6 @@ CSGBrush *CSGPrimitive3D::_create_brush_from_arrays(const Vector<Vector3> &p_ver
 }
 
 void CSGPrimitive3D::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_invert_faces", "invert_faces"), &CSGPrimitive3D::set_invert_faces);
 	ClassDB::bind_method(D_METHOD("is_inverting_faces"), &CSGPrimitive3D::is_inverting_faces);
 
@@ -715,7 +682,6 @@ CSGPrimitive3D::CSGPrimitive3D() {
 /////////////////////
 
 CSGBrush *CSGMesh3D::_build_brush() {
-
 	if (!mesh.is_valid())
 		return nullptr;
 
@@ -726,7 +692,6 @@ CSGBrush *CSGMesh3D::_build_brush() {
 	Ref<Material> material = get_material();
 
 	for (int i = 0; i < mesh->get_surface_count(); i++) {
-
 		if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
 			continue;
 		}
@@ -781,7 +746,6 @@ CSGBrush *CSGMesh3D::_build_brush() {
 			const int *ir = aindices.ptr();
 
 			for (int j = 0; j < is; j += 3) {
-
 				Vector3 vertex[3];
 				Vector3 normal[3];
 				Vector2 uv[3];
@@ -825,7 +789,6 @@ CSGBrush *CSGMesh3D::_build_brush() {
 			Ref<Material> *mw = materials.ptrw();
 
 			for (int j = 0; j < is; j += 3) {
-
 				Vector3 vertex[3];
 				Vector3 normal[3];
 				Vector2 uv[3];
@@ -875,12 +838,10 @@ void CSGMesh3D::set_material(const Ref<Material> &p_material) {
 }
 
 Ref<Material> CSGMesh3D::get_material() const {
-
 	return material;
 }
 
 void CSGMesh3D::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_mesh", "mesh"), &CSGMesh3D::set_mesh);
 	ClassDB::bind_method(D_METHOD("get_mesh"), &CSGMesh3D::get_mesh);
 
@@ -892,7 +853,6 @@ void CSGMesh3D::_bind_methods() {
 }
 
 void CSGMesh3D::set_mesh(const Ref<Mesh> &p_mesh) {
-
 	if (mesh == p_mesh)
 		return;
 	if (mesh.is_valid()) {
@@ -914,7 +874,6 @@ Ref<Mesh> CSGMesh3D::get_mesh() {
 ////////////////////////////////
 
 CSGBrush *CSGSphere3D::_build_brush() {
-
 	// set our bounding box
 
 	CSGBrush *brush = memnew(CSGBrush);
@@ -938,7 +897,6 @@ CSGBrush *CSGSphere3D::_build_brush() {
 	invert.resize(face_count);
 
 	{
-
 		Vector3 *facesw = faces.ptrw();
 		Vector2 *uvsw = uvs.ptrw();
 		bool *smoothw = smooth.ptrw();
@@ -959,7 +917,6 @@ CSGBrush *CSGSphere3D::_build_brush() {
 			double u1 = double(i) / rings;
 
 			for (int j = radial_segments; j >= 1; j--) {
-
 				double lng0 = 2 * Math_PI * (double)(j - 1) / radial_segments;
 				double x0 = Math::cos(lng0);
 				double y0 = Math::sin(lng0);
@@ -986,7 +943,6 @@ CSGBrush *CSGSphere3D::_build_brush() {
 				};
 
 				if (i < rings) {
-
 					//face 1
 					facesw[face * 3 + 0] = v[0];
 					facesw[face * 3 + 1] = v[1];
@@ -1096,13 +1052,11 @@ bool CSGSphere3D::get_smooth_faces() const {
 }
 
 void CSGSphere3D::set_material(const Ref<Material> &p_material) {
-
 	material = p_material;
 	_make_dirty();
 }
 
 Ref<Material> CSGSphere3D::get_material() const {
-
 	return material;
 }
 
@@ -1117,7 +1071,6 @@ CSGSphere3D::CSGSphere3D() {
 ///////////////
 
 CSGBrush *CSGBox3D::_build_brush() {
-
 	// set our bounding box
 
 	CSGBrush *brush = memnew(CSGBrush);
@@ -1141,7 +1094,6 @@ CSGBrush *CSGBox3D::_build_brush() {
 	invert.resize(face_count);
 
 	{
-
 		Vector3 *facesw = faces.ptrw();
 		Vector2 *uvsw = uvs.ptrw();
 		bool *smoothw = smooth.ptrw();
@@ -1153,21 +1105,17 @@ CSGBrush *CSGBox3D::_build_brush() {
 		Vector3 vertex_mul(width * 0.5, height * 0.5, depth * 0.5);
 
 		{
-
 			for (int i = 0; i < 6; i++) {
-
 				Vector3 face_points[4];
 				float uv_points[8] = { 0, 0, 0, 1, 1, 1, 1, 0 };
 
 				for (int j = 0; j < 4; j++) {
-
 					float v[3];
 					v[0] = 1.0;
 					v[1] = 1 - 2 * ((j >> 1) & 1);
 					v[2] = v[1] * (1 - 2 * (j & 1));
 
 					for (int k = 0; k < 3; k++) {
-
 						if (i < 3)
 							face_points[j][(i + k) % 3] = v[k];
 						else
@@ -1274,14 +1222,12 @@ float CSGBox3D::get_depth() const {
 }
 
 void CSGBox3D::set_material(const Ref<Material> &p_material) {
-
 	material = p_material;
 	_make_dirty();
 	update_gizmo();
 }
 
 Ref<Material> CSGBox3D::get_material() const {
-
 	return material;
 }
 
@@ -1295,7 +1241,6 @@ CSGBox3D::CSGBox3D() {
 ///////////////
 
 CSGBrush *CSGCylinder3D::_build_brush() {
-
 	// set our bounding box
 
 	CSGBrush *brush = memnew(CSGBrush);
@@ -1319,7 +1264,6 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 	invert.resize(face_count);
 
 	{
-
 		Vector3 *facesw = faces.ptrw();
 		Vector2 *uvsw = uvs.ptrw();
 		bool *smoothw = smooth.ptrw();
@@ -1331,9 +1275,7 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 		Vector3 vertex_mul(radius, height * 0.5, radius);
 
 		{
-
 			for (int i = 0; i < sides; i++) {
-
 				float inc = float(i) / sides;
 				float inc_n = float((i + 1)) / sides;
 
@@ -1510,13 +1452,11 @@ bool CSGCylinder3D::get_smooth_faces() const {
 }
 
 void CSGCylinder3D::set_material(const Ref<Material> &p_material) {
-
 	material = p_material;
 	_make_dirty();
 }
 
 Ref<Material> CSGCylinder3D::get_material() const {
-
 	return material;
 }
 
@@ -1532,7 +1472,6 @@ CSGCylinder3D::CSGCylinder3D() {
 ///////////////
 
 CSGBrush *CSGTorus3D::_build_brush() {
-
 	// set our bounding box
 
 	float min_radius = inner_radius;
@@ -1568,7 +1507,6 @@ CSGBrush *CSGTorus3D::_build_brush() {
 	invert.resize(face_count);
 
 	{
-
 		Vector3 *facesw = faces.ptrw();
 		Vector2 *uvsw = uvs.ptrw();
 		bool *smoothw = smooth.ptrw();
@@ -1578,9 +1516,7 @@ CSGBrush *CSGTorus3D::_build_brush() {
 		int face = 0;
 
 		{
-
 			for (int i = 0; i < sides; i++) {
-
 				float inci = float(i) / sides;
 				float inci_n = float((i + 1)) / sides;
 
@@ -1591,7 +1527,6 @@ CSGBrush *CSGTorus3D::_build_brush() {
 				Vector3 normali_n = Vector3(Math::cos(angi_n), 0, Math::sin(angi_n));
 
 				for (int j = 0; j < ring_sides; j++) {
-
 					float incj = float(j) / ring_sides;
 					float incj_n = float((j + 1)) / ring_sides;
 
@@ -1738,13 +1673,11 @@ bool CSGTorus3D::get_smooth_faces() const {
 }
 
 void CSGTorus3D::set_material(const Ref<Material> &p_material) {
-
 	material = p_material;
 	_make_dirty();
 }
 
 Ref<Material> CSGTorus3D::get_material() const {
-
 	return material;
 }
 
@@ -1760,7 +1693,6 @@ CSGTorus3D::CSGTorus3D() {
 ///////////////
 
 CSGBrush *CSGPolygon3D::_build_brush() {
-
 	// set our bounding box
 
 	if (polygon.size() < 3)
@@ -1871,7 +1803,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 
 	AABB aabb; //must be computed
 	{
-
 		Vector3 *facesw = faces.ptrw();
 		Vector2 *uvsw = uvs.ptrw();
 		bool *smoothw = smooth.ptrw();
@@ -1882,10 +1813,8 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 
 		switch (mode) {
 			case MODE_DEPTH: {
-
 				//add triangles, front and back
 				for (int i = 0; i < 2; i++) {
-
 					for (int j = 0; j < triangles.size(); j += 3) {
 						for (int k = 0; k < 3; k++) {
 							int src[3] = { 0, i == 0 ? 1 : 2, i == 0 ? 2 : 1 };
@@ -1910,7 +1839,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 
 				//add triangles for depth
 				for (int i = 0; i < final_polygon.size(); i++) {
-
 					int i_n = (i + 1) % final_polygon.size();
 
 					Vector3 v[4] = {
@@ -1960,9 +1888,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 
 			} break;
 			case MODE_SPIN: {
-
 				for (int i = 0; i < spin_sides; i++) {
-
 					float inci = float(i) / spin_sides;
 					float inci_n = float((i + 1)) / spin_sides;
 
@@ -1974,7 +1900,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 
 					//add triangles for depth
 					for (int j = 0; j < final_polygon.size(); j++) {
-
 						int j_n = (j + 1) % final_polygon.size();
 
 						Vector3 v[4] = {
@@ -2023,7 +1948,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 					}
 
 					if (i == 0 && spin_degrees < 360) {
-
 						for (int j = 0; j < triangles.size(); j += 3) {
 							for (int k = 0; k < 3; k++) {
 								int src[3] = { 0, 2, 1 };
@@ -2041,7 +1965,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 					}
 
 					if (i == spin_sides - 1 && spin_degrees < 360) {
-
 						for (int j = 0; j < triangles.size(); j += 3) {
 							for (int k = 0; k < 3; k++) {
 								int src[3] = { 0, 1, 2 };
@@ -2061,7 +1984,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 				}
 			} break;
 			case MODE_PATH: {
-
 				float bl = curve->get_baked_length();
 				int splits = MAX(2, Math::ceil(bl / path_interval));
 				float u1 = 0.0;
@@ -2087,7 +2009,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 				}
 
 				for (int i = 0; i <= splits; i++) {
-
 					float ofs = i * path_interval;
 					if (ofs > bl) {
 						ofs = bl;
@@ -2127,7 +2048,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 						//put triangles where they belong
 						//add triangles for depth
 						for (int j = 0; j < final_polygon.size(); j++) {
-
 							int j_n = (j + 1) % final_polygon.size();
 
 							Vector3 v[4] = {
@@ -2177,7 +2097,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 					}
 
 					if (i == 0 && !path_joined) {
-
 						for (int j = 0; j < triangles.size(); j += 3) {
 							for (int k = 0; k < 3; k++) {
 								int src[3] = { 0, 1, 2 };
@@ -2195,7 +2114,6 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 					}
 
 					if (i == splits && !path_joined) {
-
 						for (int j = 0; j < triangles.size(); j += 3) {
 							for (int k = 0; k < 3; k++) {
 								int src[3] = { 0, 2, 1 };
@@ -2461,13 +2379,11 @@ bool CSGPolygon3D::get_smooth_faces() const {
 }
 
 void CSGPolygon3D::set_material(const Ref<Material> &p_material) {
-
 	material = p_material;
 	_make_dirty();
 }
 
 Ref<Material> CSGPolygon3D::get_material() const {
-
 	return material;
 }
 
diff --git a/modules/csg/csg_shape.h b/modules/csg/csg_shape.h
index abab1ded20..7e95d685c5 100644
--- a/modules/csg/csg_shape.h
+++ b/modules/csg/csg_shape.h
@@ -204,7 +204,6 @@ public:
 };
 
 class CSGSphere3D : public CSGPrimitive3D {
-
 	GDCLASS(CSGSphere3D, CSGPrimitive3D);
 	virtual CSGBrush *_build_brush();
 
@@ -237,7 +236,6 @@ public:
 };
 
 class CSGBox3D : public CSGPrimitive3D {
-
 	GDCLASS(CSGBox3D, CSGPrimitive3D);
 	virtual CSGBrush *_build_brush();
 
@@ -266,7 +264,6 @@ public:
 };
 
 class CSGCylinder3D : public CSGPrimitive3D {
-
 	GDCLASS(CSGCylinder3D, CSGPrimitive3D);
 	virtual CSGBrush *_build_brush();
 
@@ -303,7 +300,6 @@ public:
 };
 
 class CSGTorus3D : public CSGPrimitive3D {
-
 	GDCLASS(CSGTorus3D, CSGPrimitive3D);
 	virtual CSGBrush *_build_brush();
 
@@ -340,7 +336,6 @@ public:
 };
 
 class CSGPolygon3D : public CSGPrimitive3D {
-
 	GDCLASS(CSGPolygon3D, CSGPrimitive3D);
 
 public:
diff --git a/modules/csg/register_types.cpp b/modules/csg/register_types.cpp
index 40eef84b1b..a8bcc2fed1 100644
--- a/modules/csg/register_types.cpp
+++ b/modules/csg/register_types.cpp
@@ -34,7 +34,6 @@
 #include "csg_shape.h"
 
 void register_csg_types() {
-
 #ifndef _3D_DISABLED
 
 	ClassDB::register_virtual_class<CSGShape3D>();