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.

1 files changed, 0 insertions, 98 deletions

diff --git a/core/math/geometry.cpp b/core/math/geometry.cpp
index f923b62542..3085997225 100644
--- a/core/math/geometry.cpp
+++ b/core/math/geometry.cpp
@@ -54,13 +54,10 @@ bool Geometry::is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2>
 */
 
 void Geometry::MeshData::optimize_vertices() {
-
 	Map<int, int> vtx_remap;
 
 	for (int i = 0; i < faces.size(); i++) {
-
 		for (int j = 0; j < faces[i].indices.size(); j++) {
-
 			int idx = faces[i].indices[j];
 			if (!vtx_remap.has(idx)) {
 				int ni = vtx_remap.size();
@@ -72,7 +69,6 @@ void Geometry::MeshData::optimize_vertices() {
 	}
 
 	for (int i = 0; i < edges.size(); i++) {
-
 		int a = edges[i].a;
 		int b = edges[i].b;
 
@@ -93,7 +89,6 @@ void Geometry::MeshData::optimize_vertices() {
 	new_vertices.resize(vtx_remap.size());
 
 	for (int i = 0; i < vertices.size(); i++) {
-
 		if (vtx_remap.has(i))
 			new_vertices.write[vtx_remap[i]] = vertices[i];
 	}
@@ -101,9 +96,7 @@ void Geometry::MeshData::optimize_vertices() {
 }
 
 struct _FaceClassify {
-
 	struct _Link {
-
 		int face = -1;
 		int edge = -1;
 		void clear() {
@@ -126,42 +119,34 @@ static bool _connect_faces(_FaceClassify *p_faces, int len, int p_group) {
 	bool error = false;
 
 	for (int i = 0; i < len; i++) {
-
 		for (int j = 0; j < 3; j++) {
-
 			p_faces[i].links[j].clear();
 		}
 	}
 
 	for (int i = 0; i < len; i++) {
-
 		if (p_faces[i].group != p_group)
 			continue;
 		for (int j = i + 1; j < len; j++) {
-
 			if (p_faces[j].group != p_group)
 				continue;
 
 			for (int k = 0; k < 3; k++) {
-
 				Vector3 vi1 = p_faces[i].face.vertex[k];
 				Vector3 vi2 = p_faces[i].face.vertex[(k + 1) % 3];
 
 				for (int l = 0; l < 3; l++) {
-
 					Vector3 vj2 = p_faces[j].face.vertex[l];
 					Vector3 vj1 = p_faces[j].face.vertex[(l + 1) % 3];
 
 					if (vi1.distance_to(vj1) < 0.00001 &&
 							vi2.distance_to(vj2) < 0.00001) {
 						if (p_faces[i].links[k].face != -1) {
-
 							ERR_PRINT("already linked\n");
 							error = true;
 							break;
 						}
 						if (p_faces[j].links[l].face != -1) {
-
 							ERR_PRINT("already linked\n");
 							error = true;
 							break;
@@ -184,10 +169,8 @@ static bool _connect_faces(_FaceClassify *p_faces, int len, int p_group) {
 	}
 
 	for (int i = 0; i < len; i++) {
-
 		p_faces[i].valid = true;
 		for (int j = 0; j < 3; j++) {
-
 			if (p_faces[i].links[j].face == -1)
 				p_faces[i].valid = false;
 		}
@@ -196,14 +179,12 @@ static bool _connect_faces(_FaceClassify *p_faces, int len, int p_group) {
 }
 
 static bool _group_face(_FaceClassify *p_faces, int len, int p_index, int p_group) {
-
 	if (p_faces[p_index].group >= 0)
 		return false;
 
 	p_faces[p_index].group = p_group;
 
 	for (int i = 0; i < 3; i++) {
-
 		ERR_FAIL_INDEX_V(p_faces[p_index].links[i].face, len, true);
 		_group_face(p_faces, len, p_faces[p_index].links[i].face, p_group);
 	}
@@ -212,7 +193,6 @@ static bool _group_face(_FaceClassify *p_faces, int len, int p_index, int p_grou
 }
 
 Vector<Vector<Face3>> Geometry::separate_objects(Vector<Face3> p_array) {
-
 	Vector<Vector<Face3>> objects;
 
 	int len = p_array.size();
@@ -226,7 +206,6 @@ Vector<Vector<Face3>> Geometry::separate_objects(Vector<Face3> p_array) {
 	_FaceClassify *_fcptr = fc.ptrw();
 
 	for (int i = 0; i < len; i++) {
-
 		_fcptr[i].face = arrayptr[i];
 	}
 
@@ -238,7 +217,6 @@ Vector<Vector<Face3>> Geometry::separate_objects(Vector<Face3> p_array) {
 
 	int group = 0;
 	for (int i = 0; i < len; i++) {
-
 		if (!_fcptr[i].valid)
 			continue;
 		if (_group_face(_fcptr, len, i, group)) {
@@ -249,12 +227,10 @@ Vector<Vector<Face3>> Geometry::separate_objects(Vector<Face3> p_array) {
 	// Group connected faces in separate objects.
 
 	for (int i = 0; i < len; i++) {
-
 		_fcptr[i].face = arrayptr[i];
 	}
 
 	if (group >= 0) {
-
 		objects.resize(group);
 		Vector<Face3> *group_faces = objects.ptrw();
 
@@ -262,7 +238,6 @@ Vector<Vector<Face3>> Geometry::separate_objects(Vector<Face3> p_array) {
 			if (!_fcptr[i].valid)
 				continue;
 			if (_fcptr[i].group >= 0 && _fcptr[i].group < group) {
-
 				group_faces[_fcptr[i].group].push_back(_fcptr[i].face);
 			}
 		}
@@ -299,7 +274,6 @@ enum _CellFlags {
 };
 
 static inline void _plot_face(uint8_t ***p_cell_status, int x, int y, int z, int len_x, int len_y, int len_z, const Vector3 &voxelsize, const Face3 &p_face) {
-
 	AABB aabb(Vector3(x, y, z), Vector3(len_x, len_y, len_z));
 	aabb.position = aabb.position * voxelsize;
 	aabb.size = aabb.size * voxelsize;
@@ -308,7 +282,6 @@ static inline void _plot_face(uint8_t ***p_cell_status, int x, int y, int z, int
 		return;
 
 	if (len_x == 1 && len_y == 1 && len_z == 1) {
-
 		p_cell_status[x][y][z] = _CELL_SOLID;
 		return;
 	}
@@ -337,15 +310,12 @@ static inline void _plot_face(uint8_t ***p_cell_status, int x, int y, int z, int
 	int new_len_z;
 
 	for (int i = 0; i < div_x; i++) {
-
 		_SPLIT(i, div_x, x, len_x, new_x, new_len_x);
 
 		for (int j = 0; j < div_y; j++) {
-
 			_SPLIT(j, div_y, y, len_y, new_y, new_len_y);
 
 			for (int k = 0; k < div_z; k++) {
-
 				_SPLIT(k, div_z, z, len_z, new_z, new_len_z);
 
 				_plot_face(p_cell_status, new_x, new_y, new_z, new_len_x, new_len_y, new_len_z, voxelsize, p_face);
@@ -355,14 +325,12 @@ static inline void _plot_face(uint8_t ***p_cell_status, int x, int y, int z, int
 }
 
 static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z, int len_x, int len_y, int len_z) {
-
 	if (p_cell_status[x][y][z] & 3)
 		return; // Nothing to do, already used and/or visited.
 
 	p_cell_status[x][y][z] = _CELL_PREV_FIRST;
 
 	while (true) {
-
 		uint8_t &c = p_cell_status[x][y][z];
 
 		if ((c & _CELL_STEP_MASK) == _CELL_STEP_NONE) {
@@ -416,9 +384,7 @@ static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z,
 		uint8_t prev = 0;
 
 		switch (c & _CELL_STEP_MASK) {
-
 			case _CELL_STEP_Y_POS: {
-
 				next_y++;
 				prev = _CELL_PREV_Y_NEG;
 			} break;
@@ -464,7 +430,6 @@ static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z,
 }
 
 static inline void _build_faces(uint8_t ***p_cell_status, int x, int y, int z, int len_x, int len_y, int len_z, Vector<Face3> &p_faces) {
-
 	ERR_FAIL_INDEX(x, len_x);
 	ERR_FAIL_INDEX(y, len_y);
 	ERR_FAIL_INDEX(z, len_z);
@@ -485,7 +450,6 @@ static inline void _build_faces(uint8_t ***p_cell_status, int x, int y, int z, i
 	};
 
 	for (int i = 0; i < 6; i++) {
-
 		Vector3 face_points[4];
 		int disp_x = x + ((i % 3) == 0 ? ((i < 3) ? 1 : -1) : 0);
 		int disp_y = y + (((i - 1) % 3) == 0 ? ((i < 3) ? 1 : -1) : 0);
@@ -524,7 +488,6 @@ static inline void _build_faces(uint8_t ***p_cell_status, int x, int y, int z, i
 }
 
 Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
-
 #define _MIN_SIZE 1.0
 #define _MAX_LENGTH 20
 
@@ -534,12 +497,9 @@ Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
 	AABB global_aabb;
 
 	for (int i = 0; i < face_count; i++) {
-
 		if (i == 0) {
-
 			global_aabb = faces[i].get_aabb();
 		} else {
-
 			global_aabb.merge_with(faces[i].get_aabb());
 		}
 	}
@@ -573,15 +533,12 @@ Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
 
 	uint8_t ***cell_status = memnew_arr(uint8_t **, div_x);
 	for (int i = 0; i < div_x; i++) {
-
 		cell_status[i] = memnew_arr(uint8_t *, div_y);
 
 		for (int j = 0; j < div_y; j++) {
-
 			cell_status[i][j] = memnew_arr(uint8_t, div_z);
 
 			for (int k = 0; k < div_z; k++) {
-
 				cell_status[i][j][k] = 0;
 			}
 		}
@@ -590,10 +547,8 @@ Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
 	// Plot faces into cells.
 
 	for (int i = 0; i < face_count; i++) {
-
 		Face3 f = faces[i];
 		for (int j = 0; j < 3; j++) {
-
 			f.vertex[j] -= global_aabb.position;
 		}
 		_plot_face(cell_status, 0, 0, 0, div_x, div_y, div_z, voxelsize, f);
@@ -602,27 +557,21 @@ Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
 	// Determine which cells connect to the outside by traversing the outside and recursively flood-fill marking.
 
 	for (int i = 0; i < div_x; i++) {
-
 		for (int j = 0; j < div_y; j++) {
-
 			_mark_outside(cell_status, i, j, 0, div_x, div_y, div_z);
 			_mark_outside(cell_status, i, j, div_z - 1, div_x, div_y, div_z);
 		}
 	}
 
 	for (int i = 0; i < div_z; i++) {
-
 		for (int j = 0; j < div_y; j++) {
-
 			_mark_outside(cell_status, 0, j, i, div_x, div_y, div_z);
 			_mark_outside(cell_status, div_x - 1, j, i, div_x, div_y, div_z);
 		}
 	}
 
 	for (int i = 0; i < div_x; i++) {
-
 		for (int j = 0; j < div_z; j++) {
-
 			_mark_outside(cell_status, i, 0, j, div_x, div_y, div_z);
 			_mark_outside(cell_status, i, div_y - 1, j, div_x, div_y, div_z);
 		}
@@ -633,11 +582,8 @@ Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
 	Vector<Face3> wrapped_faces;
 
 	for (int i = 0; i < div_x; i++) {
-
 		for (int j = 0; j < div_y; j++) {
-
 			for (int k = 0; k < div_z; k++) {
-
 				_build_faces(cell_status, i, j, k, div_x, div_y, div_z, wrapped_faces);
 			}
 		}
@@ -649,9 +595,7 @@ Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
 	Face3 *wrapped_faces_ptr = wrapped_faces.ptrw();
 
 	for (int i = 0; i < wrapped_faces_count; i++) {
-
 		for (int j = 0; j < 3; j++) {
-
 			Vector3 &v = wrapped_faces_ptr[i].vertex[j];
 			v = v * voxelsize;
 			v += global_aabb.position;
@@ -661,9 +605,7 @@ Vector<Face3> Geometry::wrap_geometry(Vector<Face3> p_array, real_t *p_error) {
 	// clean up grid
 
 	for (int i = 0; i < div_x; i++) {
-
 		for (int j = 0; j < div_y; j++) {
-
 			memdelete_arr(cell_status[i][j]);
 		}
 
@@ -712,14 +654,12 @@ Vector<Vector<Vector2>> Geometry::decompose_polygon_in_convex(Vector<Point2> pol
 }
 
 Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
-
 	MeshData mesh;
 
 #define SUBPLANE_SIZE 1024.0
 
 	real_t subplane_size = 1024.0; // Should compute this from the actual plane.
 	for (int i = 0; i < p_planes.size(); i++) {
-
 		Plane p = p_planes[i];
 
 		Vector3 ref = Vector3(0.0, 1.0, 0.0);
@@ -740,7 +680,6 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
 		vertices.push_back(center + up * subplane_size + right * subplane_size);
 
 		for (int j = 0; j < p_planes.size(); j++) {
-
 			if (j == i)
 				continue;
 
@@ -754,7 +693,6 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
 				break;
 
 			for (int k = 0; k < vertices.size(); k++) {
-
 				int k_n = (k + 1) % vertices.size();
 
 				Vector3 edge0_A = vertices[k];
@@ -770,7 +708,6 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
 
 				// Check for different sides and non coplanar.
 				if ((dist0 * dist1) < 0) {
-
 					// Calculate intersection.
 					Vector3 rel = edge1_A - edge0_A;
 
@@ -796,19 +733,15 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
 
 		// Add face indices.
 		for (int j = 0; j < vertices.size(); j++) {
-
 			int idx = -1;
 			for (int k = 0; k < mesh.vertices.size(); k++) {
-
 				if (mesh.vertices[k].distance_to(vertices[j]) < 0.001) {
-
 					idx = k;
 					break;
 				}
 			}
 
 			if (idx == -1) {
-
 				idx = mesh.vertices.size();
 				mesh.vertices.push_back(vertices[j]);
 			}
@@ -821,13 +754,11 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
 		// Add edge.
 
 		for (int j = 0; j < face.indices.size(); j++) {
-
 			int a = face.indices[j];
 			int b = face.indices[(j + 1) % face.indices.size()];
 
 			bool found = false;
 			for (int k = 0; k < mesh.edges.size(); k++) {
-
 				if (mesh.edges[k].a == a && mesh.edges[k].b == b) {
 					found = true;
 					break;
@@ -851,7 +782,6 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
 }
 
 Vector<Plane> Geometry::build_box_planes(const Vector3 &p_extents) {
-
 	Vector<Plane> planes;
 
 	planes.push_back(Plane(Vector3(1, 0, 0), p_extents.x));
@@ -865,11 +795,9 @@ Vector<Plane> Geometry::build_box_planes(const Vector3 &p_extents) {
 }
 
 Vector<Plane> Geometry::build_cylinder_planes(real_t p_radius, real_t p_height, int p_sides, Vector3::Axis p_axis) {
-
 	Vector<Plane> planes;
 
 	for (int i = 0; i < p_sides; i++) {
-
 		Vector3 normal;
 		normal[(p_axis + 1) % 3] = Math::cos(i * (2.0 * Math_PI) / p_sides);
 		normal[(p_axis + 2) % 3] = Math::sin(i * (2.0 * Math_PI) / p_sides);
@@ -887,7 +815,6 @@ Vector<Plane> Geometry::build_cylinder_planes(real_t p_radius, real_t p_height,
 }
 
 Vector<Plane> Geometry::build_sphere_planes(real_t p_radius, int p_lats, int p_lons, Vector3::Axis p_axis) {
-
 	Vector<Plane> planes;
 
 	Vector3 axis;
@@ -899,7 +826,6 @@ Vector<Plane> Geometry::build_sphere_planes(real_t p_radius, int p_lats, int p_l
 	axis_neg[p_axis] = -1.0;
 
 	for (int i = 0; i < p_lons; i++) {
-
 		Vector3 normal;
 		normal[(p_axis + 1) % 3] = Math::cos(i * (2.0 * Math_PI) / p_lons);
 		normal[(p_axis + 2) % 3] = Math::sin(i * (2.0 * Math_PI) / p_lons);
@@ -907,7 +833,6 @@ Vector<Plane> Geometry::build_sphere_planes(real_t p_radius, int p_lats, int p_l
 		planes.push_back(Plane(normal, p_radius));
 
 		for (int j = 1; j <= p_lats; j++) {
-
 			// FIXME: This is stupid.
 			Vector3 angle = normal.lerp(axis, j / (real_t)p_lats).normalized();
 			Vector3 pos = angle * p_radius;
@@ -920,7 +845,6 @@ Vector<Plane> Geometry::build_sphere_planes(real_t p_radius, int p_lats, int p_l
 }
 
 Vector<Plane> Geometry::build_capsule_planes(real_t p_radius, real_t p_height, int p_sides, int p_lats, Vector3::Axis p_axis) {
-
 	Vector<Plane> planes;
 
 	Vector3 axis;
@@ -932,7 +856,6 @@ Vector<Plane> Geometry::build_capsule_planes(real_t p_radius, real_t p_height, i
 	axis_neg[p_axis] = -1.0;
 
 	for (int i = 0; i < p_sides; i++) {
-
 		Vector3 normal;
 		normal[(p_axis + 1) % 3] = Math::cos(i * (2.0 * Math_PI) / p_sides);
 		normal[(p_axis + 2) % 3] = Math::sin(i * (2.0 * Math_PI) / p_sides);
@@ -940,7 +863,6 @@ Vector<Plane> Geometry::build_capsule_planes(real_t p_radius, real_t p_height, i
 		planes.push_back(Plane(normal, p_radius));
 
 		for (int j = 1; j <= p_lats; j++) {
-
 			Vector3 angle = normal.lerp(axis, j / (real_t)p_lats).normalized();
 			Vector3 pos = axis * p_height * 0.5 + angle * p_radius;
 			planes.push_back(Plane(pos, angle));
@@ -952,7 +874,6 @@ Vector<Plane> Geometry::build_capsule_planes(real_t p_radius, real_t p_height, i
 }
 
 struct _AtlasWorkRect {
-
 	Size2i s;
 	Point2i p;
 	int idx;
@@ -960,14 +881,12 @@ struct _AtlasWorkRect {
 };
 
 struct _AtlasWorkRectResult {
-
 	Vector<_AtlasWorkRect> result;
 	int max_w;
 	int max_h;
 };
 
 void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_result, Size2i &r_size) {
-
 	// Super simple, almost brute force scanline stacking fitter.
 	// It's pretty basic for now, but it tries to make sure that the aspect ratio of the
 	// resulting atlas is somehow square. This is necessary because video cards have limits.
@@ -990,7 +909,6 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
 	Vector<_AtlasWorkRectResult> results;
 
 	for (int i = 0; i <= 12; i++) {
-
 		int w = 1 << i;
 		int max_h = 0;
 		int max_w = 0;
@@ -1006,15 +924,12 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
 		int ofs = 0;
 		int limit_h = 0;
 		for (int j = 0; j < wrects.size(); j++) {
-
 			if (ofs + wrects[j].s.width > w) {
-
 				ofs = 0;
 			}
 
 			int from_y = 0;
 			for (int k = 0; k < wrects[j].s.width; k++) {
-
 				if (hmax[ofs + k] > from_y)
 					from_y = hmax[ofs + k];
 			}
@@ -1027,7 +942,6 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
 				limit_h = end_h;
 
 			for (int k = 0; k < wrects[j].s.width; k++) {
-
 				hmax.write[ofs + k] = end_h;
 			}
 
@@ -1054,7 +968,6 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
 	real_t best_aspect = 1e20;
 
 	for (int i = 0; i < results.size(); i++) {
-
 		real_t h = next_power_of_2(results[i].max_h);
 		real_t w = next_power_of_2(results[i].max_w);
 		real_t aspect = h > w ? h / w : w / h;
@@ -1067,7 +980,6 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
 	r_result.resize(p_rects.size());
 
 	for (int i = 0; i < p_rects.size(); i++) {
-
 		r_result.write[results[best].result[i].idx] = results[best].result[i].p;
 	}
 
@@ -1075,7 +987,6 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
 }
 
 Vector<Vector<Point2>> Geometry::_polypaths_do_operation(PolyBooleanOperation p_op, const Vector<Point2> &p_polypath_a, const Vector<Point2> &p_polypath_b, bool is_a_open) {
-
 	using namespace ClipperLib;
 
 	ClipType op = ctUnion;
@@ -1135,7 +1046,6 @@ Vector<Vector<Point2>> Geometry::_polypaths_do_operation(PolyBooleanOperation p_
 }
 
 Vector<Vector<Point2>> Geometry::_polypath_offset(const Vector<Point2> &p_polypath, real_t p_delta, PolyJoinType p_join_type, PolyEndType p_end_type) {
-
 	using namespace ClipperLib;
 
 	JoinType jt = jtSquare;
@@ -1202,19 +1112,16 @@ Vector<Vector<Point2>> Geometry::_polypath_offset(const Vector<Point2> &p_polypa
 }
 
 Vector<Vector3> Geometry::compute_convex_mesh_points(const Plane *p_planes, int p_plane_count) {
-
 	Vector<Vector3> points;
 
 	// Iterate through every unique combination of any three planes.
 	for (int i = p_plane_count - 1; i >= 0; i--) {
 		for (int j = i - 1; j >= 0; j--) {
 			for (int k = j - 1; k >= 0; k--) {
-
 				// Find the point where these planes all cross over (if they
 				// do at all).
 				Vector3 convex_shape_point;
 				if (p_planes[i].intersect_3(p_planes[j], p_planes[k], &convex_shape_point)) {
-
 					// See if any *other* plane excludes this point because it's
 					// on the wrong side.
 					bool excluded = false;
@@ -1241,7 +1148,6 @@ Vector<Vector3> Geometry::compute_convex_mesh_points(const Plane *p_planes, int
 }
 
 Vector<Point2i> Geometry::pack_rects(const Vector<Size2i> &p_sizes, const Size2i &p_atlas_size) {
-
 	Vector<stbrp_node> nodes;
 	nodes.resize(p_atlas_size.width);
 
@@ -1277,7 +1183,6 @@ Vector<Point2i> Geometry::pack_rects(const Vector<Size2i> &p_sizes, const Size2i
 }
 
 Vector<Vector3i> Geometry::partial_pack_rects(const Vector<Vector2i> &p_sizes, const Size2i &p_atlas_size) {
-
 	Vector<stbrp_node> nodes;
 	nodes.resize(p_atlas_size.width);
 	zeromem(nodes.ptrw(), sizeof(stbrp_node) * nodes.size());
@@ -1314,7 +1219,6 @@ Vector<Vector3i> Geometry::partial_pack_rects(const Vector<Vector2i> &p_sizes, c
 
 /* dt of 1d function using squared distance */
 static void edt(float *f, int stride, int n) {
-
 	float *d = (float *)alloca(sizeof(float) * n + sizeof(int) * n + sizeof(float) * (n + 1));
 	int *v = (int *)&(d[n]);
 	float *z = (float *)&v[n];
@@ -1351,7 +1255,6 @@ static void edt(float *f, int stride, int n) {
 #undef square
 
 Vector<uint32_t> Geometry::generate_edf(const Vector<bool> &p_voxels, const Vector3i &p_size, bool p_negative) {
-
 	uint32_t float_count = p_size.x * p_size.y * p_size.z;
 
 	ERR_FAIL_COND_V((uint32_t)p_voxels.size() != float_count, Vector<uint32_t>());
@@ -1368,7 +1271,6 @@ Vector<uint32_t> Geometry::generate_edf(const Vector<bool> &p_voxels, const Vect
 	{
 		const bool *voxr = p_voxels.ptr();
 		for (uint32_t i = 0; i < float_count; i++) {
-
 			bool plot = voxr[i];
 			if (p_negative) {
 				plot = !plot;