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, 118 deletions

diff --git a/core/math/octree.h b/core/math/octree.h
index 7d89c50f69..0782a39804 100644
--- a/core/math/octree.h
+++ b/core/math/octree.h
@@ -68,7 +68,6 @@ private:
 	};
 
 	struct PairKey {
-
 		union {
 			struct {
 				OctreeElementID A;
@@ -78,18 +77,14 @@ private:
 		};
 
 		_FORCE_INLINE_ bool operator<(const PairKey &p_pair) const {
-
 			return key < p_pair.key;
 		}
 
 		_FORCE_INLINE_ PairKey(OctreeElementID p_A, OctreeElementID p_B) {
-
 			if (p_A < p_B) {
-
 				A = p_A;
 				B = p_B;
 			} else {
-
 				B = p_A;
 				A = p_B;
 			}
@@ -101,7 +96,6 @@ private:
 	struct Element;
 
 	struct Octant {
-
 		// cached for FAST plane check
 		AABB aabb;
 
@@ -122,7 +116,6 @@ private:
 	struct PairData;
 
 	struct Element {
-
 		Octree *octree = nullptr;
 
 		T *userdata = nullptr;
@@ -141,7 +134,6 @@ private:
 		List<PairData *, AL> pair_list;
 
 		struct OctantOwner {
-
 			Octant *octant;
 			typename List<Element *, AL>::Element *E;
 		}; // an element can be in max 8 octants
@@ -152,7 +144,6 @@ private:
 	};
 
 	struct PairData {
-
 		int refcount;
 		bool intersect;
 		Element *A, *B;
@@ -179,19 +170,15 @@ private:
 	int pair_count;
 
 	_FORCE_INLINE_ void _pair_check(PairData *p_pair) {
-
 		bool intersect = p_pair->A->aabb.intersects_inclusive(p_pair->B->aabb);
 
 		if (intersect != p_pair->intersect) {
-
 			if (intersect) {
-
 				if (pair_callback) {
 					p_pair->ud = pair_callback(pair_callback_userdata, p_pair->A->_id, p_pair->A->userdata, p_pair->A->subindex, p_pair->B->_id, p_pair->B->userdata, p_pair->B->subindex);
 				}
 				pair_count++;
 			} else {
-
 				if (unpair_callback) {
 					unpair_callback(pair_callback_userdata, p_pair->A->_id, p_pair->A->userdata, p_pair->A->subindex, p_pair->B->_id, p_pair->B->userdata, p_pair->B->subindex, p_pair->ud);
 				}
@@ -203,7 +190,6 @@ private:
 	}
 
 	_FORCE_INLINE_ void _pair_reference(Element *p_A, Element *p_B) {
-
 		if (p_A == p_B || (p_A->userdata == p_B->userdata && p_A->userdata))
 			return;
 
@@ -215,7 +201,6 @@ private:
 		typename PairMap::Element *E = pair_map.find(key);
 
 		if (!E) {
-
 			PairData pdata;
 			pdata.refcount = 1;
 			pdata.A = p_A;
@@ -230,13 +215,11 @@ private:
 				pair_callback(pair_callback_userdata,p_A->userdata,p_B->userdata);
 			*/
 		} else {
-
 			E->get().refcount++;
 		}
 	}
 
 	_FORCE_INLINE_ void _pair_unreference(Element *p_A, Element *p_B) {
-
 		if (p_A == p_B)
 			return;
 
@@ -271,24 +254,18 @@ private:
 	}
 
 	_FORCE_INLINE_ void _element_check_pairs(Element *p_element) {
-
 		typename List<PairData *, AL>::Element *E = p_element->pair_list.front();
 		while (E) {
-
 			_pair_check(E->get());
 			E = E->next();
 		}
 	}
 
 	_FORCE_INLINE_ void _optimize() {
-
 		while (root && root->children_count < 2 && !root->elements.size() && !(use_pairs && root->pairable_elements.size())) {
-
 			Octant *new_root = nullptr;
 			if (root->children_count == 1) {
-
 				for (int i = 0; i < 8; i++) {
-
 					if (root->children[i]) {
 						new_root = root->children[i];
 						root->children[i] = nullptr;
@@ -314,7 +291,6 @@ private:
 	void _unpair_element(Element *p_element, Octant *p_octant);
 
 	struct _CullConvexData {
-
 		const Plane *planes;
 		int plane_count;
 		const Vector3 *points;
@@ -331,12 +307,10 @@ private:
 	void _cull_point(Octant *p_octant, const Vector3 &p_point, T **p_result_array, int *p_result_idx, int p_result_max, int *p_subindex_array, uint32_t p_mask);
 
 	void _remove_tree(Octant *p_octant) {
-
 		if (!p_octant)
 			return;
 
 		for (int i = 0; i < 8; i++) {
-
 			if (p_octant->children[i])
 				_remove_tree(p_octant->children[i]);
 		}
@@ -380,7 +354,6 @@ T *Octree<T, use_pairs, AL>::get(OctreeElementID p_id) const {
 
 template <class T, bool use_pairs, class AL>
 bool Octree<T, use_pairs, AL>::is_pairable(OctreeElementID p_id) const {
-
 	const typename ElementMap::Element *E = element_map.find(p_id);
 	ERR_FAIL_COND_V(!E, false);
 	return E->get().pairable;
@@ -388,7 +361,6 @@ bool Octree<T, use_pairs, AL>::is_pairable(OctreeElementID p_id) const {
 
 template <class T, bool use_pairs, class AL>
 int Octree<T, use_pairs, AL>::get_subindex(OctreeElementID p_id) const {
-
 	const typename ElementMap::Element *E = element_map.find(p_id);
 	ERR_FAIL_COND_V(!E, -1);
 	return E->get().subindex;
@@ -398,7 +370,6 @@ int Octree<T, use_pairs, AL>::get_subindex(OctreeElementID p_id) const {
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_insert_element(Element *p_element, Octant *p_octant) {
-
 	real_t element_size = p_element->aabb.get_longest_axis_size() * 1.01; // avoid precision issues
 
 	if (p_octant->aabb.size.x / OCTREE_DIVISOR < element_size) {
@@ -409,11 +380,9 @@ void Octree<T, use_pairs, AL>::_insert_element(Element *p_element, Octant *p_oct
 		owner.octant = p_octant;
 
 		if (use_pairs && p_element->pairable) {
-
 			p_octant->pairable_elements.push_back(p_element);
 			owner.E = p_octant->pairable_elements.back();
 		} else {
-
 			p_octant->elements.push_back(p_element);
 			owner.E = p_octant->elements.back();
 		}
@@ -428,11 +397,9 @@ void Octree<T, use_pairs, AL>::_insert_element(Element *p_element, Octant *p_oct
 		}
 
 		if (use_pairs && p_octant->children_count > 0) {
-
 			pass++; //elements below this only get ONE reference added
 
 			for (int i = 0; i < 8; i++) {
-
 				if (p_octant->children[i]) {
 					_pair_element(p_element, p_octant->children[i]);
 				}
@@ -444,7 +411,6 @@ void Octree<T, use_pairs, AL>::_insert_element(Element *p_element, Octant *p_oct
 		bool candidate = p_element->common_parent == nullptr;
 
 		for (int i = 0; i < 8; i++) {
-
 			if (p_octant->children[i]) {
 				/* element exists, go straight to it */
 				if (p_octant->children[i]->aabb.intersects_inclusive(p_element->aabb)) {
@@ -484,13 +450,11 @@ void Octree<T, use_pairs, AL>::_insert_element(Element *p_element, Octant *p_oct
 		}
 
 		if (candidate && splits > 1) {
-
 			p_element->common_parent = p_octant;
 		}
 	}
 
 	if (use_pairs) {
-
 		typename List<Element *, AL>::Element *E = p_octant->pairable_elements.front();
 
 		while (E) {
@@ -511,14 +475,12 @@ void Octree<T, use_pairs, AL>::_insert_element(Element *p_element, Octant *p_oct
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_ensure_valid_root(const AABB &p_aabb) {
-
 	if (!root) {
 		// octre is empty
 
 		AABB base(Vector3(), Vector3(1.0, 1.0, 1.0) * unit_size);
 
 		while (!base.encloses(p_aabb)) {
-
 			if (ABS(base.position.x + base.size.x) <= ABS(base.position.x)) {
 				/* grow towards positive */
 				base.size *= 2.0;
@@ -537,11 +499,9 @@ void Octree<T, use_pairs, AL>::_ensure_valid_root(const AABB &p_aabb) {
 		octant_count++;
 
 	} else {
-
 		AABB base = root->aabb;
 
 		while (!base.encloses(p_aabb)) {
-
 			ERR_FAIL_COND_MSG(base.size.x > OCTREE_SIZE_LIMIT, "Octree upper size limit reached, does the AABB supplied contain NAN?");
 
 			Octant *gp = memnew_allocator(Octant, AL);
@@ -570,11 +530,9 @@ void Octree<T, use_pairs, AL>::_ensure_valid_root(const AABB &p_aabb) {
 
 template <class T, bool use_pairs, class AL>
 bool Octree<T, use_pairs, AL>::_remove_element_from_octant(Element *p_element, Octant *p_octant, Octant *p_limit) {
-
 	bool octant_removed = false;
 
 	while (true) {
-
 		// check all exit conditions
 
 		if (p_octant == p_limit) // reached limit, nothing to erase, exit
@@ -607,7 +565,6 @@ bool Octree<T, use_pairs, AL>::_remove_element_from_octant(Element *p_element, O
 		Octant *parent = p_octant->parent;
 
 		if (p_octant->children_count == 0 && p_octant->elements.empty() && p_octant->pairable_elements.empty()) {
-
 			// erase octant
 
 			if (p_octant == root) { // won't have a parent, just erase
@@ -637,7 +594,6 @@ bool Octree<T, use_pairs, AL>::_remove_element_from_octant(Element *p_element, O
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_unpair_element(Element *p_element, Octant *p_octant) {
-
 	// always test pairable
 	typename List<Element *, AL>::Element *E = p_octant->pairable_elements.front();
 	while (E) {
@@ -666,7 +622,6 @@ void Octree<T, use_pairs, AL>::_unpair_element(Element *p_element, Octant *p_oct
 		return; // small optimization for leafs
 
 	for (int i = 0; i < 8; i++) {
-
 		if (p_octant->children[i])
 			_unpair_element(p_element, p_octant->children[i]);
 	}
@@ -674,13 +629,11 @@ void Octree<T, use_pairs, AL>::_unpair_element(Element *p_element, Octant *p_oct
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_pair_element(Element *p_element, Octant *p_octant) {
-
 	// always test pairable
 
 	typename List<Element *, AL>::Element *E = p_octant->pairable_elements.front();
 
 	while (E) {
-
 		if (E->get()->last_pass != pass) { // only get ONE reference
 			_pair_reference(p_element, E->get());
 			E->get()->last_pass = pass;
@@ -705,7 +658,6 @@ void Octree<T, use_pairs, AL>::_pair_element(Element *p_element, Octant *p_octan
 		return; // small optimization for leafs
 
 	for (int i = 0; i < 8; i++) {
-
 		if (p_octant->children[i])
 			_pair_element(p_element, p_octant->children[i]);
 	}
@@ -713,14 +665,12 @@ void Octree<T, use_pairs, AL>::_pair_element(Element *p_element, Octant *p_octan
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_remove_element(Element *p_element) {
-
 	pass++; // will do a new pass for this
 
 	typename List<typename Element::OctantOwner, AL>::Element *I = p_element->octant_owners.front();
 
 	/* FIRST remove going up normally */
 	for (; I; I = I->next()) {
-
 		Octant *o = I->get().octant;
 
 		if (!use_pairs) // small speedup
@@ -734,15 +684,12 @@ void Octree<T, use_pairs, AL>::_remove_element(Element *p_element) {
 	I = p_element->octant_owners.front();
 
 	if (use_pairs) {
-
 		for (; I; I = I->next()) {
-
 			Octant *o = I->get().octant;
 
 			// erase children pairs, they are erased ONCE even if repeated
 			pass++;
 			for (int i = 0; i < 8; i++) {
-
 				if (o->children[i])
 					_unpair_element(p_element, o->children[i]);
 			}
@@ -757,7 +704,6 @@ void Octree<T, use_pairs, AL>::_remove_element(Element *p_element) {
 	p_element->octant_owners.clear();
 
 	if (use_pairs) {
-
 		int remaining = p_element->pair_list.size();
 		//p_element->pair_list.clear();
 		ERR_FAIL_COND(remaining);
@@ -766,7 +712,6 @@ void Octree<T, use_pairs, AL>::_remove_element(Element *p_element) {
 
 template <class T, bool use_pairs, class AL>
 OctreeElementID Octree<T, use_pairs, AL>::create(T *p_userdata, const AABB &p_aabb, int p_subindex, bool p_pairable, uint32_t p_pairable_type, uint32_t p_pairable_mask) {
-
 // check for AABB validity
 #ifdef DEBUG_ENABLED
 	ERR_FAIL_COND_V(p_aabb.position.x > 1e15 || p_aabb.position.x < -1e15, 0);
@@ -806,7 +751,6 @@ OctreeElementID Octree<T, use_pairs, AL>::create(T *p_userdata, const AABB &p_aa
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::move(OctreeElementID p_id, const AABB &p_aabb) {
-
 #ifdef DEBUG_ENABLED
 	// check for AABB validity
 	ERR_FAIL_COND(p_aabb.position.x > 1e15 || p_aabb.position.x < -1e15);
@@ -827,7 +771,6 @@ void Octree<T, use_pairs, AL>::move(OctreeElementID p_id, const AABB &p_aabb) {
 	bool new_has_surf = !p_aabb.has_no_surface();
 
 	if (old_has_surf != new_has_surf) {
-
 		if (old_has_surf) {
 			_remove_element(&e); // removing
 			e.common_parent = nullptr;
@@ -850,7 +793,6 @@ void Octree<T, use_pairs, AL>::move(OctreeElementID p_id, const AABB &p_aabb) {
 
 	// it still is enclosed in the same AABB it was assigned to
 	if (e.container_aabb.encloses(p_aabb)) {
-
 		e.aabb = p_aabb;
 		if (use_pairs)
 			_element_check_pairs(&e); // must check pairs anyway
@@ -888,7 +830,6 @@ void Octree<T, use_pairs, AL>::move(OctreeElementID p_id, const AABB &p_aabb) {
 	pass++;
 
 	for (typename List<typename Element::OctantOwner, AL>::Element *F = owners.front(); F;) {
-
 		Octant *o = F->get().octant;
 		typename List<typename Element::OctantOwner, AL>::Element *N = F->next();
 
@@ -903,7 +844,6 @@ void Octree<T, use_pairs, AL>::move(OctreeElementID p_id, const AABB &p_aabb) {
 			o->elements.erase(F->get().E);
 
 		if (_remove_element_from_octant(&e, o, common_parent->parent)) {
-
 			owners.erase(F);
 		}
 
@@ -913,13 +853,11 @@ void Octree<T, use_pairs, AL>::move(OctreeElementID p_id, const AABB &p_aabb) {
 	if (use_pairs) {
 		//unpair child elements in anything that survived
 		for (typename List<typename Element::OctantOwner, AL>::Element *F = owners.front(); F; F = F->next()) {
-
 			Octant *o = F->get().octant;
 
 			// erase children pairs, unref ONCE
 			pass++;
 			for (int i = 0; i < 8; i++) {
-
 				if (o->children[i])
 					_unpair_element(&e, o->children[i]);
 			}
@@ -933,7 +871,6 @@ void Octree<T, use_pairs, AL>::move(OctreeElementID p_id, const AABB &p_aabb) {
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::set_pairable(OctreeElementID p_id, bool p_pairable, uint32_t p_pairable_type, uint32_t p_pairable_mask) {
-
 	typename ElementMap::Element *E = element_map.find(p_id);
 	ERR_FAIL_COND(!E);
 
@@ -961,14 +898,12 @@ void Octree<T, use_pairs, AL>::set_pairable(OctreeElementID p_id, bool p_pairabl
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::erase(OctreeElementID p_id) {
-
 	typename ElementMap::Element *E = element_map.find(p_id);
 	ERR_FAIL_COND(!E);
 
 	Element &e = E->get();
 
 	if (!e.aabb.has_no_surface()) {
-
 		_remove_element(&e);
 	}
 
@@ -978,17 +913,14 @@ void Octree<T, use_pairs, AL>::erase(OctreeElementID p_id) {
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_cull_convex(Octant *p_octant, _CullConvexData *p_cull) {
-
 	if (*p_cull->result_idx == p_cull->result_max)
 		return; //pointless
 
 	if (!p_octant->elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->elements.front();
 
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_cull->mask)))
@@ -1000,7 +932,6 @@ void Octree<T, use_pairs, AL>::_cull_convex(Octant *p_octant, _CullConvexData *p
 					p_cull->result_array[*p_cull->result_idx] = e->userdata;
 					(*p_cull->result_idx)++;
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1008,12 +939,10 @@ void Octree<T, use_pairs, AL>::_cull_convex(Octant *p_octant, _CullConvexData *p
 	}
 
 	if (use_pairs && !p_octant->pairable_elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->pairable_elements.front();
 
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_cull->mask)))
@@ -1021,13 +950,10 @@ void Octree<T, use_pairs, AL>::_cull_convex(Octant *p_octant, _CullConvexData *p
 			e->last_pass = pass;
 
 			if (e->aabb.intersects_convex_shape(p_cull->planes, p_cull->plane_count, p_cull->points, p_cull->point_count)) {
-
 				if (*p_cull->result_idx < p_cull->result_max) {
-
 					p_cull->result_array[*p_cull->result_idx] = e->userdata;
 					(*p_cull->result_idx)++;
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1035,7 +961,6 @@ void Octree<T, use_pairs, AL>::_cull_convex(Octant *p_octant, _CullConvexData *p
 	}
 
 	for (int i = 0; i < 8; i++) {
-
 		if (p_octant->children[i] && p_octant->children[i]->aabb.intersects_convex_shape(p_cull->planes, p_cull->plane_count, p_cull->points, p_cull->point_count)) {
 			_cull_convex(p_octant->children[i], p_cull);
 		}
@@ -1044,16 +969,13 @@ void Octree<T, use_pairs, AL>::_cull_convex(Octant *p_octant, _CullConvexData *p
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_cull_aabb(Octant *p_octant, const AABB &p_aabb, T **p_result_array, int *p_result_idx, int p_result_max, int *p_subindex_array, uint32_t p_mask) {
-
 	if (*p_result_idx == p_result_max)
 		return; //pointless
 
 	if (!p_octant->elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->elements.front();
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_mask)))
@@ -1061,16 +983,13 @@ void Octree<T, use_pairs, AL>::_cull_aabb(Octant *p_octant, const AABB &p_aabb,
 			e->last_pass = pass;
 
 			if (p_aabb.intersects_inclusive(e->aabb)) {
-
 				if (*p_result_idx < p_result_max) {
-
 					p_result_array[*p_result_idx] = e->userdata;
 					if (p_subindex_array)
 						p_subindex_array[*p_result_idx] = e->subindex;
 
 					(*p_result_idx)++;
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1078,11 +997,9 @@ void Octree<T, use_pairs, AL>::_cull_aabb(Octant *p_octant, const AABB &p_aabb,
 	}
 
 	if (use_pairs && !p_octant->pairable_elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->pairable_elements.front();
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_mask)))
@@ -1090,15 +1007,12 @@ void Octree<T, use_pairs, AL>::_cull_aabb(Octant *p_octant, const AABB &p_aabb,
 			e->last_pass = pass;
 
 			if (p_aabb.intersects_inclusive(e->aabb)) {
-
 				if (*p_result_idx < p_result_max) {
-
 					p_result_array[*p_result_idx] = e->userdata;
 					if (p_subindex_array)
 						p_subindex_array[*p_result_idx] = e->subindex;
 					(*p_result_idx)++;
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1106,7 +1020,6 @@ void Octree<T, use_pairs, AL>::_cull_aabb(Octant *p_octant, const AABB &p_aabb,
 	}
 
 	for (int i = 0; i < 8; i++) {
-
 		if (p_octant->children[i] && p_octant->children[i]->aabb.intersects_inclusive(p_aabb)) {
 			_cull_aabb(p_octant->children[i], p_aabb, p_result_array, p_result_idx, p_result_max, p_subindex_array, p_mask);
 		}
@@ -1115,16 +1028,13 @@ void Octree<T, use_pairs, AL>::_cull_aabb(Octant *p_octant, const AABB &p_aabb,
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_cull_segment(Octant *p_octant, const Vector3 &p_from, const Vector3 &p_to, T **p_result_array, int *p_result_idx, int p_result_max, int *p_subindex_array, uint32_t p_mask) {
-
 	if (*p_result_idx == p_result_max)
 		return; //pointless
 
 	if (!p_octant->elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->elements.front();
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_mask)))
@@ -1132,16 +1042,13 @@ void Octree<T, use_pairs, AL>::_cull_segment(Octant *p_octant, const Vector3 &p_
 			e->last_pass = pass;
 
 			if (e->aabb.intersects_segment(p_from, p_to)) {
-
 				if (*p_result_idx < p_result_max) {
-
 					p_result_array[*p_result_idx] = e->userdata;
 					if (p_subindex_array)
 						p_subindex_array[*p_result_idx] = e->subindex;
 					(*p_result_idx)++;
 
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1149,11 +1056,9 @@ void Octree<T, use_pairs, AL>::_cull_segment(Octant *p_octant, const Vector3 &p_
 	}
 
 	if (use_pairs && !p_octant->pairable_elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->pairable_elements.front();
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_mask)))
@@ -1162,9 +1067,7 @@ void Octree<T, use_pairs, AL>::_cull_segment(Octant *p_octant, const Vector3 &p_
 			e->last_pass = pass;
 
 			if (e->aabb.intersects_segment(p_from, p_to)) {
-
 				if (*p_result_idx < p_result_max) {
-
 					p_result_array[*p_result_idx] = e->userdata;
 					if (p_subindex_array)
 						p_subindex_array[*p_result_idx] = e->subindex;
@@ -1172,7 +1075,6 @@ void Octree<T, use_pairs, AL>::_cull_segment(Octant *p_octant, const Vector3 &p_
 					(*p_result_idx)++;
 
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1180,7 +1082,6 @@ void Octree<T, use_pairs, AL>::_cull_segment(Octant *p_octant, const Vector3 &p_
 	}
 
 	for (int i = 0; i < 8; i++) {
-
 		if (p_octant->children[i] && p_octant->children[i]->aabb.intersects_segment(p_from, p_to)) {
 			_cull_segment(p_octant->children[i], p_from, p_to, p_result_array, p_result_idx, p_result_max, p_subindex_array, p_mask);
 		}
@@ -1189,16 +1090,13 @@ void Octree<T, use_pairs, AL>::_cull_segment(Octant *p_octant, const Vector3 &p_
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::_cull_point(Octant *p_octant, const Vector3 &p_point, T **p_result_array, int *p_result_idx, int p_result_max, int *p_subindex_array, uint32_t p_mask) {
-
 	if (*p_result_idx == p_result_max)
 		return; //pointless
 
 	if (!p_octant->elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->elements.front();
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_mask)))
@@ -1206,16 +1104,13 @@ void Octree<T, use_pairs, AL>::_cull_point(Octant *p_octant, const Vector3 &p_po
 			e->last_pass = pass;
 
 			if (e->aabb.has_point(p_point)) {
-
 				if (*p_result_idx < p_result_max) {
-
 					p_result_array[*p_result_idx] = e->userdata;
 					if (p_subindex_array)
 						p_subindex_array[*p_result_idx] = e->subindex;
 					(*p_result_idx)++;
 
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1223,11 +1118,9 @@ void Octree<T, use_pairs, AL>::_cull_point(Octant *p_octant, const Vector3 &p_po
 	}
 
 	if (use_pairs && !p_octant->pairable_elements.empty()) {
-
 		typename List<Element *, AL>::Element *I;
 		I = p_octant->pairable_elements.front();
 		for (; I; I = I->next()) {
-
 			Element *e = I->get();
 
 			if (e->last_pass == pass || (use_pairs && !(e->pairable_type & p_mask)))
@@ -1236,9 +1129,7 @@ void Octree<T, use_pairs, AL>::_cull_point(Octant *p_octant, const Vector3 &p_po
 			e->last_pass = pass;
 
 			if (e->aabb.has_point(p_point)) {
-
 				if (*p_result_idx < p_result_max) {
-
 					p_result_array[*p_result_idx] = e->userdata;
 					if (p_subindex_array)
 						p_subindex_array[*p_result_idx] = e->subindex;
@@ -1246,7 +1137,6 @@ void Octree<T, use_pairs, AL>::_cull_point(Octant *p_octant, const Vector3 &p_po
 					(*p_result_idx)++;
 
 				} else {
-
 					return; // pointless to continue
 				}
 			}
@@ -1254,7 +1144,6 @@ void Octree<T, use_pairs, AL>::_cull_point(Octant *p_octant, const Vector3 &p_po
 	}
 
 	for (int i = 0; i < 8; i++) {
-
 		//could be optimized..
 		if (p_octant->children[i] && p_octant->children[i]->aabb.has_point(p_point)) {
 			_cull_point(p_octant->children[i], p_point, p_result_array, p_result_idx, p_result_max, p_subindex_array, p_mask);
@@ -1264,7 +1153,6 @@ void Octree<T, use_pairs, AL>::_cull_point(Octant *p_octant, const Vector3 &p_po
 
 template <class T, bool use_pairs, class AL>
 int Octree<T, use_pairs, AL>::cull_convex(const Vector<Plane> &p_convex, T **p_result_array, int p_result_max, uint32_t p_mask) {
-
 	if (!root || p_convex.size() == 0)
 		return 0;
 
@@ -1291,7 +1179,6 @@ int Octree<T, use_pairs, AL>::cull_convex(const Vector<Plane> &p_convex, T **p_r
 
 template <class T, bool use_pairs, class AL>
 int Octree<T, use_pairs, AL>::cull_aabb(const AABB &p_aabb, T **p_result_array, int p_result_max, int *p_subindex_array, uint32_t p_mask) {
-
 	if (!root)
 		return 0;
 
@@ -1304,7 +1191,6 @@ int Octree<T, use_pairs, AL>::cull_aabb(const AABB &p_aabb, T **p_result_array,
 
 template <class T, bool use_pairs, class AL>
 int Octree<T, use_pairs, AL>::cull_segment(const Vector3 &p_from, const Vector3 &p_to, T **p_result_array, int p_result_max, int *p_subindex_array, uint32_t p_mask) {
-
 	if (!root)
 		return 0;
 
@@ -1317,7 +1203,6 @@ int Octree<T, use_pairs, AL>::cull_segment(const Vector3 &p_from, const Vector3
 
 template <class T, bool use_pairs, class AL>
 int Octree<T, use_pairs, AL>::cull_point(const Vector3 &p_point, T **p_result_array, int p_result_max, int *p_subindex_array, uint32_t p_mask) {
-
 	if (!root)
 		return 0;
 
@@ -1330,20 +1215,17 @@ int Octree<T, use_pairs, AL>::cull_point(const Vector3 &p_point, T **p_result_ar
 
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::set_pair_callback(PairCallback p_callback, void *p_userdata) {
-
 	pair_callback = p_callback;
 	pair_callback_userdata = p_userdata;
 }
 template <class T, bool use_pairs, class AL>
 void Octree<T, use_pairs, AL>::set_unpair_callback(UnpairCallback p_callback, void *p_userdata) {
-
 	unpair_callback = p_callback;
 	unpair_callback_userdata = p_userdata;
 }
 
 template <class T, bool use_pairs, class AL>
 Octree<T, use_pairs, AL>::Octree(real_t p_unit_size) {
-
 	last_element_id = 1;
 	pass = 1;
 	unit_size = p_unit_size;