A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code

1 files changed, 188 insertions, 230 deletions

diff --git a/core/math/bsp_tree.cpp b/core/math/bsp_tree.cpp
index 1ca6385032..ef229a0553 100644
--- a/core/math/bsp_tree.cpp
+++ b/core/math/bsp_tree.cpp
@@ -30,32 +30,31 @@
 #include "error_macros.h"
 #include "print_string.h"
 
-
-void BSP_Tree::from_aabb(const Rect3& p_aabb) {
+void BSP_Tree::from_aabb(const Rect3 &p_aabb) {
 
 	planes.clear();
 
-	for(int i=0;i<3;i++) {
+	for (int i = 0; i < 3; i++) {
 
 		Vector3 n;
-		n[i]=1;
-		planes.push_back(Plane(n,p_aabb.pos[i]+p_aabb.size[i]));
-		planes.push_back(Plane(-n,-p_aabb.pos[i]));
+		n[i] = 1;
+		planes.push_back(Plane(n, p_aabb.pos[i] + p_aabb.size[i]));
+		planes.push_back(Plane(-n, -p_aabb.pos[i]));
 	}
 
 	nodes.clear();
 
-	for(int i=0;i<6;i++) {
+	for (int i = 0; i < 6; i++) {
 
 		Node n;
-		n.plane=i;
-		n.under=(i==0)?UNDER_LEAF:i-1;
-		n.over=OVER_LEAF;
+		n.plane = i;
+		n.under = (i == 0) ? UNDER_LEAF : i - 1;
+		n.over = OVER_LEAF;
 		nodes.push_back(n);
 	}
 
-	aabb=p_aabb;
-	error_radius=0;
+	aabb = p_aabb;
+	error_radius = 0;
 }
 
 Vector<BSP_Tree::Node> BSP_Tree::get_nodes() const {
@@ -72,143 +71,136 @@ Rect3 BSP_Tree::get_aabb() const {
 	return aabb;
 }
 
-int BSP_Tree::_get_points_inside(int p_node,const Vector3* p_points,int *p_indices, const Vector3& p_center,const Vector3& p_half_extents,int p_indices_count) const {
-
+int BSP_Tree::_get_points_inside(int p_node, const Vector3 *p_points, int *p_indices, const Vector3 &p_center, const Vector3 &p_half_extents, int p_indices_count) const {
 
-	const Node *node =&nodes[p_node];
+	const Node *node = &nodes[p_node];
 	const Plane &p = planes[node->plane];
 
 	Vector3 min(
-			(p.normal.x>0) ? -p_half_extents.x : p_half_extents.x,
-			(p.normal.y>0) ? -p_half_extents.y : p_half_extents.y,
-			(p.normal.z>0) ? -p_half_extents.z : p_half_extents.z
-		);
-	Vector3 max=-min;
-	max+=p_center;
-	min+=p_center;
+			(p.normal.x > 0) ? -p_half_extents.x : p_half_extents.x,
+			(p.normal.y > 0) ? -p_half_extents.y : p_half_extents.y,
+			(p.normal.z > 0) ? -p_half_extents.z : p_half_extents.z);
+	Vector3 max = -min;
+	max += p_center;
+	min += p_center;
 
 	real_t dist_min = p.distance_to(min);
 	real_t dist_max = p.distance_to(max);
 
-	if ((dist_min * dist_max) < CMP_EPSILON ) { //intersection, test point by point
-
+	if ((dist_min * dist_max) < CMP_EPSILON) { //intersection, test point by point
 
-		int under_count=0;
+		int under_count = 0;
 
 		//sort points, so the are under first, over last
-		for(int i=0;i<p_indices_count;i++) {
+		for (int i = 0; i < p_indices_count; i++) {
 
-			int index=p_indices[i];
+			int index = p_indices[i];
 
 			if (p.is_point_over(p_points[index])) {
 
 				// kind of slow (but cache friendly), should try something else,
 				// but this is a corner case most of the time
 
-				for(int j=index;j<p_indices_count-1;j++)
-					p_indices[j]=p_indices[j+1];
+				for (int j = index; j < p_indices_count - 1; j++)
+					p_indices[j] = p_indices[j + 1];
 
-				p_indices[p_indices_count-1]=index;
+				p_indices[p_indices_count - 1] = index;
 
 			} else {
 				under_count++;
 			}
-
 		}
 
-		int total=0;
+		int total = 0;
 
-		if (under_count>0) {
-			if (node->under==UNDER_LEAF) {
-				total+=under_count;
+		if (under_count > 0) {
+			if (node->under == UNDER_LEAF) {
+				total += under_count;
 			} else {
-				total+=_get_points_inside(node->under,p_points,p_indices,p_center,p_half_extents,under_count);
+				total += _get_points_inside(node->under, p_points, p_indices, p_center, p_half_extents, under_count);
 			}
 		}
 
-		if (under_count!=p_indices_count) {
-			if (node->over==OVER_LEAF) {
+		if (under_count != p_indices_count) {
+			if (node->over == OVER_LEAF) {
 				//total+=0 //if they are over an OVER_LEAF, they are outside the model
 			} else {
-				total+=_get_points_inside(node->over,p_points,&p_indices[under_count],p_center,p_half_extents,p_indices_count-under_count);
+				total += _get_points_inside(node->over, p_points, &p_indices[under_count], p_center, p_half_extents, p_indices_count - under_count);
 			}
 		}
 
 		return total;
 
-	} else if (dist_min > 0 ) { //all points over plane
+	} else if (dist_min > 0) { //all points over plane
 
-		if (node->over==OVER_LEAF) {
+		if (node->over == OVER_LEAF) {
 
 			return 0; // all these points are not visible
 		}
 
+		return _get_points_inside(node->over, p_points, p_indices, p_center, p_half_extents, p_indices_count);
+	} else if (dist_min <= 0) { //all points behind plane
 
-		return _get_points_inside(node->over,p_points,p_indices,p_center,p_half_extents,p_indices_count);
-	} else if (dist_min <= 0 ) { //all points behind plane
-
-		if (node->under==UNDER_LEAF) {
+		if (node->under == UNDER_LEAF) {
 
 			return p_indices_count; // all these points are visible
 		}
-		return _get_points_inside(node->under,p_points,p_indices,p_center,p_half_extents,p_indices_count);
+		return _get_points_inside(node->under, p_points, p_indices, p_center, p_half_extents, p_indices_count);
 	}
 
 	return 0;
 }
 
-int BSP_Tree::get_points_inside(const Vector3* p_points,int p_point_count) const {
-
+int BSP_Tree::get_points_inside(const Vector3 *p_points, int p_point_count) const {
 
-	if (nodes.size()==0)
+	if (nodes.size() == 0)
 		return 0;
 
 #if 1
-//this version is easier to debug, and and MUCH faster in real world cases
+	//this version is easier to debug, and and MUCH faster in real world cases
 
 	int pass_count = 0;
-	const Node *nodesptr=&nodes[0];
-	const Plane *planesptr=&planes[0];
-	int plane_count=planes.size();
-	int node_count=nodes.size();
+	const Node *nodesptr = &nodes[0];
+	const Plane *planesptr = &planes[0];
+	int plane_count = planes.size();
+	int node_count = nodes.size();
 
-	if (node_count==0) // no nodes!
+	if (node_count == 0) // no nodes!
 		return 0;
 
-	for(int i=0;i<p_point_count;i++) {
+	for (int i = 0; i < p_point_count; i++) {
 
-		const Vector3& point = p_points[i];
+		const Vector3 &point = p_points[i];
 		if (!aabb.has_point(point)) {
 			continue;
 		}
 
-		int idx=node_count-1;
+		int idx = node_count - 1;
 
-		bool pass=false;
+		bool pass = false;
 
-		while(true) {
+		while (true) {
 
-			if (idx==OVER_LEAF) {
-				pass=false;
+			if (idx == OVER_LEAF) {
+				pass = false;
 				break;
-			} else if (idx==UNDER_LEAF) {
-				pass=true;
+			} else if (idx == UNDER_LEAF) {
+				pass = true;
 				break;
 			}
 
-			uint16_t plane=nodesptr[ idx ].plane;
+			uint16_t plane = nodesptr[idx].plane;
 #ifdef DEBUG_ENABLED
 
-			ERR_FAIL_INDEX_V( plane, plane_count, false );
+			ERR_FAIL_INDEX_V(plane, plane_count, false);
 #endif
 
-			idx = planesptr[ nodesptr[ idx ].plane ].is_point_over(point) ? nodes[ idx ].over : nodes[ idx ].under;
+			idx = planesptr[nodesptr[idx].plane].is_point_over(point) ? nodes[idx].over : nodes[idx].under;
 
 #ifdef DEBUG_ENABLED
 
-			ERR_FAIL_COND_V( idx<MAX_NODES && idx>=node_count, false );
+			ERR_FAIL_COND_V(idx < MAX_NODES && idx >= node_count, false);
 #endif
-
 		}
 
 		if (pass)
@@ -218,69 +210,65 @@ int BSP_Tree::get_points_inside(const Vector3* p_points,int p_point_count) const
 	return pass_count;
 
 #else
-//this version scales better but it's slower for real world cases
+	//this version scales better but it's slower for real world cases
 
-	int *indices = (int*)alloca(p_point_count*sizeof(int));
+	int *indices = (int *)alloca(p_point_count * sizeof(int));
 	AABB bounds;
 
-	for(int i=0;i<p_point_count;i++) {
+	for (int i = 0; i < p_point_count; i++) {
 
-		indices[i]=i;
-		if (i==0)
-			bounds.pos=p_points[i];
+		indices[i] = i;
+		if (i == 0)
+			bounds.pos = p_points[i];
 		else
 			bounds.expand_to(p_points[i]);
-
 	}
 
-	Vector3 half_extents = bounds.size/2.0;
-	return _get_points_inside(nodes.size()+1,p_points,indices,bounds.pos+half_extents,half_extents,p_point_count);
+	Vector3 half_extents = bounds.size / 2.0;
+	return _get_points_inside(nodes.size() + 1, p_points, indices, bounds.pos + half_extents, half_extents, p_point_count);
 #endif
 }
 
-
-
-bool BSP_Tree::point_is_inside(const Vector3& p_point) const {
+bool BSP_Tree::point_is_inside(const Vector3 &p_point) const {
 
 	if (!aabb.has_point(p_point)) {
 		return false;
 	}
 
-	int node_count=nodes.size();
+	int node_count = nodes.size();
 
-	if (node_count==0) // no nodes!
+	if (node_count == 0) // no nodes!
 		return false;
 
+	const Node *nodesptr = &nodes[0];
+	const Plane *planesptr = &planes[0];
+	int plane_count = planes.size();
 
-	const Node *nodesptr=&nodes[0];
-	const Plane *planesptr=&planes[0];
-	int plane_count=planes.size();
-
-	int idx=node_count-1;
-	int steps=0;
+	int idx = node_count - 1;
+	int steps = 0;
 
-	while(true) {
+	while (true) {
 
-		if (idx==OVER_LEAF) {
+		if (idx == OVER_LEAF) {
 			return false;
 		}
-		if (idx==UNDER_LEAF) {
+		if (idx == UNDER_LEAF) {
 
 			return true;
 		}
 
-		uint16_t plane=nodesptr[ idx ].plane;
+		uint16_t plane = nodesptr[idx].plane;
 #ifdef DEBUG_ENABLED
 
-		ERR_FAIL_INDEX_V( plane, plane_count, false );
+		ERR_FAIL_INDEX_V(plane, plane_count, false);
 #endif
-		bool over = planesptr[ nodesptr[ idx ].plane ].is_point_over(p_point);
+		bool over = planesptr[nodesptr[idx].plane].is_point_over(p_point);
 
-		idx =  over ? nodes[ idx ].over : nodes[ idx ].under;
+		idx = over ? nodes[idx].over : nodes[idx].under;
 
 #ifdef DEBUG_ENABLED
 
-		ERR_FAIL_COND_V( idx<MAX_NODES && idx>=node_count, false );
+		ERR_FAIL_COND_V(idx < MAX_NODES && idx >= node_count, false);
 #endif
 
 		steps++;
@@ -289,44 +277,42 @@ bool BSP_Tree::point_is_inside(const Vector3& p_point) const {
 	return false;
 }
 
-
-static int _bsp_find_best_half_plane(const Face3* p_faces,const Vector<int>& p_indices,real_t p_tolerance) {
+static int _bsp_find_best_half_plane(const Face3 *p_faces, const Vector<int> &p_indices, real_t p_tolerance) {
 
 	int ic = p_indices.size();
-	const int*indices=p_indices.ptr();
+	const int *indices = p_indices.ptr();
 
 	int best_plane = -1;
 	real_t best_plane_cost = 1e20;
 
 	// Loop to find the polygon that best divides the set.
 
-	for (int i=0;i<ic;i++) {
+	for (int i = 0; i < ic; i++) {
 
-		const Face3& f=p_faces[ indices[i] ];
+		const Face3 &f = p_faces[indices[i]];
 		Plane p = f.get_plane();
 
-		int num_over=0,num_under=0,num_spanning=0;
+		int num_over = 0, num_under = 0, num_spanning = 0;
 
-		for(int j=0;j<ic;j++) {
+		for (int j = 0; j < ic; j++) {
 
-			if (i==j)
+			if (i == j)
 				continue;
 
-			const Face3& g=p_faces[ indices[j] ];
-			int over=0,under=0;
+			const Face3 &g = p_faces[indices[j]];
+			int over = 0, under = 0;
 
-			for(int k=0;k<3;k++) {
+			for (int k = 0; k < 3; k++) {
 
 				real_t d = p.distance_to(g.vertex[j]);
 
-				if (Math::abs(d)>p_tolerance) {
+				if (Math::abs(d) > p_tolerance) {
 
 					if (d > 0)
 						over++;
 					else
 						under++;
 				}
-
 			}
 
 			if (over && under)
@@ -335,13 +321,10 @@ static int _bsp_find_best_half_plane(const Face3* p_faces,const Vector<int>& p_i
 				num_over++;
 			else
 				num_under++;
-
 		}
 
-
-
 		//real_t split_cost = num_spanning / (real_t) face_count;
-		real_t relation = Math::abs(num_over-num_under) / (real_t) ic;
+		real_t relation = Math::abs(num_over - num_under) / (real_t)ic;
 
 		// being honest, i never found a way to add split cost to the mix in a meaninguful way
 		// in this engine, also, will likely be ignored anyway
@@ -349,59 +332,55 @@ static int _bsp_find_best_half_plane(const Face3* p_faces,const Vector<int>& p_i
 		real_t plane_cost = /*split_cost +*/ relation;
 
 		//printf("plane %i, %i over, %i under, %i spanning, cost is %g\n",i,num_over,num_under,num_spanning,plane_cost);
-		if (plane_cost<best_plane_cost) {
+		if (plane_cost < best_plane_cost) {
 
-			best_plane=i;
-			best_plane_cost=plane_cost;
+			best_plane = i;
+			best_plane_cost = plane_cost;
 		}
-
 	}
 
 	return best_plane;
-
 }
 
+static int _bsp_create_node(const Face3 *p_faces, const Vector<int> &p_indices, Vector<Plane> &p_planes, Vector<BSP_Tree::Node> &p_nodes, real_t p_tolerance) {
 
-static int _bsp_create_node(const Face3 *p_faces,const Vector<int>& p_indices,Vector<Plane> &p_planes, Vector<BSP_Tree::Node> &p_nodes,real_t p_tolerance) {
-
-	ERR_FAIL_COND_V( p_nodes.size() == BSP_Tree::MAX_NODES, -1 );
+	ERR_FAIL_COND_V(p_nodes.size() == BSP_Tree::MAX_NODES, -1);
 
 	// should not reach here
-	ERR_FAIL_COND_V( p_indices.size() == 0, -1 )
+	ERR_FAIL_COND_V(p_indices.size() == 0, -1)
 
 	int ic = p_indices.size();
-	const int*indices=p_indices.ptr();
+	const int *indices = p_indices.ptr();
 
-	int divisor_idx = _bsp_find_best_half_plane(p_faces,p_indices,p_tolerance);
+	int divisor_idx = _bsp_find_best_half_plane(p_faces, p_indices, p_tolerance);
 
 	// returned error
-	ERR_FAIL_COND_V( divisor_idx<0 , -1 );
-
+	ERR_FAIL_COND_V(divisor_idx < 0, -1);
 
 	Vector<int> faces_over;
 	Vector<int> faces_under;
 
-	Plane divisor_plane=p_faces[ indices[divisor_idx] ].get_plane();
+	Plane divisor_plane = p_faces[indices[divisor_idx]].get_plane();
 
-	for (int i=0;i<ic;i++) {
+	for (int i = 0; i < ic; i++) {
 
-		if (i==divisor_idx)
+		if (i == divisor_idx)
 			continue;
 
-		const Face3& f=p_faces[ indices[i] ];
+		const Face3 &f = p_faces[indices[i]];
 
 		/*
 		if (f.get_plane().is_almost_like(divisor_plane))
 			continue;
 		*/
 
-		int over_count=0;
-		int under_count=0;
+		int over_count = 0;
+		int under_count = 0;
 
-		for(int j=0;j<3;j++) {
+		for (int j = 0; j < 3; j++) {
 
 			real_t d = divisor_plane.distance_to(f.vertex[j]);
-			if (Math::abs(d)>p_tolerance) {
+			if (Math::abs(d) > p_tolerance) {
 
 				if (d > 0)
 					over_count++;
@@ -411,183 +390,169 @@ static int _bsp_create_node(const Face3 *p_faces,const Vector<int>& p_indices,Ve
 		}
 
 		if (over_count)
-			faces_over.push_back( indices[i] );
+			faces_over.push_back(indices[i]);
 		if (under_count)
-			faces_under.push_back( indices[i] );
-
+			faces_under.push_back(indices[i]);
 	}
 
+	uint16_t over_idx = BSP_Tree::OVER_LEAF, under_idx = BSP_Tree::UNDER_LEAF;
 
+	if (faces_over.size() > 0) { //have facess above?
 
-	uint16_t over_idx=BSP_Tree::OVER_LEAF,under_idx=BSP_Tree::UNDER_LEAF;
-
-	if (faces_over.size()>0) { //have facess above?
-
-		int idx = _bsp_create_node( p_faces, faces_over, p_planes, p_nodes,p_tolerance );
-		if (idx>=0)
-			over_idx=idx;
+		int idx = _bsp_create_node(p_faces, faces_over, p_planes, p_nodes, p_tolerance);
+		if (idx >= 0)
+			over_idx = idx;
 	}
 
-	if (faces_under.size()>0) { //have facess above?
+	if (faces_under.size() > 0) { //have facess above?
 
-		int idx = _bsp_create_node( p_faces,faces_under, p_planes, p_nodes,p_tolerance );
-		if (idx>=0)
-			under_idx=idx;
+		int idx = _bsp_create_node(p_faces, faces_under, p_planes, p_nodes, p_tolerance);
+		if (idx >= 0)
+			under_idx = idx;
 	}
 
 	/* Create the node */
 
 	// find existing divisor plane
-	int divisor_plane_idx=-1;
-
+	int divisor_plane_idx = -1;
 
-	for (int i=0;i<p_planes.size();i++) {
+	for (int i = 0; i < p_planes.size(); i++) {
 
-		if (p_planes[i].is_almost_like( divisor_plane )) {
-			divisor_plane_idx=i;
+		if (p_planes[i].is_almost_like(divisor_plane)) {
+			divisor_plane_idx = i;
 			break;
 		}
 	}
 
-	if (divisor_plane_idx==-1) {
+	if (divisor_plane_idx == -1) {
 
-		ERR_FAIL_COND_V( p_planes.size() == BSP_Tree::MAX_PLANES, -1 );
-		divisor_plane_idx=p_planes.size();
-		p_planes.push_back( divisor_plane );
+		ERR_FAIL_COND_V(p_planes.size() == BSP_Tree::MAX_PLANES, -1);
+		divisor_plane_idx = p_planes.size();
+		p_planes.push_back(divisor_plane);
 	}
 
 	BSP_Tree::Node node;
-	node.plane=divisor_plane_idx;
-	node.under=under_idx;
-	node.over=over_idx;
+	node.plane = divisor_plane_idx;
+	node.under = under_idx;
+	node.over = over_idx;
 
 	p_nodes.push_back(node);
 
-	return p_nodes.size()-1;
+	return p_nodes.size() - 1;
 }
 
-
 BSP_Tree::operator Variant() const {
 
-
 	Dictionary d;
-	d["error_radius"]=error_radius;
+	d["error_radius"] = error_radius;
 
 	Vector<real_t> plane_values;
-	plane_values.resize(planes.size()*4);
+	plane_values.resize(planes.size() * 4);
 
-	for(int i=0;i<planes.size();i++) {
+	for (int i = 0; i < planes.size(); i++) {
 
-		plane_values[i*4+0]=planes[i].normal.x;
-		plane_values[i*4+1]=planes[i].normal.y;
-		plane_values[i*4+2]=planes[i].normal.z;
-		plane_values[i*4+3]=planes[i].d;
+		plane_values[i * 4 + 0] = planes[i].normal.x;
+		plane_values[i * 4 + 1] = planes[i].normal.y;
+		plane_values[i * 4 + 2] = planes[i].normal.z;
+		plane_values[i * 4 + 3] = planes[i].d;
 	}
 
-	d["planes"]=plane_values;
+	d["planes"] = plane_values;
 
 	PoolVector<int> dst_nodes;
-	dst_nodes.resize(nodes.size()*3);
+	dst_nodes.resize(nodes.size() * 3);
 
-	for(int i=0;i<nodes.size();i++) {
+	for (int i = 0; i < nodes.size(); i++) {
 
-		dst_nodes.set(i*3+0,nodes[i].over);
-		dst_nodes.set(i*3+1,nodes[i].under);
-		dst_nodes.set(i*3+2,nodes[i].plane);
+		dst_nodes.set(i * 3 + 0, nodes[i].over);
+		dst_nodes.set(i * 3 + 1, nodes[i].under);
+		dst_nodes.set(i * 3 + 2, nodes[i].plane);
 	}
 
-
-	d["nodes"]=dst_nodes;
+	d["nodes"] = dst_nodes;
 	d["aabb"] = aabb;
 
 	return Variant(d);
 }
 
 BSP_Tree::BSP_Tree() {
-
 }
 
+BSP_Tree::BSP_Tree(const Variant &p_variant) {
 
-BSP_Tree::BSP_Tree(const Variant& p_variant) {
-
-	Dictionary d=p_variant;
+	Dictionary d = p_variant;
 	ERR_FAIL_COND(!d.has("nodes"));
 	ERR_FAIL_COND(!d.has("planes"));
 	ERR_FAIL_COND(!d.has("aabb"));
 	ERR_FAIL_COND(!d.has("error_radius"));
 
 	PoolVector<int> src_nodes = d["nodes"];
-	ERR_FAIL_COND(src_nodes.size()%3);
+	ERR_FAIL_COND(src_nodes.size() % 3);
 
+	if (d["planes"].get_type() == Variant::POOL_REAL_ARRAY) {
 
-	if (d["planes"].get_type()==Variant::POOL_REAL_ARRAY) {
-
-		PoolVector<real_t> src_planes=d["planes"];
-		int plane_count=src_planes.size();
-		ERR_FAIL_COND(plane_count%4);
-		planes.resize(plane_count/4);
+		PoolVector<real_t> src_planes = d["planes"];
+		int plane_count = src_planes.size();
+		ERR_FAIL_COND(plane_count % 4);
+		planes.resize(plane_count / 4);
 
 		if (plane_count) {
 			PoolVector<real_t>::Read r = src_planes.read();
-			for(int i=0;i<plane_count/4;i++) {
+			for (int i = 0; i < plane_count / 4; i++) {
 
-				planes[i].normal.x=r[i*4+0];
-				planes[i].normal.y=r[i*4+1];
-				planes[i].normal.z=r[i*4+2];
-				planes[i].d=r[i*4+3];
+				planes[i].normal.x = r[i * 4 + 0];
+				planes[i].normal.y = r[i * 4 + 1];
+				planes[i].normal.z = r[i * 4 + 2];
+				planes[i].d = r[i * 4 + 3];
 			}
 		}
 
-
 	} else {
 
 		planes = d["planes"];
 	}
 
-
 	error_radius = d["error"];
 	aabb = d["aabb"];
 
 	//int node_count = src_nodes.size();
-	nodes.resize(src_nodes.size()/3);
+	nodes.resize(src_nodes.size() / 3);
 
 	PoolVector<int>::Read r = src_nodes.read();
 
-	for(int i=0;i<nodes.size();i++) {
+	for (int i = 0; i < nodes.size(); i++) {
 
-		nodes[i].over=r[i*3+0];
-		nodes[i].under=r[i*3+1];
-		nodes[i].plane=r[i*3+2];
+		nodes[i].over = r[i * 3 + 0];
+		nodes[i].under = r[i * 3 + 1];
+		nodes[i].plane = r[i * 3 + 2];
 	}
-
 }
 
-BSP_Tree::BSP_Tree(const PoolVector<Face3>& p_faces,real_t p_error_radius) {
+BSP_Tree::BSP_Tree(const PoolVector<Face3> &p_faces, real_t p_error_radius) {
 
 	// compute aabb
 
-	int face_count=p_faces.size();
-	PoolVector<Face3>::Read faces_r=p_faces.read();
+	int face_count = p_faces.size();
+	PoolVector<Face3>::Read faces_r = p_faces.read();
 	const Face3 *facesptr = faces_r.ptr();
 
-
-	bool first=true;
+	bool first = true;
 
 	Vector<int> indices;
 
-	for (int i=0;i<face_count;i++) {
+	for (int i = 0; i < face_count; i++) {
 
-		const Face3& f=facesptr[i];
+		const Face3 &f = facesptr[i];
 
 		if (f.is_degenerate())
 			continue;
 
-		for (int j=0;j<3;j++) {
+		for (int j = 0; j < 3; j++) {
 
 			if (first) {
 
-				aabb.pos=f.vertex[0];
-				first=false;
+				aabb.pos = f.vertex[0];
+				first = false;
 			} else {
 
 				aabb.expand_to(f.vertex[j]);
@@ -595,36 +560,29 @@ BSP_Tree::BSP_Tree(const PoolVector<Face3>& p_faces,real_t p_error_radius) {
 		}
 
 		indices.push_back(i);
-
 	}
 
-	ERR_FAIL_COND( aabb.has_no_area() );
+	ERR_FAIL_COND(aabb.has_no_area());
 
-	int top = _bsp_create_node(faces_r.ptr(),indices,planes,nodes,aabb.get_longest_axis_size()*0.0001);
+	int top = _bsp_create_node(faces_r.ptr(), indices, planes, nodes, aabb.get_longest_axis_size() * 0.0001);
 
-	if (top<0) {
+	if (top < 0) {
 
 		nodes.clear();
 		planes.clear();
-		ERR_FAIL_COND( top < 0 );
+		ERR_FAIL_COND(top < 0);
 	}
 
-
-
-
-	error_radius=p_error_radius;
+	error_radius = p_error_radius;
 }
 
-BSP_Tree::BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const Rect3& p_aabb,real_t p_error_radius) {
-
-	nodes=p_nodes;
-	planes=p_planes;
-	aabb=p_aabb;
-	error_radius=p_error_radius;
+BSP_Tree::BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const Rect3 &p_aabb, real_t p_error_radius) {
 
+	nodes = p_nodes;
+	planes = p_planes;
+	aabb = p_aabb;
+	error_radius = p_error_radius;
 }
 
 BSP_Tree::~BSP_Tree() {
-
-
 }