remove trailing whitespace

116 files changed, 2949 insertions, 2949 deletions

diff --git a/core/color.cpp b/core/color.cpp
index 56a550c024..bf9c94462f 100644
--- a/core/color.cpp
+++ b/core/color.cpp
@@ -75,11 +75,11 @@ float Color::get_h() const {
 		h = 2 + ( b - r ) / delta;	// between cyan & yellow
 	else
 		h = 4 + ( r - g ) / delta;	// between magenta & cyan
-	
+
 	h/=6.0;
 	if (h<0)
 		h+=1.0;
-		
+
 	return h;
 }
 
@@ -119,7 +119,7 @@ void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha) {
 	p_h *=6.0;
 	p_h = Math::fmod(p_h,6);
 	i = Math::floor( p_h );
-	
+
 	f = p_h - i;
 	p = p_v * ( 1 - p_s );
 	q = p_v * ( 1 - p_s * f );
@@ -136,7 +136,7 @@ void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha) {
 			g = p_v;
 			b = p;
 			break;
-		case 2: 
+		case 2:
 			r = p;
 			g = p_v;
 			b = t;
@@ -162,8 +162,8 @@ void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha) {
 void Color::invert() {
 
 	r=1.0-r;
-	g=1.0-g;	
-	b=1.0-b;	
+	g=1.0-g;
+	b=1.0-b;
 }
 void Color::contrast() {
 
@@ -368,7 +368,7 @@ String Color::to_html(bool p_alpha) const {
 
 float Color::gray() const {
 
-	return (r+g+b)/3.0;	
+	return (r+g+b)/3.0;
 }
 
 Color::operator String() const {
diff --git a/core/color.h b/core/color.h
index d0a1e8835c..5b671d5f62 100644
--- a/core/color.h
+++ b/core/color.h
@@ -37,13 +37,13 @@
 struct Color {
 
 	union {
-	
+
 		struct {
 			float r;
 			float g;
 			float b;
 			float a;
-		};		
+		};
 		float components[4];
 	};
 
@@ -58,28 +58,28 @@ struct Color {
 	float get_v() const;
 	void set_hsv(float p_h, float p_s, float p_v, float p_alpha=1.0);
 
-	_FORCE_INLINE_ float& operator[](int idx) { 
+	_FORCE_INLINE_ float& operator[](int idx) {
 		return components[idx];
 	}
-	_FORCE_INLINE_ const float& operator[](int idx) const { 
+	_FORCE_INLINE_ const float& operator[](int idx) const {
 		return components[idx];
 	}
-		
+
 	void invert();
 	void contrast();
 	Color inverted() const;
 	Color contrasted() const;
 
 	_FORCE_INLINE_ Color linear_interpolate(const Color& p_b, float p_t) const {
-	
+
 		Color res=*this;
-	
+
 		res.r+= (p_t * (p_b.r-r));
 		res.g+= (p_t * (p_b.g-g));
 		res.b+= (p_t * (p_b.b-b));
 		res.a+= (p_t * (p_b.a-a));
-	
-		return res;	
+
+		return res;
 	}
 
 	_FORCE_INLINE_ Color blend(const Color& p_over) const {
diff --git a/core/command_queue_mt.cpp b/core/command_queue_mt.cpp
index a2507b1378..acd3aeddfb 100644
--- a/core/command_queue_mt.cpp
+++ b/core/command_queue_mt.cpp
@@ -76,7 +76,7 @@ CommandQueueMT::SyncSemaphore* CommandQueueMT::_alloc_sync_sem() {
 CommandQueueMT::CommandQueueMT(bool p_sync){
 
 	read_ptr=0;
-	write_ptr=0;	
+	write_ptr=0;
 	mutex = Mutex::create();
 
 	for(int i=0;i<SYNC_SEMAPHORES;i++) {
diff --git a/core/command_queue_mt.h b/core/command_queue_mt.h
index 142668f6f6..b1e0066c35 100644
--- a/core/command_queue_mt.h
+++ b/core/command_queue_mt.h
@@ -47,69 +47,69 @@ class CommandQueueMT {
 	};
 
 	struct CommandBase {
-	
+
 		virtual void call()=0;
 		virtual ~CommandBase() {};
 	};
-	
+
 	template<class T,class M>
 	struct Command0 : public CommandBase {
 
 		T*instance;
 		M method;
-	
+
 		virtual void call() { (instance->*method)(); }
 	};
-	
+
 	template<class T,class M,class P1>
 	struct Command1 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
-	
+
 		virtual void call() { (instance->*method)(p1); }
 	};
-	
+
 	template<class T,class M,class P1,class P2>
 	struct Command2 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
 		typename GetSimpleTypeT<P2>::type_t p2;
-	
+
 		virtual void call() { (instance->*method)(p1,p2); }
 	};
 
 	template<class T,class M,class P1,class P2,class P3>
 	struct Command3 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
 		typename GetSimpleTypeT<P2>::type_t p2;
 		typename GetSimpleTypeT<P3>::type_t p3;
-	
+
 		virtual void call() { (instance->*method)(p1,p2,p3); }
 	};
 
 	template<class T,class M,class P1,class P2,class P3,class P4>
 	struct Command4 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
 		typename GetSimpleTypeT<P2>::type_t p2;
 		typename GetSimpleTypeT<P3>::type_t p3;
 		typename GetSimpleTypeT<P4>::type_t p4;
-	
+
 		virtual void call() { (instance->*method)(p1,p2,p3,p4); }
 	};
 
 	template<class T,class M,class P1,class P2,class P3,class P4,class P5>
 	struct Command5 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -117,13 +117,13 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P3>::type_t p3;
 		typename GetSimpleTypeT<P4>::type_t p4;
 		typename GetSimpleTypeT<P5>::type_t p5;
-	
+
 		virtual void call() { (instance->*method)(p1,p2,p3,p4,p5); }
 	};
 
 	template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6>
 	struct Command6 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -132,13 +132,13 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P4>::type_t p4;
 		typename GetSimpleTypeT<P5>::type_t p5;
 		typename GetSimpleTypeT<P6>::type_t p6;
-	
+
 		virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6); }
 	};
-	
+
 	template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
 	struct Command7 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -148,12 +148,12 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P5>::type_t p5;
 		typename GetSimpleTypeT<P6>::type_t p6;
 		typename GetSimpleTypeT<P7>::type_t p7;
-	
+
 		virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6,p7); }
 	};
-		
+
 	/* comands that return */
-	
+
 	template<class T,class M,class R>
 	struct CommandRet0 : public CommandBase {
 
@@ -161,38 +161,38 @@ class CommandQueueMT {
 		M method;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(); sync->sem->post(); sync->in_use=false; ; }
 	};
-	
+
 	template<class T,class M,class P1,class R>
 	struct CommandRet1 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(p1); sync->sem->post(); sync->in_use=false; }
 	};
-	
+
 	template<class T,class M,class P1,class P2,class R>
 	struct CommandRet2 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
 		typename GetSimpleTypeT<P2>::type_t p2;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(p1,p2); sync->sem->post(); sync->in_use=false; ; }
 	};
 
 	template<class T,class M,class P1,class P2,class P3,class R>
 	struct CommandRet3 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -200,13 +200,13 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P3>::type_t p3;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(p1,p2,p3); sync->sem->post(); sync->in_use=false; ; }
 	};
 
 	template<class T,class M,class P1,class P2,class P3,class P4,class R>
 	struct CommandRet4 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -215,13 +215,13 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P4>::type_t p4;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4); sync->sem->post(); sync->in_use=false; ; }
 	};
 
 	template<class T,class M,class P1,class P2,class P3,class P4,class P5,class R>
 	struct CommandRet5 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -231,13 +231,13 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P5>::type_t p5;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4,p5); sync->sem->post(); sync->in_use=false; ; }
 	};
 
 	template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class R>
 	struct CommandRet6 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -248,13 +248,13 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P6>::type_t p6;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4,p5,p6); sync->sem->post(); sync->in_use=false; ; }
-	};	
+	};
 
 	template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class R>
 	struct CommandRet7 : public CommandBase {
-	
+
 		T*instance;
 		M method;
 		typename GetSimpleTypeT<P1>::type_t p1;
@@ -266,9 +266,9 @@ class CommandQueueMT {
 		typename GetSimpleTypeT<P7>::type_t p7;
 		R* ret;
 		SyncSemaphore *sync;
-	
+
 		virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4,p5,p6,p7); sync->sem->post(); sync->in_use=false; ; }
-	};	
+	};
 
 	/** commands that don't return but sync */
 
@@ -392,7 +392,7 @@ class CommandQueueMT {
 
 	/***** BASE *******/
 
-	enum {	
+	enum {
 		COMMAND_MEM_SIZE_KB=256,
 		COMMAND_MEM_SIZE=COMMAND_MEM_SIZE_KB*1024,
 		SYNC_SEMAPHORES=8
@@ -405,30 +405,30 @@ class CommandQueueMT {
 	SyncSemaphore sync_sems[SYNC_SEMAPHORES];
 	Mutex *mutex;
 	Semaphore *sync;
-	
-	
+
+
 	template<class T>
 	T* allocate() {
-	
+
 		// alloc size is size+T+safeguard
 		uint32_t alloc_size=sizeof(T)+sizeof(uint32_t);
-		
+
 		tryagain:
-		
+
 		if (write_ptr < read_ptr) {
 			// behind read_ptr, check that there is room
 			if ( (read_ptr-write_ptr) <= alloc_size )
 				return NULL;
 		} else if (write_ptr >= read_ptr) {
 			// ahead of read_ptr, check that there is room
-			
-			
+
+
 			if ( (COMMAND_MEM_SIZE-write_ptr) < alloc_size+4 ) {
 				// no room at the end, wrap down;
-				
+
 				if (read_ptr==0) // dont want write_ptr to become read_ptr
 					return NULL;
-					
+
 				// if this happens, it's a bug
 				ERR_FAIL_COND_V( (COMMAND_MEM_SIZE-write_ptr) < sizeof(uint32_t), NULL );
 				// zero means, wrap to begining
@@ -447,147 +447,147 @@ class CommandQueueMT {
 		T* cmd = memnew_placement( &command_mem[write_ptr], T );
 		write_ptr+=sizeof(T);
 		return cmd;
-	
+
 	}
-	
+
 	template<class T>
 	T* allocate_and_lock() {
-	
+
 		lock();
 		T* ret;
-		
+
 		while ( (ret=allocate<T>())==NULL ) {
-		
+
 			unlock();
-			// sleep a little until fetch happened and some room is made			
+			// sleep a little until fetch happened and some room is made
 			wait_for_flush();
 			lock();
-			
+
 		}
-				
+
 		return ret;
 	}
-	
-	
+
+
 	bool flush_one() {
-	
+
 		tryagain:
-		
+
 		// tried to read an empty queue
 		if (read_ptr == write_ptr )
 			return false;
-		
+
 		uint32_t size = *(uint32_t*)( &command_mem[read_ptr] );
-		
+
 		if (size==0) {
 			//end of ringbuffer, wrap
 			read_ptr=0;
 			goto tryagain;
 		}
-		
+
 		read_ptr+=sizeof(uint32_t);
-		
+
 		CommandBase *cmd = reinterpret_cast<CommandBase*>( &command_mem[read_ptr] );
-		
+
 		cmd->call();
 		cmd->~CommandBase();
-		
-		read_ptr+=size;		
+
+		read_ptr+=size;
 
 		return true;
 	}
-	
-	
+
+
 	void lock();
 	void unlock();
 	void wait_for_flush();
 	SyncSemaphore* _alloc_sync_sem();
-	
-	
+
+
 public:
 
 	/* NORMAL PUSH COMMANDS */
-	
+
 	template<class T, class M>
 	void push( T * p_instance, M p_method ) {
-	
+
 		Command0<T,M> * cmd = allocate_and_lock< Command0<T,M> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 
 	template<class T, class M, class P1>
 	void push( T * p_instance, M p_method, P1 p1 ) {
-	
+
 		Command1<T,M,P1> * cmd = allocate_and_lock< Command1<T,M,P1> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 
 	template<class T, class M, class P1, class P2>
 	void push( T * p_instance, M p_method, P1 p1, P2 p2 ) {
-	
+
 		Command2<T,M,P1,P2> * cmd = allocate_and_lock< Command2<T,M,P1,P2> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
 		cmd->p2=p2;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 
 	template<class T, class M, class P1, class P2, class P3>
 	void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3 ) {
-	
+
 		Command3<T,M,P1,P2,P3> * cmd = allocate_and_lock< Command3<T,M,P1,P2,P3> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
 		cmd->p2=p2;
 		cmd->p3=p3;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 
 	template<class T, class M, class P1, class P2, class P3, class P4>
 	void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4 ) {
-	
+
 		Command4<T,M,P1,P2,P3,P4> * cmd = allocate_and_lock< Command4<T,M,P1,P2,P3,P4> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
 		cmd->p2=p2;
 		cmd->p3=p3;
 		cmd->p4=p4;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 
 	template<class T, class M, class P1, class P2, class P3, class P4, class P5>
 	void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) {
-	
+
 		Command5<T,M,P1,P2,P3,P4,P5> * cmd = allocate_and_lock< Command5<T,M,P1,P2,P3,P4,P5> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -595,17 +595,17 @@ public:
 		cmd->p3=p3;
 		cmd->p4=p4;
 		cmd->p5=p5;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 
 	template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6>
 	void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 ) {
-	
+
 		Command6<T,M,P1,P2,P3,P4,P5,P6> * cmd = allocate_and_lock< Command6<T,M,P1,P2,P3,P4,P5,P6> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -614,17 +614,17 @@ public:
 		cmd->p4=p4;
 		cmd->p5=p5;
 		cmd->p6=p6;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 
 	template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
 	void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 ) {
-	
+
 		Command7<T,M,P1,P2,P3,P4,P5,P6,P7> * cmd = allocate_and_lock< Command7<T,M,P1,P2,P3,P4,P5,P6,P7> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -634,19 +634,19 @@ public:
 		cmd->p5=p5;
 		cmd->p6=p6;
 		cmd->p7=p7;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 	}
 	/*** PUSH AND RET COMMANDS ***/
-	
-	
+
+
 	template<class T, class M,class R>
 	void push_and_ret( T * p_instance, M p_method, R* r_ret) {
-	
+
 		CommandRet0<T,M,R> * cmd = allocate_and_lock< CommandRet0<T,M,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->ret=r_ret;
@@ -654,34 +654,34 @@ public:
 		cmd->sync=ss;
 
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
 
 	template<class T, class M, class P1,class R>
 	void push_and_ret( T * p_instance, M p_method, P1 p1, R* r_ret) {
-	
+
 		CommandRet1<T,M,P1,R> * cmd = allocate_and_lock< CommandRet1<T,M,P1,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
 		cmd->ret=r_ret;
 		SyncSemaphore *ss=_alloc_sync_sem();
 		cmd->sync=ss;
-		
+
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
 
 	template<class T, class M, class P1, class P2,class R>
 	void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, R* r_ret) {
-	
+
 		CommandRet2<T,M,P1,P2,R> * cmd = allocate_and_lock< CommandRet2<T,M,P1,P2,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -691,16 +691,16 @@ public:
 		cmd->sync=ss;
 
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
 
 	template<class T, class M, class P1, class P2, class P3,class R>
 	void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, R* r_ret ) {
-	
+
 		CommandRet3<T,M,P1,P2,P3,R> * cmd = allocate_and_lock< CommandRet3<T,M,P1,P2,P3,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -711,16 +711,16 @@ public:
 		cmd->sync=ss;
 
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
 
 	template<class T, class M, class P1, class P2, class P3, class P4,class R>
 	void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, R* r_ret ) {
-	
+
 		CommandRet4<T,M,P1,P2,P3,P4,R> * cmd = allocate_and_lock< CommandRet4<T,M,P1,P2,P3,P4,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -732,16 +732,16 @@ public:
 		cmd->sync=ss;
 
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
 
 	template<class T, class M, class P1, class P2, class P3, class P4, class P5,class R>
 	void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, R* r_ret ) {
-	
+
 		CommandRet5<T,M,P1,P2,P3,P4,P5,R> * cmd = allocate_and_lock< CommandRet5<T,M,P1,P2,P3,P4,P5,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -754,16 +754,16 @@ public:
 		cmd->sync=ss;
 
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
 
 	template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6,class R>
 	void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, R* r_ret ) {
-	
+
 		CommandRet6<T,M,P1,P2,P3,P4,P5,P6,R> * cmd = allocate_and_lock< CommandRet6<T,M,P1,P2,P3,P4,P5,P6,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -777,16 +777,16 @@ public:
 		cmd->sync=ss;
 
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
-	
+
 	template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6,class P7,class R>
 	void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,P7 p7, R* r_ret ) {
-	
+
 		CommandRet7<T,M,P1,P2,P3,P4,P5,P6,P7,R> * cmd = allocate_and_lock< CommandRet7<T,M,P1,P2,P3,P4,P5,P6,P7,R> >();
-		
+
 		cmd->instance=p_instance;
 		cmd->method=p_method;
 		cmd->p1=p1;
@@ -801,7 +801,7 @@ public:
 		cmd->sync=ss;
 
 		unlock();
-		
+
 		if (sync) sync->post();
 		ss->sem->wait();
 	}
@@ -975,12 +975,12 @@ public:
 		ERR_FAIL_COND(!sync);
 		sync->wait();
 		lock();
-		flush_one();		
+		flush_one();
 		unlock();
 	}
-	
+
 	void flush_all() {
-			
+
 		//ERR_FAIL_COND(sync);
 		lock();
 		while (true) {
@@ -990,10 +990,10 @@ public:
 		}
 		unlock();
 	}
-	
+
 	CommandQueueMT(bool p_sync);
 	~CommandQueueMT();
-	
+
 };
 
 #endif
diff --git a/core/dvector.h b/core/dvector.h
index 17431b33a6..fbb1fc4824 100644
--- a/core/dvector.h
+++ b/core/dvector.h
@@ -43,18 +43,18 @@ template<class T>
 class DVector {
 
 	mutable MID mem;
-		
-		
+
+
 	void copy_on_write() {
-		
+
 		if (!mem.is_valid())
 			return;
 
 		if (dvector_lock)
 			dvector_lock->lock();
-					
+
 		MID_Lock lock( mem );
-		
+
 
 		if ( *(int*)lock.data()  == 1 ) {
 			// one reference, means no refcount changes
@@ -62,114 +62,114 @@ class DVector {
 				dvector_lock->unlock();
 			return;
 		}
-		
+
 		MID new_mem= dynalloc( mem.get_size() );
-		
+
 		if (!new_mem.is_valid()) {
-		
+
 			if (dvector_lock)
 				dvector_lock->unlock();
-			ERR_FAIL_COND( new_mem.is_valid() ); // out of memory		
+			ERR_FAIL_COND( new_mem.is_valid() ); // out of memory
 		}
-		
+
 		MID_Lock dst_lock( new_mem );
-		
+
 		int *rc = (int*)dst_lock.data();
-		
+
 		*rc=1;
-		
+
 		T * dst = (T*)(rc + 1 );
-		
+
 		T * src =(T*) ((int*)lock.data() + 1 );
-		
+
 		int count = (mem.get_size() - sizeof(int)) / sizeof(T);
-		
+
 		for (int i=0;i<count;i++) {
-		
+
 			memnew_placement( &dst[i], T(src[i]) );
 		}
-		
+
 		(*(int*)lock.data())--;
-		
+
 		// unlock all
 		dst_lock=MID_Lock();
 		lock=MID_Lock();
-		
+
 		mem=new_mem;
-				
+
 		if (dvector_lock)
 			dvector_lock->unlock();
-				
+
 	}
-	
+
 	void reference( const DVector& p_dvector ) {
-	
+
 		unreference();
-				
+
 		if (dvector_lock)
 			dvector_lock->lock();
-		
+
 		if (!p_dvector.mem.is_valid()) {
-		
+
 			if (dvector_lock)
 				dvector_lock->unlock();
-			return;			
+			return;
 		}
-		
+
 		MID_Lock lock(p_dvector.mem);
-		
+
 		int * rc = (int*)lock.data();
 		(*rc)++;
-		
+
 		lock = MID_Lock();
 		mem=p_dvector.mem;
-			
+
 		if (dvector_lock)
 			dvector_lock->unlock();
-			
+
 	}
-	
-	
+
+
 	void unreference() {
-	
+
 		if (dvector_lock)
 			dvector_lock->lock();
-		
+
 		if (!mem.is_valid()) {
-		
+
 			if (dvector_lock)
 				dvector_lock->unlock();
-			return;			
+			return;
 		}
-		
+
 		MID_Lock lock(mem);
-		
+
 		int * rc = (int*)lock.data();
 		(*rc)--;
-		
+
 		if (*rc==0) {
 			// no one else using it, destruct
-			
+
 			T * t= (T*)(rc+1);
 			int count = (mem.get_size() - sizeof(int)) / sizeof(T);
-			
+
 			for (int i=0;i<count;i++) {
-			
+
 				t[i].~T();
 			}
-						
+
 		}
-			
-		
+
+
 		lock = MID_Lock();
-		
+
 		mem = MID ();
-		
+
 		if (dvector_lock)
 			dvector_lock->unlock();
-					
+
 	}
-	
+
 public:
 
 	class Read {
@@ -177,10 +177,10 @@ public:
 		MID_Lock lock;
 		const T * mem;
 	public:
-	
+
 		_FORCE_INLINE_ const T& operator[](int p_index) const { return mem[p_index]; }
 		_FORCE_INLINE_ const T *ptr() const { return mem; }
-		
+
 		Read() { mem=NULL; }
 	};
 
@@ -189,32 +189,32 @@ public:
 		MID_Lock lock;
 		T * mem;
 	public:
-	
+
 		_FORCE_INLINE_ T& operator[](int p_index) { return mem[p_index]; }
 		_FORCE_INLINE_ T *ptr() { return mem; }
-		
+
 		Write() { mem=NULL; }
 	};
 
 
 	Read read() const {
-	
+
 		Read r;
-		if (mem.is_valid()) {		
+		if (mem.is_valid()) {
 			r.lock = MID_Lock( mem );
 			r.mem = (const T*)((int*)r.lock.data()+1);
 		}
-		return r;		
+		return r;
 	}
 	Write write() {
-	
+
 		Write w;
 		if (mem.is_valid()) {
 			copy_on_write();
 			w.lock = MID_Lock( mem );
 			w.mem = (T*)((int*)w.lock.data()+1);
 		}
-		return w;		
+		return w;
 	}
 
 	template<class MC>
@@ -280,12 +280,12 @@ public:
 
 
 	bool is_locked() const { return mem.is_locked(); }
-	
+
 	inline const T operator[](int p_index) const;
 
 	Error resize(int p_size);
-	
-	
+
+
 	void operator=(const DVector& p_dvector) { reference(p_dvector); }
 	DVector() {}
 	DVector(const DVector& p_dvector) { reference(p_dvector); }
@@ -308,7 +308,7 @@ T DVector<T>::get(int p_index) const {
 template<class T>
 void DVector<T>::set(int p_index, const T& p_val) {
 
-	if (p_index<0 || p_index>=size()) {		
+	if (p_index<0 || p_index>=size()) {
 		ERR_FAIL_COND(p_index<0 || p_index>=size());
 	}
 
@@ -332,7 +332,7 @@ const T DVector<T>::operator[](int p_index) const {
 	}
 
 	Read r = read();
-	
+
 	return r[p_index];
 }
 
@@ -344,83 +344,83 @@ Error DVector<T>::resize(int p_size) {
 		dvector_lock->lock();
 
 	bool same = p_size==size();
-	
+
 	if (dvector_lock)
 		dvector_lock->unlock();
-	// no further locking is necesary because we are supposed to own the only copy of this (using copy on write)	
-	
+	// no further locking is necesary because we are supposed to own the only copy of this (using copy on write)
+
 	if (same)
 		return OK;
 
 	if (p_size == 0 ) {
-	
+
 		unreference();
 		return OK;
 	}
 
 
 	copy_on_write(); // make it unique
-	
+
 	ERR_FAIL_COND_V( mem.is_locked(), ERR_LOCKED ); // if after copy on write, memory is locked, fail.
-	
+
 	if (p_size > size() ) {
-	
+
 		int oldsize=size();
-		
+
 		MID_Lock lock;
-		
+
 		if (oldsize==0) {
 
 			mem = dynalloc( p_size * sizeof(T) + sizeof(int) );
 			lock=MID_Lock(mem);
 			int *rc = ((int*)lock.data());
 			*rc=1;
-			
+
 		} else {
 
 			if (dynrealloc( mem, p_size * sizeof(T) + sizeof(int) )!=OK ) {
-			
+
 				ERR_FAIL_V(ERR_OUT_OF_MEMORY); // out of memory
 			}
-			
-			lock=MID_Lock(mem);			
+
+			lock=MID_Lock(mem);
 		}
-	
-	
-		
-		
+
+
+
+
 		T *t = (T*)((int*)lock.data() + 1);
-		
+
 		for (int i=oldsize;i<p_size;i++) {
-		
+
 			memnew_placement(&t[i], T );
 		}
-		
+
 		lock = MID_Lock(); // clear
 	} else {
-	
+
 		int oldsize=size();
-	
+
 		MID_Lock lock(mem);
-		
-		
+
+
 		T *t = (T*)((int*)lock.data() + 1);
-		
+
 		for (int i=p_size;i<oldsize;i++) {
-		
+
 			t[i].~T();
 		}
-		
+
 		lock = MID_Lock(); // clear
-	
+
 		if (dynrealloc( mem, p_size * sizeof(T) + sizeof(int) )!=OK ) {
-	
-			ERR_FAIL_V(ERR_OUT_OF_MEMORY); // wtf error		
+
+			ERR_FAIL_V(ERR_OUT_OF_MEMORY); // wtf error
 		}
-		
-		
+
+
 	}
-	
+
 	return OK;
 }
 
diff --git a/core/error_macros.h b/core/error_macros.h
index 47b1de5df3..6d931e899e 100644
--- a/core/error_macros.h
+++ b/core/error_macros.h
@@ -33,12 +33,12 @@
 /**
  * Error macros. Unlike exceptions and asserts, these macros try to mantain consistency and stability
  * inside the code. It is recommended to always return processable data, so in case of an error, the
- * engine can stay working well. 
+ * engine can stay working well.
  * In most cases, bugs and/or invalid data are not fatal and should never allow a perfectly running application
  * to fail or crash.
  */
 
-/** 
+/**
  * Pointer to the error macro priting function. Reassign to any function to have errors printed
  */
 
@@ -136,7 +136,7 @@ extern bool _err_error_exists;
 		return m_retval;	 \
 	}else _err_error_exists=false; }	\
 
-/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert(). 
+/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert().
  * the function will exit.
  */
 
@@ -146,7 +146,7 @@ extern bool _err_error_exists;
 		return;	 \
 	}else _err_error_exists=false; }	\
 
-/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert(). 
+/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert().
  * the function will exit.
  * This function returns an error value, if returning Error, please select the most
  * appropriate error condition from error_macros.h
@@ -158,7 +158,7 @@ extern bool _err_error_exists;
 		return m_retval;	 \
 	}else _err_error_exists=false; }	\
 
-/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert(). 
+/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert().
  * the loop will skip to the next iteration.
  */
 
@@ -168,7 +168,7 @@ extern bool _err_error_exists;
 		continue;\
 	} else _err_error_exists=false;}	\
 
-/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert(). 
+/** An error condition happened (m_cond tested true) (WARNING this is the opposite as assert().
  * the loop will break
  */
 
diff --git a/core/event_queue.cpp b/core/event_queue.cpp
index 088e80b266..53638c5431 100644
--- a/core/event_queue.cpp
+++ b/core/event_queue.cpp
@@ -43,118 +43,118 @@ Error EventQueue::push_call(uint32_t p_instance_ID, const StringName& p_method,
 		args=2;
 	else if (p_arg1.get_type()!=Variant::NIL)
 		args=1;
-	else 
+	else
 		args=0;
-		
+
 	room_needed+=sizeof(Variant)*args;
-		
+
 	ERR_FAIL_COND_V( (buffer_end+room_needed) >= buffer_size , ERR_OUT_OF_MEMORY );
 	Event * ev = memnew_placement( &event_buffer[ buffer_end ], Event );
 	ev->args=args;
 	ev->instance_ID=p_instance_ID;
 	ev->method=p_method;
-	
+
 	buffer_end+=sizeof(Event);
-	
+
 	if (args>=1) {
-	
+
 		Variant * v = memnew_placement( &event_buffer[ buffer_end ], Variant );
 		buffer_end+=sizeof(Variant);
 		*v=p_arg1;
 	}
 
 	if (args>=2) {
-	
+
 		Variant * v = memnew_placement( &event_buffer[ buffer_end ], Variant );
 		buffer_end+=sizeof(Variant);
 		*v=p_arg2;
 	}
 
 	if (args>=3) {
-	
+
 		Variant * v = memnew_placement( &event_buffer[ buffer_end ], Variant );
 		buffer_end+=sizeof(Variant);
 		*v=p_arg3;
-		
+
 	}
 
 	if (args>=4) {
-	
+
 		Variant * v = memnew_placement( &event_buffer[ buffer_end ], Variant );
 		buffer_end+=sizeof(Variant);
 		*v=p_arg4;
 	}
 
 	if (args>=5) {
-	
+
 		Variant * v = memnew_placement( &event_buffer[ buffer_end ], Variant );
 		buffer_end+=sizeof(Variant);
 		*v=p_arg5;
 	}
-	
+
 	if (buffer_max_used>buffer_end);
 		buffer_max_used=buffer_end;
-		
+
 	return OK;
 }
 
 void EventQueue::flush_events() {
 
 	uint32_t read_pos=0;
-	
+
 	while (read_pos < buffer_end ) {
-	
+
 		Event *event = (Event*)&event_buffer[ read_pos ];
 		Variant *args= (Variant*)(event+1);
 		Object *obj = ObjectDB::get_instance(event->instance_ID);
-					
-		if (obj) {		
+
+		if (obj) {
 			// events don't expect a return value
-			obj->call( event->method, 
+			obj->call( event->method,
 				(event->args>=1) ? args[0] : Variant(),
 				(event->args>=2) ? args[1] : Variant(),
 				(event->args>=3) ? args[2] : Variant(),
 				(event->args>=4) ? args[3] : Variant(),
 				(event->args>=5) ? args[4] : Variant() );
 		}
-		
+
 		if (event->args>=1) args[0].~Variant();
 		if (event->args>=2) args[1].~Variant();
 		if (event->args>=3) args[2].~Variant();
 		if (event->args>=4) args[3].~Variant();
 		if (event->args>=5) args[4].~Variant();
 		event->~Event();
-		
+
 		read_pos+=sizeof(Event)+sizeof(Variant)*event->args;
 	}
-	
+
 	buffer_end=0; // reset buffer
 }
 
 EventQueue::EventQueue(uint32_t p_buffer_size) {
 
-	
+
 	buffer_end=0;
 	buffer_max_used=0;
 	buffer_size=p_buffer_size;
 	event_buffer = memnew_arr( uint8_t, buffer_size );
-	
+
 }
 EventQueue::~EventQueue() {
 
 	uint32_t read_pos=0;
-	
+
 	while (read_pos < buffer_end ) {
-	
+
 		Event *event = (Event*)&event_buffer[ read_pos ];
 		Variant *args= (Variant*)(event+1);
 		for (int i=0;i<event->args;i++)
 			args[i].~Variant();
 		event->~Event();
-		
+
 		read_pos+=sizeof(Event)+sizeof(Variant)*event->args;
 	}
-	
+
 	memdelete_arr(event_buffer);
 	event_buffer=NULL;
 }
diff --git a/core/event_queue.h b/core/event_queue.h
index af0a4df2b8..99e853fd28 100644
--- a/core/event_queue.h
+++ b/core/event_queue.h
@@ -36,18 +36,18 @@
 class EventQueue {
 
 	enum {
-	
+
 		DEFAULT_EVENT_QUEUE_SIZE_KB=256
 	};
 
 	struct Event {
-	
+
 		uint32_t instance_ID;
 		StringName method;
 		int args;
 	};
-	
-	
+
+
 	uint8_t *event_buffer;
 	uint32_t buffer_end;
 	uint32_t buffer_max_used;
@@ -57,7 +57,7 @@ public:
 
 	Error push_call(uint32_t p_instance_ID, const StringName& p_method, VARIANT_ARG_LIST);
 	void flush_events();
-	
+
 	EventQueue(uint32_t p_buffer_size=DEFAULT_EVENT_QUEUE_SIZE_KB*1024);
 	~EventQueue();
 
diff --git a/core/globals.cpp b/core/globals.cpp
index d63f9c1bb4..c0c1171ae6 100644
--- a/core/globals.cpp
+++ b/core/globals.cpp
@@ -40,7 +40,7 @@
 Globals *Globals::singleton=NULL;
 
 Globals *Globals::get_singleton() {
-	
+
 	return singleton;
 }
 
@@ -108,7 +108,7 @@ bool Globals::is_persisting(const String& p_name) const {
 
 
 String Globals::globalize_path(const String& p_path) const {
-	
+
 	if (p_path.begins_with("res://")) {
 
 		if (resource_path != "") {
@@ -125,7 +125,7 @@ String Globals::globalize_path(const String& p_path) const {
 bool Globals::_set(const StringName& p_name, const Variant& p_value) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	if (p_value.get_type()==Variant::NIL)
 		props.erase(p_name);
 	else {
@@ -174,7 +174,7 @@ bool Globals::_get(const StringName& p_name,Variant &r_ret) const {
 		return false;
 	r_ret=props[p_name].variant;
 	return true;
-	
+
 }
 
 struct _VCSort {
@@ -188,13 +188,13 @@ struct _VCSort {
 };
 
 void Globals::_get_property_list(List<PropertyInfo> *p_list) const {
-	
+
 	_THREAD_SAFE_METHOD_
 
 	Set<_VCSort> vclist;
-	
+
 	for(Map<StringName,VariantContainer>::Element *E=props.front();E;E=E->next()) {
-		
+
 		const VariantContainer *v=&E->get();
 
 		if (v->hide_from_editor)
@@ -250,7 +250,7 @@ bool Globals::_load_resource_pack(const String& p_pack) {
 Error Globals::setup(const String& p_path,const String & p_main_pack) {
 
 	//an absolute mess of a function, must be cleaned up and reorganized somehow at some point
-	
+
 	//_load_settings(p_path+"/override.cfg");
 
 	if (p_main_pack!="") {
@@ -292,7 +292,7 @@ Error Globals::setup(const String& p_path,const String & p_main_pack) {
 		}
 
 	}
-	
+
 
 	if (FileAccessNetworkClient::get_singleton()) {
 
@@ -332,7 +332,7 @@ Error Globals::setup(const String& p_path,const String & p_main_pack) {
 		resource_path = p_path;
 
 	} else {
-	
+
 		d->change_dir(p_path);
 
 		String candidate = d->get_current_dir();
@@ -395,7 +395,7 @@ Error Globals::setup(const String& p_path,const String & p_main_pack) {
 }
 
 bool Globals::has(String p_var) const {
-	
+
 	_THREAD_SAFE_METHOD_
 
 	return props.has(p_var);
@@ -1410,7 +1410,7 @@ void Globals::_bind_methods() {
 }
 
 Globals::Globals() {
-	
+
 
 	singleton=this;
 	last_order=0;
@@ -1531,7 +1531,7 @@ Globals::Globals() {
 
 
 Globals::~Globals() {
-	
+
 	singleton=NULL;
 }
 
diff --git a/core/globals.h b/core/globals.h
index 8951f5fbd2..68bb859ace 100644
--- a/core/globals.h
+++ b/core/globals.h
@@ -38,7 +38,7 @@
 
 
 class Globals : public Object {
-	
+
 	OBJ_TYPE( Globals, Object );
 	_THREAD_SAFE_CLASS_
 
@@ -77,13 +77,13 @@ protected:
 	bool using_datapack;
 	List<String> input_presets;
 
-	
+
 	bool _set(const StringName& p_name, const Variant& p_value);
 	bool _get(const StringName& p_name,Variant &r_ret) const;
 	void _get_property_list(List<PropertyInfo> *p_list) const;
-	
+
 	static Globals *singleton;
-	
+
 	Error _load_settings(const String p_path);
 	Error _load_settings_binary(const String p_path);
 
@@ -101,7 +101,7 @@ protected:
 	static void _bind_methods();
 public:
 
-	
+
 	bool has(String p_var) const;
 	String localize_path(const String& p_path) const;
 	String globalize_path(const String& p_path) const;
@@ -110,13 +110,13 @@ public:
 	bool is_persisting(const String& p_name) const;
 
 	String get_resource_path() const;
-	
+
 	static Globals *get_singleton();
 
 	void clear(const String& p_name);
 	int get_order(const String& p_name) const;
 	void set_order(const String& p_name, int p_order);
-	
+
 	Error setup(const String& p_path, const String &p_main_pack);
 
 	Error save_custom(const String& p_path="",const CustomMap& p_custom=CustomMap(),const Set<String>& p_ignore_masks=Set<String>());
@@ -141,7 +141,7 @@ public:
 
 	void set_registering_order(bool p_registering);
 
-	Globals();	
+	Globals();
 	~Globals();
 
 };
diff --git a/core/hash_map.h b/core/hash_map.h
index 33eb25652c..e83710c700 100644
--- a/core/hash_map.h
+++ b/core/hash_map.h
@@ -38,7 +38,7 @@
 
 class HashMapHahserDefault {
 public:
-	
+
 	static _FORCE_INLINE_ uint32_t hash(const String &p_string)  { return p_string.hash(); }
 	static _FORCE_INLINE_ uint32_t hash(const char *p_cstr)  { return hash_djb2(p_cstr); }
 	static _FORCE_INLINE_ uint32_t hash(const uint64_t p_int)  {
@@ -66,8 +66,8 @@ public:
 
 /**
  * @class HashMap
- * @author Juan Linietsky <reduzio@gmail.com> 
- * 
+ * @author Juan Linietsky <reduzio@gmail.com>
+ *
  * Implementation of a standard Hashing HashMap, for quick lookups of Data associated with a Key.
  * The implementation provides hashers for the default types, if you need a special kind of hasher, provide
  * your own.
@@ -77,213 +77,213 @@ public:
  * @param MIN_HASH_TABLE_POWER Miminum size of the hash table, as a power of two. You rarely need to change this parameter.
  * @param RELATIONSHIP Relationship at which the hash table is resized. if amount of elements is RELATIONSHIP
  * times bigger than the hash table, table is resized to solve this condition. if RELATIONSHIP is zero, table is always MIN_HASH_TABLE_POWER.
- * 
+ *
 */
 
 template<class TKey, class TData, class Hasher=HashMapHahserDefault,uint8_t MIN_HASH_TABLE_POWER=3,uint8_t RELATIONSHIP=8>
 class HashMap {
-public:	
-	
+public:
+
 	struct Pair {
-			
+
 		TKey key;
 		TData data;
-		
+
 		Pair() {}
 		Pair(const TKey& p_key, const TData& p_data) { key=p_key; data=p_data; }
 	};
-	
-		
-private:	
+
+
+private:
 	struct Entry {
-		
+
 		uint32_t hash;
 		Entry *next;
 		Pair pair;
-		
+
 		Entry() { next=0; }
 	};
-	
+
 	Entry **hash_table;
 	uint8_t hash_table_power;
 	uint32_t elements;
-	
+
 	void make_hash_table() {
-		
+
 		ERR_FAIL_COND( hash_table );
-		
-		
+
+
 		hash_table = memnew_arr( Entry*, (1<<MIN_HASH_TABLE_POWER) );
-		
+
 		hash_table_power = MIN_HASH_TABLE_POWER;
 		elements=0;
 		for (int i=0;i<(1<<MIN_HASH_TABLE_POWER);i++)
 			hash_table[i]=0;
 	}
-	
+
 	void erase_hash_table() {
-	
+
 		ERR_FAIL_COND(elements);
-		
+
 		memdelete_arr( hash_table );
 		hash_table=0;
-		hash_table_power=0;		
-		elements=0;	
-	}	
-	
+		hash_table_power=0;
+		elements=0;
+	}
+
 	void check_hash_table() {
 
 		int new_hash_table_power=-1;
-	
+
 		if ((int)elements > ( (1<<hash_table_power) * RELATIONSHIP ) ) {
 			/* rehash up */
 			new_hash_table_power=hash_table_power+1;
-		
+
 			while( (int)elements > ( (1<<new_hash_table_power) * RELATIONSHIP ) ) {
-		
+
 				new_hash_table_power++;
 			}
-	
+
 		} else if ( (hash_table_power>(int)MIN_HASH_TABLE_POWER) && ((int)elements < ( (1<<(hash_table_power-1)) * RELATIONSHIP )  )  ) {
-	
+
 			/* rehash down */
 			new_hash_table_power=hash_table_power-1;
-		
+
 			while( (int)elements < ( (1<<(new_hash_table_power-1)) * RELATIONSHIP ) ) {
-		
+
 				new_hash_table_power--;
 			}
-	
+
 			if (new_hash_table_power<(int)MIN_HASH_TABLE_POWER)
 				new_hash_table_power=MIN_HASH_TABLE_POWER;
 		}
-		
-		
+
+
 		if (new_hash_table_power==-1)
 			return;
-		
+
 		Entry ** new_hash_table = memnew_arr( Entry*, (1<<new_hash_table_power) );
 		if (!new_hash_table) {
-	
+
 			ERR_PRINT("Out of Memory");
 			return;
 		}
-	
+
 		for (int i=0;i<(1<<new_hash_table_power);i++) {
-	
+
 			new_hash_table[i]=0;
 		}
-	
+
 		for (int i=0;i<(1<<hash_table_power);i++) {
-	
+
 			while( hash_table[i] ) {
-		
+
 				Entry *se=hash_table[i];
 				hash_table[i]=se->next;
 				int new_pos = se->hash & ((1<<new_hash_table_power)-1);
 				se->next=new_hash_table[new_pos];
 				new_hash_table[new_pos]=se;
 			}
-		
+
 		}
-	
+
 		if (hash_table)
 			memdelete_arr( hash_table );
 		hash_table=new_hash_table;
-		hash_table_power=new_hash_table_power;	
+		hash_table_power=new_hash_table_power;
 
 	}
 
 
 	/* I want to have only one function.. */
 	_FORCE_INLINE_ const Entry * get_entry( const TKey& p_key ) const {
-		
+
 		uint32_t hash = Hasher::hash( p_key );
 		uint32_t index = hash&((1<<hash_table_power)-1);
-		
+
 		Entry *e = hash_table[index];
-		
+
 		while (e) {
-			
+
 			/* checking hash first avoids comparing key, which may take longer */
 			if (e->hash == hash && e->pair.key == p_key ) {
-				
+
 				/* the pair exists in this hashtable, so just update data */
 				return e;
 			}
-			
+
 			e=e->next;
 		}
-				
+
 		return NULL;
 	}
-	
+
 	Entry * create_entry(const TKey& p_key) {
-				
+
 		/* if entry doesn't exist, create it */
 		Entry *e = memnew( Entry );
 		ERR_FAIL_COND_V(!e,NULL); /* out of memory */
 		uint32_t hash = Hasher::hash( p_key );
 		uint32_t index = hash&((1<<hash_table_power)-1);
-		e->next = hash_table[index];	
+		e->next = hash_table[index];
 		e->hash = hash;
 		e->pair.key=p_key;
-				
+
 		hash_table[index]=e;
 		elements++;
-		
+
 		return e;
 	}
-	
-	
+
+
 	void copy_from(const HashMap& p_t) {
-		
+
 		if (&p_t==this)
 			return; /* much less bother with that */
-		
+
 		clear();
-		
+
 		if (!p_t.hash_table || p_t.hash_table_power==0)
 			return; /* not copying from empty table */
-		
+
 		hash_table = memnew_arr(Entry*,1<<p_t.hash_table_power);
 		hash_table_power=p_t.hash_table_power;
 		elements=p_t.elements;
-		
+
 		for (int i=0;i<( 1<<p_t.hash_table_power );i++) {
-			
+
 			hash_table[i]=NULL;
 			/* elements will be in the reverse order, but it doesn't matter */
-			
+
 			const Entry *e = p_t.hash_table[i];
-			
+
 			while(e) {
-				
+
 				Entry *le = memnew( Entry ); /* local entry */
-				
+
 				*le=*e; /* copy data */
-				
+
 				/* add to list and reassign pointers */
 				le->next=hash_table[i];
 				hash_table[i]=le;
-				
+
 				e=e->next;
 			}
-			
-			
+
+
 		}
-		
-		
+
+
 	}
 public:
-	
-	
+
+
 	void set( const TKey& p_key, const TData& p_data ) {
-	
+
 		set( Pair( p_key, p_data ) );
-		
+
 	}
-	
+
 	void set( const Pair& p_pair ) {
 
 		Entry *e=NULL;
@@ -291,63 +291,63 @@ public:
 			make_hash_table(); // if no table, make one
 		else
 			e = const_cast<Entry*>( get_entry(p_pair.key) );
-		
+
 		/* if we made it up to here, the pair doesn't exist, create and assign */
-		
+
 		if (!e) {
-			
+
 			e=create_entry(p_pair.key);
 			if (!e)
 				return;
 			check_hash_table(); // perform mantenience routine
 		}
-		
+
 		e->pair.data = p_pair.data;
-		
+
 	}
-	
-	
+
+
 	bool has( const TKey& p_key ) const {
-		
+
 		return getptr(p_key)!=NULL;
 	}
-	
+
 	/**
-	 * Get a key from data, return a const reference. 
+	 * Get a key from data, return a const reference.
 	 * WARNING: this doesn't check errors, use either getptr and check NULL, or check
 	 * first with has(key)
 	 */
-	
+
 	const TData& get( const TKey& p_key ) const {
-		
+
 		const TData* res = getptr(p_key);
 		ERR_FAIL_COND_V(!res,*res);
 		return *res;
 	}
-	
+
 	TData& get( const TKey& p_key )  {
-		
+
 		TData* res = getptr(p_key);
 		ERR_FAIL_COND_V(!res,*res);
 		return *res;
 	}
-	
+
 	/**
 	 * Same as get, except it can return NULL when item was not found.
 	 * This is mainly used for speed purposes.
 	 */
 
-	
+
 	_FORCE_INLINE_  TData* getptr( const TKey& p_key ) {
-		
+
 		if (!hash_table)
 			return NULL;
-		
+
 		Entry *e=const_cast<Entry*>(get_entry(p_key ));
-		
+
 		if (e)
 			return &e->pair.data;
-		
+
 		return NULL;
 
 	}
@@ -427,108 +427,108 @@ public:
 	/**
 	 * Erase an item, return true if erasing was succesful
 	 */
-	
+
 	bool erase( const TKey& p_key ) {
-		
+
 		if (!hash_table)
 			return false;
-		
+
 		uint32_t hash = Hasher::hash( p_key );
 		uint32_t index = hash&((1<<hash_table_power)-1);
-		
-		
+
+
 		Entry *e = hash_table[index];
 		Entry *p=NULL;
 		while (e) {
-			
+
 			/* checking hash first avoids comparing key, which may take longer */
 			if (e->hash == hash && e->pair.key == p_key ) {
-				
+
 				if (p) {
-					
+
 					p->next=e->next;
-				} else { 
+				} else {
 					//begin of list
 					hash_table[index]=e->next;
 				}
-				
+
 				memdelete(e);
 				elements--;
-				
+
 				if (elements==0)
 					erase_hash_table();
 				else
-					check_hash_table();		
+					check_hash_table();
 				return true;
 			}
-			
+
 			p=e;
 			e=e->next;
 		}
-		
-		
+
+
 		return false;
-		
+
 	}
-	
+
 	inline const TData& operator[](const TKey& p_key) const { //constref
-		
+
 		return get(p_key);
 	}
 	inline TData& operator[](const TKey& p_key ) { //assignment
-		
+
 		Entry *e=NULL;
 		if (!hash_table)
 			make_hash_table(); // if no table, make one
 		else
 			e = const_cast<Entry*>( get_entry(p_key) );
-		
+
 		/* if we made it up to here, the pair doesn't exist, create */
 		if (!e) {
-			
+
 			e=create_entry(p_key);
 			if (!e)
 				return *(TData*)NULL; /* panic! */
 			check_hash_table(); // perform mantenience routine
 		}
-		
+
 		return e->pair.data;
-		
+
 	}
-	
-	/** 
-	 * Get the next key to p_key, and the first key if p_key is null. 
+
+	/**
+	 * Get the next key to p_key, and the first key if p_key is null.
 	 * Returns a pointer to the next key if found, NULL otherwise.
 	 * Adding/Removing elements while iterating will, of course, have unexpected results, don't do it.
-	 * 
+	 *
 	 * Example:
-	 * 
+	 *
 	 * 	const TKey *k=NULL;
-	 * 
+	 *
 	 * 	while( (k=table.next(k)) ) {
-	 * 
+	 *
 	 * 		print( *k );
 	 * 	}
-         *	
+         *
 	*/
 	const TKey* next(const TKey* p_key) const {
-		
+
 		if (!hash_table) return NULL;
-		
+
 		if (!p_key) { /* get the first key */
-			
+
 			for (int i=0;i<(1<<hash_table_power);i++) {
-				
+
 				if (hash_table[i]) {
 					return &hash_table[i]->pair.key;
 				}
 			}
 
 		} else { /* get the next key */
-			
+
 			const Entry *e = get_entry( *p_key );
 			ERR_FAIL_COND_V( !e, NULL ); /* invalid key supplied */
-			
+
 			if (e->next) {
 				/* if there is a "next" in the list, return that */
 				return &e->next->pair.key;
@@ -537,60 +537,60 @@ public:
 				uint32_t index = e->hash&((1<<hash_table_power)-1);
 				index++;
 				for (int i=index;i<(1<<hash_table_power);i++) {
-				
+
 					if (hash_table[i]) {
 						return &hash_table[i]->pair.key;
 					}
 				}
 			}
-				
+
 			/* nothing found, was at end */
-			
+
 		}
-		
-		
+
+
 		return NULL; /* nothing found */
 	}
-	
+
 	inline unsigned int size() const {
-		
+
 		return elements;
 	}
-	
+
 	inline bool empty() const {
-		
+
 		return elements==0;
 	}
-	
+
 	void clear() {
-		
+
 		/* clean up */
 		if (hash_table) {
 			for (int i=0;i<(1<<hash_table_power);i++) {
-				
+
 				while (hash_table[i]) {
-								
+
 					Entry *e=hash_table[i];
 					hash_table[i]=e->next;
 					memdelete( e );
 				}
 			}
-		
+
 			memdelete_arr( hash_table );
 		}
-		
+
 		hash_table=0;
 		hash_table_power=0;
-		elements=0;		
+		elements=0;
 	}
-	
-	
+
+
 	void operator=(const HashMap& p_table) {
-		
+
 		copy_from(p_table);
 	}
-	
-	HashMap() { 
+
+	HashMap() {
 		hash_table=NULL;
 		elements=0;
 		hash_table_power=0;
@@ -609,18 +609,18 @@ public:
 		}
 	}
 
-	HashMap(const HashMap& p_table) { 
-	
+	HashMap(const HashMap& p_table) {
+
 		hash_table=NULL;
 		elements=0;
 		hash_table_power=0;
-		
+
 		copy_from(p_table);
-		
+
 	}
-	
+
 	~HashMap() {
-		
+
 		clear();
 	}
 
diff --git a/core/hashfuncs.h b/core/hashfuncs.h
index c2ed5bd679..a917ee5edb 100644
--- a/core/hashfuncs.h
+++ b/core/hashfuncs.h
@@ -47,10 +47,10 @@ static inline uint32_t hash_djb2(const char *p_cstr) {
 	const unsigned char* chr=(const unsigned char*)p_cstr;
 	uint32_t hash = 5381;
 	uint32_t c;
-	
+
 	while ((c = *chr++))
 		hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
-	
+
 	return hash;
 }
 
@@ -86,7 +86,7 @@ static inline uint32_t make_uint32_t(T p_in) {
 		T t;
 		uint32_t _u32;
 	} _u;
-	_u._u32=0;	
+	_u._u32=0;
 	_u.t=p_in;
 	return _u._u32;
 }
@@ -106,7 +106,7 @@ static inline uint64_t make_uint64_t(T p_in) {
 		uint64_t _u64;
 	} _u;
 	_u._u64=0; // in case p_in is smaller
-	
+
 	_u.t=p_in;
 	return _u._u64;
 }
diff --git a/core/image.cpp b/core/image.cpp
index 798fc41f40..184ab70dc4 100644
--- a/core/image.cpp
+++ b/core/image.cpp
@@ -382,7 +382,7 @@ void Image::convert( Format p_new_format ){
 
 
 	Image new_img(width,height,0,p_new_format);
-	
+
 	int len=data.size();
 
 	DVector<uint8_t>::Read r = data.read();
@@ -413,7 +413,7 @@ void Image::convert( Format p_new_format ){
 	w = DVector<uint8_t>::Write();
 
 	bool gen_mipmaps=mipmaps>0;
-			
+
 	*this=new_img;
 
 	if (gen_mipmaps)
@@ -643,13 +643,13 @@ void Image::resize( int p_width, int p_height, Interpolation p_interpolation ) {
 	ERR_FAIL_COND(p_height<=0);
 	ERR_FAIL_COND(p_width>MAX_WIDTH);
 	ERR_FAIL_COND(p_height>MAX_HEIGHT);
-	
+
 
 	if (p_width==width && p_height==height)
 		return;
-		
+
 	Image dst( p_width, p_height, 0, format );
-	 
+
 	if (format==FORMAT_INDEXED)
 		p_interpolation=INTERPOLATE_NEAREST;
 
@@ -714,34 +714,34 @@ void Image::crop( int p_width, int p_height ) {
 	ERR_FAIL_COND(p_height<=0);
 	ERR_FAIL_COND(p_width>MAX_WIDTH);
 	ERR_FAIL_COND(p_height>MAX_HEIGHT);
-	
+
 	/* to save memory, cropping should be done in-place, however, since this function
 	   will most likely either not be used much, or in critical areas, for now it wont, because
 	   it's a waste of time. */
 
 	if (p_width==width && p_height==height)
 		return;
-		
+
 	Image dst( p_width, p_height,0, format );
 
-	
+
 	for (int y=0;y<p_height;y++) {
-	
+
 		for (int x=0;x<p_width;x++) {
 
 			Color col = (x>=width || y>=height)? Color() : get_pixel(x,y);
 			dst.put_pixel(x,y,col);
 		}
 	}
-	
+
 	if (mipmaps>0)
 		dst.generate_mipmaps();
 	*this=dst;
-	
+
 }
 
 void Image::flip_y() {
-	
+
 	if (!_can_modify(format)) {
 		ERR_EXPLAIN("Cannot flip_y in indexed, compressed or custom image formats.");
 		ERR_FAIL();
@@ -756,12 +756,12 @@ void Image::flip_y() {
 
 
 	for (int y=0;y<(height/2);y++) {
-	
+
 		for (int x=0;x<width;x++) {
 
 			Color up = get_pixel(x,y);
 			Color down = get_pixel(x,height-y-1);
-			
+
 			put_pixel(x,y,down);
 			put_pixel(x,height-y-1,up);
 		}
@@ -783,12 +783,12 @@ void Image::flip_x() {
 		clear_mipmaps();;
 
 	for (int y=0;y<(height/2);y++) {
-		
+
 		for (int x=0;x<width;x++) {
-			
+
 			Color up = get_pixel(x,y);
 			Color down = get_pixel(width-x-1,y);
-			
+
 			put_pixel(x,y,down);
 			put_pixel(width-x-1,y,up);
 		}
@@ -1040,26 +1040,26 @@ void Image::make_normalmap(float p_height_scale) {
 	}
 
 	ERR_FAIL_COND( empty() );
-	
+
 	Image normalmap(width,height,0, FORMAT_RGB);
 	/*
 	for (int y=0;y<height;y++) {
 		for (int x=0;x<width;x++) {
-		
+
 			float center=get_pixel(x,y).gray()/255.0;
 			float up=(y>0)?get_pixel(x,y-1).gray()/255.0:center;
 			float down=(y<(height-1))?get_pixel(x,y+1).gray()/255.0:center;
 			float left=(x>0)?get_pixel(x-1,y).gray()/255.0:center;
 			float right=(x<(width-1))?get_pixel(x+1,y).gray()/255.0:center;
-		
-		
+
+
 			// uhm, how do i do this? ....
-			
+
 			Color result( (uint8_t)((normal.x+1.0)*127.0), (uint8_t)((normal.y+1.0)*127.0), (uint8_t)((normal.z+1.0)*127.0) );
-			
+
 			normalmap.put_pixel( x, y, result );
 		}
-		
+
 	}
 	*/
 	*this=normalmap;
@@ -1071,14 +1071,14 @@ bool Image::empty() const {
 }
 
 DVector<uint8_t> Image::get_data() const {
-	
+
 	return data;
 }
 
 void Image::create(int p_width, int p_height, bool p_use_mipmaps,Format p_format) {
 
 
-	int mm=0;	
+	int mm=0;
 	int size = _get_dst_image_size(p_width,p_height,p_format,mm,p_use_mipmaps?-1:0);
 	data.resize( size );
 	{
@@ -1095,7 +1095,7 @@ void Image::create(int p_width, int p_height, bool p_use_mipmaps,Format p_format
 }
 
 void Image::create(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t>& p_data) {
-	
+
 	ERR_FAIL_INDEX(p_width-1,MAX_WIDTH);
 	ERR_FAIL_INDEX(p_height-1,MAX_HEIGHT);
 
@@ -1108,48 +1108,48 @@ void Image::create(int p_width, int p_height, int p_mipmaps, Format p_format, co
 			ERR_FAIL_COND(p_data.size()!=size);
 		}
 	};
-	
+
 	height=p_height;
 	width=p_width;
 	format=p_format;
-	data=p_data;	
+	data=p_data;
 	mipmaps=p_mipmaps;
 }
 
 
 void Image::create( const char ** p_xpm ) {
-	
+
 
 	int size_width,size_height;
 	int pixelchars=0;
 	mipmaps=0;
 	bool has_alpha=false;
-	
+
 	enum Status {
 		READING_HEADER,
 		READING_COLORS,
 		READING_PIXELS,
 		DONE
 	};
-	
+
 	Status status = READING_HEADER;
 	int line=0;
-	
+
 	HashMap<String,Color> colormap;
 	int colormap_size;
-	
+
 	while (status!=DONE) {
-		
+
 		const char * line_ptr = p_xpm[line];
-		
-		
+
+
 		switch (status) {
-			
+
 		case READING_HEADER: {
-			
+
 			String line_str=line_ptr;
 			line_str.replace("\t"," ");
-			
+
 			size_width=line_str.get_slicec(' ',0).to_int();
 			size_height=line_str.get_slicec(' ',1).to_int();
 			colormap_size=line_str.get_slicec(' ',2).to_int();
@@ -1161,10 +1161,10 @@ void Image::create( const char ** p_xpm ) {
 			status=READING_COLORS;
 		} break;
 		case READING_COLORS: {
-			
+
 			String colorstring;
 			for (int i=0;i<pixelchars;i++) {
-				
+
 				colorstring+=*line_ptr;
 				line_ptr++;
 			}
@@ -1175,25 +1175,25 @@ void Image::create( const char ** p_xpm ) {
 				line_ptr++;
 			}
 			if (*line_ptr=='c') {
-				
+
 				line_ptr++;
 				while (*line_ptr==' ' ||  *line_ptr=='\t' || *line_ptr==0) {
 					if (*line_ptr==0)
 						break;
 					line_ptr++;
 				}
-				
+
 				if (*line_ptr=='#') {
 					line_ptr++;
 					uint8_t col_r;
 					uint8_t col_g;
 					uint8_t col_b;
 //					uint8_t col_a=255;
-					
+
 					for (int i=0;i<6;i++) {
-						
+
 						char v = line_ptr[i];
-						
+
 						if (v>='0' && v<='9')
 							v-='0';
 						else if (v>='A' && v<='F')
@@ -1202,7 +1202,7 @@ void Image::create( const char ** p_xpm ) {
 							v=(v-'a')+10;
 						else
 							break;
-						
+
 						switch(i) {
 						case 0: col_r=v<<4; break;
 						case 1: col_r|=v; break;
@@ -1211,48 +1211,48 @@ void Image::create( const char ** p_xpm ) {
 						case 4: col_b=v<<4; break;
 						case 5: col_b|=v; break;
 						};
-						
+
 					}
-					
+
 							// magenta mask
 					if (col_r==255 && col_g==0 && col_b==255) {
-						
+
 						colormap[colorstring]=Color(0,0,0,0);
 						has_alpha=true;
 					} else {
 
 						colormap[colorstring]=Color(col_r/255.0,col_g/255.0,col_b/255.0,1.0);
 					}
-					
+
 				}
 			}
 			if (line==colormap_size) {
-				
+
 				status=READING_PIXELS;
 				create(size_width,size_height,0,has_alpha?FORMAT_RGBA:FORMAT_RGB);
 			}
 		} break;
 		case READING_PIXELS: {
-			
+
 			int y=line-colormap_size-1;
 			for (int x=0;x<size_width;x++) {
-				
+
 				char pixelstr[6]={0,0,0,0,0,0};
 				for (int i=0;i<pixelchars;i++)
 					pixelstr[i]=line_ptr[x*pixelchars+i];
-				
+
 				Color *colorptr = colormap.getptr(pixelstr);
 				ERR_FAIL_COND(!colorptr);
 				put_pixel(x,y,*colorptr);
-				
+
 			}
-			
+
 			if (y==(size_height-1))
 				status=DONE;
 		} break;
 		default:{}
 		}
-		
+
 		line++;
 	}
 }
@@ -2022,7 +2022,7 @@ Image Image::compressed(int p_mode) {
 };
 
 Image::Image(const char **p_xpm) {
-	
+
 	width=0;
 	height=0;
 	mipmaps=0;
diff --git a/core/image.h b/core/image.h
index aea5dc6438..8f8fff755e 100644
--- a/core/image.h
+++ b/core/image.h
@@ -46,7 +46,7 @@ typedef Error (*SavePNGFunc)(const String &p_path, Image& p_img);
 
 class Image {
 
-	enum { 
+	enum {
 		MAX_WIDTH=16384, // force a limit somehow
 		MAX_HEIGHT=16384// force a limit somehow
 	};
@@ -55,12 +55,12 @@ public:
 	static SavePNGFunc save_png_func;
 
 	enum Format {
-		FORMAT_GRAYSCALE, ///< one byte per pixel, 0-255 
-		FORMAT_INTENSITY, ///< one byte per pixel, 0-255 
-		FORMAT_GRAYSCALE_ALPHA, ///< two bytes per pixel, 0-255. alpha 0-255 
-		FORMAT_RGB, ///< one byte R, one byte G, one byte B 
-		FORMAT_RGBA, ///< one byte R, one byte G, one byte B, one byte A 
-		FORMAT_INDEXED, ///< index byte 0-256, and after image end, 256*3 bytes of palette 
+		FORMAT_GRAYSCALE, ///< one byte per pixel, 0-255
+		FORMAT_INTENSITY, ///< one byte per pixel, 0-255
+		FORMAT_GRAYSCALE_ALPHA, ///< two bytes per pixel, 0-255. alpha 0-255
+		FORMAT_RGB, ///< one byte R, one byte G, one byte B
+		FORMAT_RGBA, ///< one byte R, one byte G, one byte B, one byte A
+		FORMAT_INDEXED, ///< index byte 0-256, and after image end, 256*3 bytes of palette
 		FORMAT_INDEXED_ALPHA, ///< index byte 0-256, and after image end, 256*4 bytes of palette (alpha)
 		FORMAT_YUV_422,
 		FORMAT_YUV_444,
@@ -89,7 +89,7 @@ public:
 
 	static const char* format_names[FORMAT_MAX];
 	enum Interpolation {
-	
+
 		INTERPOLATE_NEAREST,
 		INTERPOLATE_BILINEAR,
 		INTERPOLATE_CUBIC,
@@ -186,7 +186,7 @@ private:
 	DVector<uint8_t> data;
 	int width,height,mipmaps;
 
-	
+
 
 	_FORCE_INLINE_ BColor _get_pixel(int p_x,int p_y,const unsigned char *p_data,int p_data_size) const;
 	_FORCE_INLINE_ BColor _get_pixelw(int p_x,int p_y,int p_width,const unsigned char *p_data,int p_data_size) const;
@@ -207,7 +207,7 @@ public:
 	int get_width() const; ///< Get image width
 	int get_height() const; ///< Get image height
 	int get_mipmaps() const;
-	
+
 	/**
 	 * Get a pixel from the image. for grayscale or indexed formats, use Color::gray to obtain the actual
 	 * value.
@@ -217,7 +217,7 @@ public:
 	 * Set a pixel into the image. for grayscale or indexed formats, a suitable Color constructor.
 	 */
 	void put_pixel(int p_x,int p_y, const Color& p_color,int p_mipmap=0); /* alpha and index are averaged */
-	
+
 	/**
 	 * Convert the image to another format, as close as it can be done.
 	 */
@@ -230,7 +230,7 @@ public:
 		ret.convert((Format)p_new_format);
 		return ret;
 	};
-	
+
 	/**
 	 * Get the current image format.
 	 */
@@ -243,7 +243,7 @@ public:
 	/**
 	 * Resize the image, using the prefered interpolation method.
 	 * Indexed-Color images always use INTERPOLATE_NEAREST.
-	 */ 
+	 */
 
 	void resize_to_po2(bool p_square=false);
 	void resize( int p_width, int p_height, Interpolation p_interpolation=INTERPOLATE_BILINEAR );
@@ -252,22 +252,22 @@ public:
 	 * Crop the image to a specific size, if larger, then the image is filled by black
 	 */
 	void crop( int p_width, int p_height );
-	
-	
+
+
 	void flip_x();
 	void flip_y();
 	/**
-	 * Generate a mipmap to an image (creates an image 1/4 the size, with averaging of 4->1) 
+	 * Generate a mipmap to an image (creates an image 1/4 the size, with averaging of 4->1)
 	 */
 	Error generate_mipmaps(int p_amount=-1,bool p_keep_existing=false);
 
 	void clear_mipmaps();
 
-	
+
 	/**
 	 * Generate a normal map from a grayscale image
 	 */
-	 
+
 	void make_normalmap(float p_height_scale=1.0);
 
 	/**
@@ -276,26 +276,26 @@ public:
 	void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
 	void create(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t>& p_data);
 
-	void create( const char ** p_xpm );	
+	void create( const char ** p_xpm );
 	/**
 	 * returns true when the image is empty (0,0) in size
 	 */
 	bool empty() const;
-	
+
 	DVector<uint8_t> get_data() const;
-	
+
 	Error load(const String& p_path);
 	Error save_png(const String& p_path);
-	
-	/** 
+
+	/**
 	 * create an empty image
 	 */
 	Image();
-	/** 
+	/**
 	 * create an empty image of a specific size and format
 	 */
 	Image(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
-	/** 
+	/**
 	 * import an image of a specific size and format from a pointer
 	 */
 	Image(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t>& p_data);
@@ -313,7 +313,7 @@ public:
 	uint8_t get_indexed_pixel(int p_x, int p_y,int p_mipmap=0) const;
 	void set_pallete(const DVector<uint8_t>& p_data);
 
-	
+
 	static int get_format_pixel_size(Format p_format);
 	static int get_format_pixel_rshift(Format p_format);
 	static int get_format_pallete_size(Format p_format);
diff --git a/core/input_map.cpp b/core/input_map.cpp
index 874ce1c424..5a9b035771 100644
--- a/core/input_map.cpp
+++ b/core/input_map.cpp
@@ -38,7 +38,7 @@ void InputMap::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_action_from_id","id"),&InputMap::get_action_from_id);
 	ObjectTypeDB::bind_method(_MD("add_action","action"),&InputMap::add_action);
 	ObjectTypeDB::bind_method(_MD("erase_action","action"),&InputMap::erase_action);
-	
+
 	ObjectTypeDB::bind_method(_MD("action_add_event","action","event"),&InputMap::action_add_event);
 	ObjectTypeDB::bind_method(_MD("action_has_event","action","event"),&InputMap::action_has_event);
 	ObjectTypeDB::bind_method(_MD("action_erase_event","action","event"),&InputMap::action_erase_event);
diff --git a/core/io/aes256.h b/core/io/aes256.h
index fabbcf1968..8fcc25a4de 100644
--- a/core/io/aes256.h
+++ b/core/io/aes256.h
@@ -1,6 +1,6 @@
-/*  
+/*
 *   Byte-oriented AES-256 implementation.
-*   All lookup tables replaced with 'on the fly' calculations. 
+*   All lookup tables replaced with 'on the fly' calculations.
 *
 *   Copyright (c) 2007-2009 Ilya O. Levin, http://www.literatecode.com
 *   Other contributors: Hal Finney
@@ -24,14 +24,14 @@
 #include "typedefs.h"
 
 #ifdef __cplusplus
-extern "C" { 
+extern "C" {
 #endif
 
     typedef struct {
-        uint8_t key[32]; 
-        uint8_t enckey[32]; 
+        uint8_t key[32];
+        uint8_t enckey[32];
         uint8_t deckey[32];
-    } aes256_context; 
+    } aes256_context;
 
 
     void aes256_init(aes256_context *, uint8_t * /* key */);
diff --git a/core/io/fastlz.h b/core/io/fastlz.h
index f87bc7be31..e5ca8dfc02 100644
--- a/core/io/fastlz.h
+++ b/core/io/fastlz.h
@@ -1,4 +1,4 @@
-/*  
+/*
   FastLZ - lightning-fast lossless compression library
 
   Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
@@ -40,11 +40,11 @@ extern "C" {
 #endif
 
 /**
-  Compress a block of data in the input buffer and returns the size of 
-  compressed block. The size of input buffer is specified by length. The 
+  Compress a block of data in the input buffer and returns the size of
+  compressed block. The size of input buffer is specified by length. The
   minimum input buffer size is 16.
 
-  The output buffer must be at least 5% larger than the input buffer  
+  The output buffer must be at least 5% larger than the input buffer
   and can not be smaller than 66 bytes.
 
   If the input is not compressible, the return value might be larger than
@@ -56,9 +56,9 @@ extern "C" {
 int fastlz_compress(const void* input, int length, void* output);
 
 /**
-  Decompress a block of compressed data and returns the size of the 
-  decompressed block. If error occurs, e.g. the compressed data is 
-  corrupted or the output buffer is not large enough, then 0 (zero) 
+  Decompress a block of compressed data and returns the size of the
+  decompressed block. If error occurs, e.g. the compressed data is
+  corrupted or the output buffer is not large enough, then 0 (zero)
   will be returned instead.
 
   The input buffer and the output buffer can not overlap.
@@ -67,14 +67,14 @@ int fastlz_compress(const void* input, int length, void* output);
   more than what is specified in maxout.
  */
 
-int fastlz_decompress(const void* input, int length, void* output, int maxout); 
+int fastlz_decompress(const void* input, int length, void* output, int maxout);
 
 /**
-  Compress a block of data in the input buffer and returns the size of 
-  compressed block. The size of input buffer is specified by length. The 
+  Compress a block of data in the input buffer and returns the size of
+  compressed block. The size of input buffer is specified by length. The
   minimum input buffer size is 16.
 
-  The output buffer must be at least 5% larger than the input buffer  
+  The output buffer must be at least 5% larger than the input buffer
   and can not be smaller than 66 bytes.
 
   If the input is not compressible, the return value might be larger than
@@ -82,14 +82,14 @@ int fastlz_decompress(const void* input, int length, void* output, int maxout);
 
   The input buffer and the output buffer can not overlap.
 
-  Compression level can be specified in parameter level. At the moment, 
+  Compression level can be specified in parameter level. At the moment,
   only level 1 and level 2 are supported.
   Level 1 is the fastest compression and generally useful for short data.
   Level 2 is slightly slower but it gives better compression ratio.
 
   Note that the compressed data, regardless of the level, can always be
   decompressed using the function fastlz_decompress above.
-*/  
+*/
 
 int fastlz_compress_level(int level, const void* input, int length, void* output);
 
diff --git a/core/io/file_access_buffered.cpp b/core/io/file_access_buffered.cpp
index b38fda3686..e6b01475b6 100644
--- a/core/io/file_access_buffered.cpp
+++ b/core/io/file_access_buffered.cpp
@@ -33,17 +33,17 @@
 #include "error_macros.h"
 
 Error FileAccessBuffered::set_error(Error p_error) const {
-	
+
 	return (last_error = p_error);
 };
 
 void FileAccessBuffered::set_cache_size(int p_size) {
-	
+
 	cache_size = p_size;
 };
 
 int FileAccessBuffered::get_cache_size() {
-	
+
 	return cache_size;
 };
 
@@ -66,27 +66,27 @@ int FileAccessBuffered::cache_data_left() const {
 };
 
 void FileAccessBuffered::seek(size_t p_position) {
-	
+
 	file.offset = p_position;
 };
 
 void FileAccessBuffered::seek_end(int64_t p_position) {
-	
+
 	file.offset = file.size + p_position;
 };
 
 size_t FileAccessBuffered::get_pos() const {
-	
+
 	return file.offset;
 };
 
 size_t FileAccessBuffered::get_len() const {
-	
+
 	return file.size;
 };
 
 bool FileAccessBuffered::eof_reached() const {
-	
+
 	return file.offset > file.size;
 };
 
@@ -165,12 +165,12 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest,int p_elements) const {
 };
 
 bool FileAccessBuffered::is_open() const {
-	
+
 	return file.open;
 };
 
 Error FileAccessBuffered::get_error() const {
-	
+
 	return last_error;
 };
 
@@ -180,5 +180,5 @@ FileAccessBuffered::FileAccessBuffered() {
 };
 
 FileAccessBuffered::~FileAccessBuffered(){
-	
+
 }
diff --git a/core/io/file_access_buffered.h b/core/io/file_access_buffered.h
index 9d405e15f7..058c26b8a9 100644
--- a/core/io/file_access_buffered.h
+++ b/core/io/file_access_buffered.h
@@ -60,9 +60,9 @@ protected:
 		String name;
 		int access_flags;
 	} file;
-	
+
 	mutable struct Cache {
-		
+
 		Vector<uint8_t> buffer;
 		int offset;
 	} cache;
@@ -71,7 +71,7 @@ protected:
 
 	void set_cache_size(int p_size);
 	int get_cache_size();
-	
+
 public:
 
 	virtual size_t get_pos() const; ///< get position in the file
diff --git a/core/io/file_access_network.cpp b/core/io/file_access_network.cpp
index e63b57533f..a3c839e761 100644
--- a/core/io/file_access_network.cpp
+++ b/core/io/file_access_network.cpp
@@ -217,7 +217,7 @@ Error FileAccessNetworkClient::connect(const String& p_host,int p_port,const Str
 		return ERR_CANT_CONNECT;
 	}
 
-	CharString cs = p_password.utf8();	
+	CharString cs = p_password.utf8();
 	put_32(cs.length());
 	client->put_data((const uint8_t*)cs.ptr(),cs.length());
 
diff --git a/core/io/http_client.cpp b/core/io/http_client.cpp
index dd53c8f8eb..e0c01c9422 100644
--- a/core/io/http_client.cpp
+++ b/core/io/http_client.cpp
@@ -305,7 +305,7 @@ Error HTTPClient::poll(){
 						String header = responses[i].strip_edges();
 						String s = header.to_lower();
 						if (s.length()==0)
-							continue;						
+							continue;
 						if (s.begins_with("content-length:")) {
 							body_size = s.substr(s.find(":")+1,s.length()).strip_edges().to_int();
 							body_left=body_size;
diff --git a/core/io/image_loader.cpp b/core/io/image_loader.cpp
index aa641f00b4..05bad97e90 100644
--- a/core/io/image_loader.cpp
+++ b/core/io/image_loader.cpp
@@ -30,16 +30,16 @@
 
 #include "print_string.h"
 bool ImageFormatLoader::recognize(const String& p_extension) const {
-	
-	
+
+
 	List<String> extensions;
 	get_recognized_extensions(&extensions);
 	for (List<String>::Element *E=extensions.front();E;E=E->next()) {
-		
+
 		if (E->get().nocasecmp_to(p_extension.extension())==0)
 			return true;
 	}
-	
+
 	return false;
 }
 
@@ -55,12 +55,12 @@ Error ImageLoader::load_image(String p_file,Image *p_image, FileAccess *p_custom
 			return err;
 		}
 	}
-				
+
 	String extension = p_file.extension();
 
 
 	for (int i=0;i<loader_count;i++) {
-	
+
 		if (!loader[i]->recognize(extension))
 			continue;
 		Error err = loader[i]->load_image(p_image,f);
@@ -73,25 +73,25 @@ Error ImageLoader::load_image(String p_file,Image *p_image, FileAccess *p_custom
 
 			return err;
 		}
-			
-		
+
+
 	}
 	print_line("NO LOADER?");
 
 	if (!p_custom)
-		memdelete(f);	
-		
+		memdelete(f);
+
 	return ERR_FILE_UNRECOGNIZED;
 
 }
 
 void ImageLoader::get_recognized_extensions(List<String> *p_extensions) {
-	
+
 	for (int i=0;i<loader_count;i++) {
-		
+
 		loader[i]->get_recognized_extensions(p_extensions);
-				
-	}	
+
+	}
 }
 
 bool ImageLoader::recognize(const String& p_extension) {
diff --git a/core/io/image_loader.h b/core/io/image_loader.h
index 3cc6c6cf43..c799837792 100644
--- a/core/io/image_loader.h
+++ b/core/io/image_loader.h
@@ -41,11 +41,11 @@
 /**
  * @class ImageScanLineLoader
  * @author Juan Linietsky <reduzio@gmail.com>
- * 
- 
+ *
+
  */
 class ImageLoader;
- 
+
 
 /**
  * @class ImageLoader
@@ -60,8 +60,8 @@ protected:
 	virtual Error load_image(Image *p_image,FileAccess *p_fileaccess)=0;
 	virtual void get_recognized_extensions(List<String> *p_extensions) const=0;
 	bool recognize(const String& p_extension) const;
-	
-	
+
+
 public:
 	virtual ~ImageFormatLoader() {}
 };
@@ -79,11 +79,11 @@ protected:
 
 
 public:
-	
+
 	static Error load_image(String p_file,Image *p_image, FileAccess *p_custom=NULL);
 	static void get_recognized_extensions(List<String> *p_extensions) ;
 	static bool recognize(const String& p_extension) ;
-		
+
 	static void add_image_format_loader(ImageFormatLoader *p_loader);
 
 };
diff --git a/core/io/ip.cpp b/core/io/ip.cpp
index b8bd00c2fb..a77aace07f 100644
--- a/core/io/ip.cpp
+++ b/core/io/ip.cpp
@@ -49,7 +49,7 @@ struct _IP_ResolverPrivate {
 			response = IP_Address();
 			hostname="";
 		};
-		
+
 		QueueItem() {
 			clear();
 		};
diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp
index 4dccf21d2d..1733aecd46 100644
--- a/core/io/marshalls.cpp
+++ b/core/io/marshalls.cpp
@@ -95,7 +95,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int *
 			str.parse_utf8((const char*)buf,strlen);
 			r_variant=str;
 
-			if (r_len) {				
+			if (r_len) {
 				if (strlen%4)
 					(*r_len)+=4-strlen%4;
 				(*r_len)+=4+strlen;
@@ -294,7 +294,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int *
 		} break;
 		case Variant::NODE_PATH: {
 
-			ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);			
+			ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);
 			uint32_t strlen = decode_uint32(buf);
 
 			if (strlen&0x80000000) {
@@ -1077,7 +1077,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) {
 
 			r_len+=data.size()+5*4+pad;
 
-		} break;		
+		} break;
 		/*case Variant::RESOURCE: {
 
 			ERR_EXPLAIN("Can't marshallize resources");
@@ -1238,7 +1238,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) {
 			DVector<uint8_t> data = p_variant;
 			int datalen=data.size();
 			int datasize=sizeof(uint8_t);
-			
+
 			if (buf) {
 				encode_uint32(datalen,buf);
 				buf+=4;
diff --git a/core/io/marshalls.h b/core/io/marshalls.h
index 7a5b16e8af..6a46e9882a 100644
--- a/core/io/marshalls.h
+++ b/core/io/marshalls.h
@@ -37,7 +37,7 @@
   * Miscelaneous helpers for marshalling data types, and encoding
   * in an endian independent way
   */
-  
+
 
 union MarshallFloat {
 
@@ -54,22 +54,22 @@ union MarshallDouble {
 static inline unsigned int encode_uint16(uint16_t p_uint, uint8_t *p_arr) {
 
 	for (int i=0;i<2;i++) {
-	
+
 		*p_arr=p_uint&0xFF;
 		p_arr++; p_uint>>=8;
 	}
-	
+
 	return sizeof( uint16_t );
 }
 
 static inline unsigned int encode_uint32(uint32_t p_uint, uint8_t *p_arr) {
 
 	for (int i=0;i<4;i++) {
-	
+
 		*p_arr=p_uint&0xFF;
 		p_arr++; p_uint>>=8;
 	}
-	
+
 	return sizeof( uint32_t );
 }
 
@@ -85,11 +85,11 @@ static inline unsigned int encode_float(float p_float, uint8_t *p_arr) {
 static inline unsigned int encode_uint64(uint64_t p_uint, uint8_t *p_arr) {
 
 	for (int i=0;i<8;i++) {
-	
+
 		*p_arr=p_uint&0xFF;
 		p_arr++; p_uint>>=8;
 	}
-	
+
 	return sizeof(uint64_t);
 }
 
@@ -100,25 +100,25 @@ static inline unsigned int encode_double(double p_double, uint8_t *p_arr) {
 	encode_uint64( md.l, p_arr );
 
 	return sizeof(uint64_t);
-	
+
 }
 
 
 static inline int encode_cstring(const char *p_string, uint8_t * p_data) {
 
 	int len=0;
-	
+
 	while (*p_string) {
 
 		if (p_data) {
-		
+
 			*p_data=(uint8_t)*p_string;
 			p_data++;
 		}
 		p_string++;
 		len++;
 	};
-	
+
 	if (p_data) *p_data = 0;
 	return len+1;
 }
@@ -126,35 +126,35 @@ static inline int encode_cstring(const char *p_string, uint8_t * p_data) {
 static inline uint16_t decode_uint16(const uint8_t *p_arr) {
 
 	uint16_t u=0;
-	
+
 	for (int i=0;i<2;i++) {
-	
+
 		uint16_t b = *p_arr;
 		b<<=(i*8);
 		u|=b;
 		p_arr++;
 	}
-	
+
 	return u;
 }
 
 static inline uint32_t decode_uint32(const uint8_t *p_arr) {
 
 	uint32_t u=0;
-	
+
 	for (int i=0;i<4;i++) {
-	
+
 		uint32_t b = *p_arr;
 		b<<=(i*8);
 		u|=b;
 		p_arr++;
 	}
-	
+
 	return u;
 }
 
 static inline float decode_float(const uint8_t *p_arr) {
-	
+
 	MarshallFloat mf;
 	mf.i = decode_uint32(p_arr);
 	return mf.f;
@@ -163,15 +163,15 @@ static inline float decode_float(const uint8_t *p_arr) {
 static inline uint64_t decode_uint64(const uint8_t *p_arr) {
 
 	uint64_t u=0;
-	
+
 	for (int i=0;i<8;i++) {
-	
+
 		uint64_t b = (*p_arr)&0xFF;
 		b<<=(i*8);
 		u|=b;
 		p_arr++;
 	}
-	
+
 	return u;
 }
 
diff --git a/core/io/packet_peer.cpp b/core/io/packet_peer.cpp
index 973a2ec9a5..22b8bc0b39 100644
--- a/core/io/packet_peer.cpp
+++ b/core/io/packet_peer.cpp
@@ -180,10 +180,10 @@ int PacketPeerStream::get_available_packet_count() const {
 		ring_buffer.copy(lbuf,ofs,4);
 		uint32_t len = decode_uint32(lbuf);
 		remaining-=4;
-		ofs+=4;		
+		ofs+=4;
 		if (len>remaining)
 			break;
-		remaining-=len;		
+		remaining-=len;
 		ofs+=len;
 		count++;
 	}
@@ -201,7 +201,7 @@ Error PacketPeerStream::get_packet(const uint8_t **r_buffer,int &r_buffer_size)
 	uint8_t lbuf[4];
 	ring_buffer.copy(lbuf,0,4);
 	remaining-=4;
-	uint32_t len = decode_uint32(lbuf);	
+	uint32_t len = decode_uint32(lbuf);
 	ERR_FAIL_COND_V(remaining<(int)len,ERR_UNAVAILABLE);
 
 	ring_buffer.read(lbuf,4); //get rid of first 4 bytes
diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp
index c008c3f9a4..58f3a4df2b 100644
--- a/core/io/resource_format_binary.cpp
+++ b/core/io/resource_format_binary.cpp
@@ -378,7 +378,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v)  {
 				} break;
 				case OBJECT_INTERNAL_RESOURCE: {
 					uint32_t index=f->get_32();
-					String path = res_path+"::"+itos(index);					
+					String path = res_path+"::"+itos(index);
 					RES res = ResourceLoader::load(path);
 					if (res.is_null()) {
 						WARN_PRINT(String("Couldn't load resource: "+path).utf8().get_data());
@@ -2100,7 +2100,7 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path,const RES& p_
 					p.value=E->get()->get(F->get().name);
 					if ((F->get().usage&PROPERTY_USAGE_STORE_IF_NONZERO && p.value.is_zero())||(F->get().usage&PROPERTY_USAGE_STORE_IF_NONONE && p.value.is_one()) )
 						continue;
-					p.pi=F->get();										
+					p.pi=F->get();
 
 					rd.properties.push_back(p);
 
diff --git a/core/io/resource_format_xml.cpp b/core/io/resource_format_xml.cpp
index 03b77a4aab..a42a922baf 100644
--- a/core/io/resource_format_xml.cpp
+++ b/core/io/resource_format_xml.cpp
@@ -1818,7 +1818,7 @@ Error ResourceInteractiveLoaderXML::rename_dependencies(FileAccess *p_f, const S
 
 void ResourceInteractiveLoaderXML::open(FileAccess *p_f) {
 
-	error=OK;	
+	error=OK;
 
 	lines=1;
 	f=p_f;
diff --git a/core/io/resource_loader.cpp b/core/io/resource_loader.cpp
index 67208b5960..abb1082256 100644
--- a/core/io/resource_loader.cpp
+++ b/core/io/resource_loader.cpp
@@ -49,16 +49,16 @@ Error ResourceInteractiveLoader::wait() {
 
 
 bool ResourceFormatLoader::recognize(const String& p_extension) const {
-	
-	
+
+
 	List<String> extensions;
 	get_recognized_extensions(&extensions);
 	for (List<String>::Element *E=extensions.front();E;E=E->next()) {
-		
+
 		if (E->get().nocasecmp_to(p_extension.extension())==0)
 			return true;
 	}
-	
+
 	return false;
 }
 
@@ -184,9 +184,9 @@ RES ResourceLoader::load(const String &p_path, const String& p_type_hint, bool p
 
 	String extension=remapped_path.extension();
 	bool found=false;
-	
+
 	for (int i=0;i<loader_count;i++) {
-		
+
 		if (!loader[i]->recognize(extension))
 			continue;
 		if (p_type_hint!="" && !loader[i]->handles_type(p_type_hint))
@@ -356,7 +356,7 @@ Ref<ResourceInteractiveLoader> ResourceLoader::load_interactive(const String &p_
 }
 
 void ResourceLoader::add_resource_format_loader(ResourceFormatLoader *p_format_loader) {
-	
+
 	ERR_FAIL_COND( loader_count >= MAX_LOADERS );
 	loader[loader_count++]=p_format_loader;
 }
diff --git a/core/io/resource_loader.h b/core/io/resource_loader.h
index fe58303066..6404e6cb13 100644
--- a/core/io/resource_loader.h
+++ b/core/io/resource_loader.h
@@ -47,7 +47,7 @@ public:
 	virtual Ref<Resource> get_resource()=0;
 	virtual Error poll()=0;
 	virtual int get_stage() const=0;
-	virtual int get_stage_count() const=0;	
+	virtual int get_stage_count() const=0;
 	virtual Error wait();
 
 	ResourceInteractiveLoader() {}
@@ -76,12 +76,12 @@ typedef void (*ResourceLoadErrorNotify)(void *p_ud,const String& p_text);
 typedef void (*DependencyErrorNotify)(void *p_ud,const String& p_loading,const String& p_which,const String& p_type);
 
 
-class ResourceLoader {	
-	
+class ResourceLoader {
+
 	enum {
 		MAX_LOADERS=64
 	};
-	
+
 	static ResourceFormatLoader *loader[MAX_LOADERS];
 	static int loader_count;
 	static bool timestamp_on_load;
@@ -96,7 +96,7 @@ class ResourceLoader {
 public:
 
 
-	
+
 	static Ref<ResourceInteractiveLoader> load_interactive(const String &p_path,const String& p_type_hint="",bool p_no_cache=false,Error *r_error=NULL);
 	static RES load(const String &p_path,const String& p_type_hint="",bool p_no_cache=false,Error *r_error=NULL);
 	static Ref<ResourceImportMetadata> load_import_metadata(const String &p_path);
diff --git a/core/io/resource_saver.cpp b/core/io/resource_saver.cpp
index 51020a0285..8d78ecabbf 100644
--- a/core/io/resource_saver.cpp
+++ b/core/io/resource_saver.cpp
@@ -39,30 +39,30 @@ bool ResourceSaver::timestamp_on_save=false;
 ResourceSavedCallback ResourceSaver::save_callback=0;
 
 Error ResourceSaver::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
-		
+
 	String extension=p_path.extension();
 	Error err=ERR_FILE_UNRECOGNIZED;
 
 	for (int i=0;i<saver_count;i++) {
-		
+
 		if (!saver[i]->recognize(p_resource))
 			continue;
-			
+
 		List<String> extensions;
 		bool recognized=false;
 		saver[i]->get_recognized_extensions(p_resource,&extensions);
-				
+
 		for (List<String>::Element *E=extensions.front();E;E=E->next()) {
-		
+
 			if (E->get().nocasecmp_to(extension.extension())==0)
 				recognized=true;
 		}
 
 		if (!recognized)
 			continue;
-		
+
 		String old_path=p_resource->get_path();
-		
+
 
 		String local_path=Globals::get_singleton()->localize_path(p_path);
 
@@ -92,10 +92,10 @@ Error ResourceSaver::save(const String &p_path,const RES& p_resource,uint32_t p_
 
 			return OK;
 		} else {
-		
+
 		}
 	}
-	
+
 	return err;
 }
 
@@ -108,16 +108,16 @@ void ResourceSaver::set_save_callback(ResourceSavedCallback p_callback) {
 
 void ResourceSaver::get_recognized_extensions(const RES& p_resource,List<String> *p_extensions) {
 
-	
+
 	for (int i=0;i<saver_count;i++) {
-		
+
 		saver[i]->get_recognized_extensions(p_resource,p_extensions);
 	}
-	
+
 }
 
 void ResourceSaver::add_resource_format_saver(ResourceFormatSaver *p_format_saver) {
-	
+
 	ERR_FAIL_COND( saver_count >= MAX_SAVERS );
 	saver[saver_count++]=p_format_saver;
 }
diff --git a/core/io/resource_saver.h b/core/io/resource_saver.h
index 7bc96c1087..97500c46f4 100644
--- a/core/io/resource_saver.h
+++ b/core/io/resource_saver.h
@@ -42,7 +42,7 @@
 
 class ResourceFormatSaver {
 public:
-	
+
 	virtual Error save(const String &p_path,const RES& p_resource,uint32_t p_flags=0)=0;
 	virtual bool recognize(const RES& p_resource) const=0;
 	virtual void get_recognized_extensions(const RES& p_resource,List<String> *p_extensions) const=0;
@@ -52,12 +52,12 @@ public:
 
 typedef void (*ResourceSavedCallback)(const String& p_path);
 
-class ResourceSaver {	
-	
+class ResourceSaver {
+
 	enum {
 		MAX_SAVERS=64
 	};
-	
+
 	static ResourceFormatSaver *saver[MAX_SAVERS];
 	static int saver_count;
 	static bool timestamp_on_save;
@@ -86,7 +86,7 @@ public:
 	static void set_save_callback(ResourceSavedCallback p_callback);
 
 
-	
+
 };
 
 
diff --git a/core/list.h b/core/list.h
index fbeb653da4..b989f009a9 100644
--- a/core/list.h
+++ b/core/list.h
@@ -245,7 +245,7 @@ public:
 			_data->first=n;
 
 		_data->size_cache++;
-		
+
 		return n;
 	};
 
@@ -285,7 +285,7 @@ public:
 			_data->last=n;
 
 		_data->size_cache++;
-		
+
 		return n;
 	};
 
@@ -363,30 +363,30 @@ public:
 	}
 
 	void swap(Element* p_A, Element *p_B) {
-		
+
 		ERR_FAIL_COND(!p_A || !p_B);
 		ERR_FAIL_COND(p_A->data!=_data);
 		ERR_FAIL_COND(p_B->data!=_data);
-		
+
 		Element* A_prev=p_A->prev_ptr;
 		Element* A_next=p_A->next_ptr;
-		
+
 		p_A->next_ptr=p_B->next_ptr;
 		p_A->prev_ptr=p_B->prev_ptr;
-		
+
 		p_B->next_ptr=A_next;
-		p_B->prev_ptr=A_prev;	
-		
+		p_B->prev_ptr=A_prev;
+
 		if (p_A->prev_ptr)
 			p_A->prev_ptr->next_ptr=p_A;
 		if (p_A->next_ptr)
-			p_A->next_ptr->prev_ptr=p_A;		
-		
+			p_A->next_ptr->prev_ptr=p_A;
+
 		if (p_B->prev_ptr)
 			p_B->prev_ptr->next_ptr=p_B;
 		if (p_B->next_ptr)
-			p_B->next_ptr->prev_ptr=p_B;		
-		
+			p_B->next_ptr->prev_ptr=p_B;
+
 	}
 	/**
 	 * copy the list
@@ -552,10 +552,10 @@ public:
 	 */
 
 	void sort() {
-		
+
 		sort_custom< Comparator<T> >();
 	}
-			
+
 	template<class C>
 	void sort_custom_inplace() {
 
@@ -565,44 +565,44 @@ public:
 		Element *from=front();
 		Element *current=from;
 		Element *to=from;
-		
+
 		while(current) {
-			
+
 			Element *next=current->next_ptr;
-			
+
 			//disconnect
 			current->next_ptr=NULL;
-			
+
 			if (from!=current) {
-				
+
 				current->prev_ptr=NULL;
 				current->next_ptr=from;
-				
+
 				Element *find=from;
 				C less;
 				while( find && less(find->value,current->value) ) {
-				
+
 					current->prev_ptr=find;
 					current->next_ptr=find->next_ptr;
 					find=find->next_ptr;
 				}
-								
+
 				if (current->prev_ptr)
 					current->prev_ptr->next_ptr=current;
 				else
 					from=current;
-				
+
 				if (current->next_ptr)
 					current->next_ptr->prev_ptr=current;
 				else
 					to=current;
 			} else {
-				
+
 				current->prev_ptr=NULL;
 				current->next_ptr=NULL;
-				
+
 			}
-			
+
 			current=next;
 		}
 		_data->first=from;
diff --git a/core/map.h b/core/map.h
index 35dc73df48..81cda1ece2 100644
--- a/core/map.h
+++ b/core/map.h
@@ -39,12 +39,12 @@
 
 template <class K,class V,class C=Comparator<K>,class A=DefaultAllocator>
 class Map {
-	
-	enum Color {	
+
+	enum Color {
 		RED,
 		BLACK
 	};
-	struct _Data;	
+	struct _Data;
 public:
 
 	class Element {
@@ -66,34 +66,34 @@ public:
 	public:
 
 		const Element *next() const {
-			
+
 			return _next;
 		}
 		Element *next() {
-			
+
 			return _next;
 		}
 		const Element *prev() const {
-			
+
 			return _prev;
 		}
 		Element *prev() {
-			
+
 			return _prev;
 		}
-		const K& key() const { 
+		const K& key() const {
 			return _key;
 		};
-		V& value() { 
+		V& value() {
 			return _value;
 		};
-		const V& value() const { 
+		const V& value() const {
 			return _value;
 		};
-		V& get() { 
+		V& get() {
 			return _value;
 		};
-		const V& get() const { 
+		const V& get() const {
 			return _value;
 		};
 		Element() {
@@ -106,15 +106,15 @@ public:
 		};
 	};
 
-	
+
 private:
 
 	struct _Data {
-		
+
 		Element* _root;
 		Element* _nil;
 		int size_cache;
-		
+
 		_FORCE_INLINE_ _Data() {
 #ifdef GLOBALNIL_DISABLED
 			_nil = memnew_allocator( Element, A );
@@ -126,7 +126,7 @@ private:
 			_root=NULL;
 			size_cache=0;
 		}
-		
+
 		void _create_root() {
 
 			_root = memnew_allocator( Element,A );
@@ -145,23 +145,23 @@ private:
 		~_Data() {
 
 			_free_root();
-			
+
 #ifdef GLOBALNIL_DISABLED
 			memdelete_allocator<Element,A>(_nil);
 #endif
 //			memdelete_allocator<Element,A>(_root);
 		}
 	};
-	
+
 	_Data _data;
-	
+
 	inline void _set_color(Element *p_node, int p_color) {
-		
+
 		ERR_FAIL_COND( p_node == _data._nil && p_color == RED );
 		p_node->color=p_color;
 	}
 	inline void _rotate_left(Element *p_node) {
-	
+
 		Element *r=p_node->right;
 		p_node->right=r->left;
 		if (r->left != _data._nil )
@@ -171,14 +171,14 @@ private:
 			p_node->parent->left=r;
 		else
 			p_node->parent->right=r;
-			
+
 		r->left=p_node;
 		p_node->parent=r;
-		
+
 	}
-	
+
 	inline void _rotate_right(Element *p_node) {
-	
+
 		Element *l=p_node->left;
 		p_node->left=l->right;
 		if (l->right != _data._nil)
@@ -188,25 +188,25 @@ private:
 			p_node->parent->right=l;
 		else
 			p_node->parent->left=l;
-			
+
 		l->right=p_node;
 		p_node->parent=l;
-		
+
 	}
-	
-	inline Element* _successor(Element *p_node) const { 
-		
+
+	inline Element* _successor(Element *p_node) const {
+
 		Element *node=p_node;
-				
+
 		if (node->right != _data._nil) {
-			
+
 			node=node->right;
 			while(node->left != _data._nil) { /* returns the minium of the right subtree of node */
 				node=node->left;
 			}
 			return node;
 		} else {
-			
+
 			while(node == node->parent->right) {
 				node=node->parent;
 			}
@@ -215,44 +215,44 @@ private:
 			return node->parent;
 		}
 	}
-	
-	inline Element* _predecessor(Element *p_node) const { 
+
+	inline Element* _predecessor(Element *p_node) const {
 		Element *node=p_node;
-		
+
 		if (node->left != _data._nil) {
-			
+
 			node=node->left;
 			while(node->right != _data._nil) { /* returns the minium of the left subtree of node */
 				node=node->right;
 			}
 			return node;
 		} else {
-			
+
 			while(node == node->parent->left) {
 				if (node->parent == _data._root)
-					return NULL;			
+					return NULL;
 				node=node->parent;
 			}
 			return node->parent;
 		}
 	}
-	
-	
+
+
 	Element *_find(const K& p_key) const {
-	
+
 		Element *node = _data._root->left;
-		C less;			
-				
+		C less;
+
 		while(node!=_data._nil) {
-				
-			if (less(p_key,node->_key)) 
+
+			if (less(p_key,node->_key))
 				node=node->left;
 			else if (less(node->_key,p_key))
 				node=node->right;
 			else
 				break; // found
 		}
-		
+
 		return (node!=_data._nil)?node:NULL;
 	}
 
@@ -289,73 +289,73 @@ private:
 	}
 
 	Element *_insert(const K& p_key, bool& r_exists) {
-		
+
 		Element *new_parent=_data._root;
 		Element *node = _data._root->left;
-		C less;			
-		
+		C less;
+
 		while (node!=_data._nil) {
-			
+
 			new_parent=node;
-			
+
 			if (less(p_key,node->_key))
 				node=node->left;
 			else if (less(node->_key,p_key))
 				node=node->right;
-			else {				
+			else {
 				r_exists=true;
 				return node;
-			}						
+			}
 		}
-		
+
 		Element *new_node = memnew_allocator( Element, A );
 
-		
+
 		new_node->parent=new_parent;
 		new_node->right=_data._nil;
 		new_node->left=_data._nil;
 		new_node->_key=p_key;
 		//new_node->data=_data;
 		if (new_parent==_data._root || less(p_key,new_parent->_key)) {
-			
+
 			new_parent->left=new_node;
 		} else {
 			new_parent->right=new_node;
 		}
-		
+
 		r_exists=false;
-		
+
 		new_node->_next=_successor(new_node);
 		new_node->_prev=_predecessor(new_node);
 		if (new_node->_next)
 			new_node->_next->_prev=new_node;
 		if (new_node->_prev)
 			new_node->_prev->_next=new_node;
-		
+
 
 		return new_node;
 	}
-	
+
 	Element * _insert_rb(const K& p_key, const V& p_value) {
-		
+
 		bool exists=false;
 		Element *new_node = _insert(p_key,exists);
-		
+
 		if (new_node) {
 			new_node->_value=p_value;
 		}
 		if (exists)
 			return new_node;
-				                
+
 		Element *node=new_node;
 		_data.size_cache++;
 
-		while(node->parent->color==RED) { 
-			
+		while(node->parent->color==RED) {
+
 			if (node->parent == node->parent->parent->left) {
-				
+
 				Element *aux=node->parent->parent->right;
-				
+
 				if (aux->color==RED) {
 					_set_color(node->parent,BLACK);
 					_set_color(aux,BLACK);
@@ -369,10 +369,10 @@ private:
 					_set_color(node->parent,BLACK);
 					_set_color(node->parent->parent,RED);
 					_rotate_right(node->parent->parent);
-				} 
-			} else { 
+				}
+			} else {
 				Element *aux=node->parent->parent->left;
-				
+
 				if (aux->color==RED) {
 					_set_color(node->parent,BLACK);
 					_set_color(aux,BLACK);
@@ -386,19 +386,19 @@ private:
 					_set_color(node->parent,BLACK);
 					_set_color(node->parent->parent,RED);
 					_rotate_left(node->parent->parent);
-				} 
+				}
 			}
 		}
 		_set_color(_data._root->left,BLACK);
-		return new_node;		
-	}	
+		return new_node;
+	}
 
 	void _erase_fix(Element *p_node) {
-		
+
 		Element *root = _data._root->left;
 		Element *node=p_node;
-		
-		
+
+
 		while( (node->color==BLACK) && (root != node)) {
 			if (node == node->parent->left) {
 				Element *aux=node->parent->right;
@@ -408,7 +408,7 @@ private:
 					_rotate_left(node->parent);
 					aux=node->parent->right;
 				}
-				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) { 
+				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) {
 					_set_color(aux,RED);
 					node=node->parent;
 				} else {
@@ -432,7 +432,7 @@ private:
 					_rotate_right(node->parent);
 					aux=node->parent->left;
 				}
-				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) { 
+				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) {
 					_set_color(aux,RED);
 					node=node->parent;
 				} else {
@@ -446,24 +446,24 @@ private:
 					_set_color(node->parent,BLACK);
 					_set_color(aux->left,BLACK);
 					_rotate_right(node->parent);
-					node=root; 
+					node=root;
 				}
 			}
 		}
-		
+
 		_set_color(node,BLACK);
-		
+
 		ERR_FAIL_COND(_data._nil->color!=BLACK);
 	}
-	
+
 	void _erase(Element *p_node) {
-		
-		
+
+
 		Element *rp= ((p_node->left == _data._nil) || (p_node->right == _data._nil)) ? p_node : _successor(p_node);
 		if (!rp)
 			rp=_data._nil;
 		Element *node= (rp->left == _data._nil) ? rp->right : rp->left;
-				
+
 		if (_data._root == (node->parent=rp->parent) ) {
 			_data._root->left=node;
 		} else {
@@ -473,47 +473,47 @@ private:
 				rp->parent->right=node;
 			}
 		}
-		
-		if (rp != p_node) { 
-			
+
+		if (rp != p_node) {
+
 			ERR_FAIL_COND( rp == _data._nil );
-			
+
 			if (rp->color==BLACK)
 				_erase_fix(node);
-			
-			
+
+
 			rp->left=p_node->left;
 			rp->right=p_node->right;
 			rp->parent=p_node->parent;
 			rp->color=p_node->color;
 			p_node->left->parent=rp;
 			p_node->right->parent=rp;
-			
+
 			if (p_node == p_node->parent->left) {
-				p_node->parent->left=rp; 
+				p_node->parent->left=rp;
 			} else {
 				p_node->parent->right=rp;
 			}
 		} else {
-			if (p_node->color==BLACK) 
+			if (p_node->color==BLACK)
 				_erase_fix(node);
-		
+
 		}
-		
-		
+
+
 		if (p_node->_next)
 			p_node->_next->_prev=p_node->_prev;
 		if (p_node->_prev)
 			p_node->_prev->_next=p_node->_next;
-		
+
 		memdelete_allocator<Element,A>(p_node);
 		_data.size_cache--;
 		ERR_FAIL_COND( _data._nil->color==RED );
 	}
-	
-	
+
+
 	void _calculate_depth(Element *p_element,int &max_d,int d) const {
-		
+
 		if (p_element==_data._nil) {
 			return;
 		}
@@ -522,23 +522,23 @@ private:
 		if (d>max_d)
 			max_d=d;
 	}
-	
+
 	void _cleanup_tree(Element *p_element) {
-		
+
 		if (p_element==_data._nil)
 			return;
-		
+
 		_cleanup_tree(p_element->left);
 		_cleanup_tree(p_element->right);
 		memdelete_allocator<Element,A>( p_element );
 	}
-	
+
 	void _copy_from( const Map& p_map) {
-		
+
 		clear();
 		// not the fastest way, but safeset to write.
 		for(Element *I=p_map.front();I;I=I->next()) {
-			
+
 			insert(I->key(),I->value());
 		}
 	}
@@ -554,7 +554,7 @@ public:
 	}
 
 	Element *find(const K& p_key) {
-		
+
 		if (!_data._root)
 			return NULL;
 		Element *res=_find(p_key);
@@ -578,15 +578,15 @@ public:
 	}
 
 	Element *insert(const K& p_key,const V& p_value) {
-	
+
 		if (!_data._root)
 			_data._create_root();
 		return _insert_rb(p_key,p_value);
-		
+
 	}
-	
+
 	void erase(Element* p_element) {
-	
+
 		if (!_data._root)
 			return;
 		_erase(p_element);
@@ -595,72 +595,72 @@ public:
 	}
 
 	bool erase(const K& p_key) {
-		
+
 		if (!_data._root)
 			return false;
 		Element *e=find(p_key);
 		if (!e)
 			return false;
-		_erase(e);		
+		_erase(e);
 		return true;
 	}
-	
+
 	bool has(const K& p_key) const {
-		
+
 		if (!_data._root)
 			return false;
 		return find(p_key) != NULL;
 	}
-	
+
 	const V& operator[](const K& p_key) const {
-		
+
 		ERR_FAIL_COND_V(!_data._root, *(V*)NULL); // crash on purpose
 		const Element *e=find(p_key);
 		ERR_FAIL_COND_V(!e, *(V*)NULL); // crash on purpose
 		return e->_value;
 	}
 	V& operator[](const K& p_key) {
-		
+
 		if (!_data._root)
 			_data._create_root();
 
 		Element *e=find(p_key);
 		if (!e)
 			e=insert(p_key,V());
-		
-		ERR_FAIL_COND_V(!e, *(V*)NULL); // crash on purpose		
+
+		ERR_FAIL_COND_V(!e, *(V*)NULL); // crash on purpose
 		return e->_value;
 	}
-	
+
 	Element *front() const {
-		
+
 		if (!_data._root)
 			return NULL;
 
 		Element *e=_data._root->left;
 		if (e==_data._nil)
 			return NULL;
-		
+
 		while(e->left!=_data._nil)
 			e=e->left;
-		
+
 		return e;
 	}
-	
+
 	Element *back() const {
-		
+
 		if (!_data._root)
 			return NULL;
 		Element *e=_data._root->left;
 		if (e==_data._nil)
 			return NULL;
-		
+
 		while(e->right!=_data._nil)
 			e=e->right;
-		
+
 		return e;
 	}
-	
+
 	inline bool empty() const { return _data.size_cache==0; }
 	inline int size() const { return _data.size_cache; }
 	int calculate_depth() const {
@@ -671,9 +671,9 @@ public:
 		_calculate_depth(_data._root->left,max_d,0);
 		return max_d;
 	}
-	
+
 	void clear() {
-		
+
 		if (!_data._root)
 			return;
 		_cleanup_tree(_data._root->left);
@@ -682,25 +682,25 @@ public:
 		_data._nil->parent=_data._nil;
 		_data._free_root();
 	}
-	
+
 	void operator=(const Map& p_map) {
-		
+
 		_copy_from( p_map );
 	}
-	
+
 	Map(const Map& p_map) {
-		
+
 		_copy_from( p_map );
 	}
 
 	_FORCE_INLINE_ Map() {
-	
+
 	}
-		    
-		    
+
+
 	~Map() {
-		
-		clear();		
+
+		clear();
 	}
 
 };
diff --git a/core/math/aabb.h b/core/math/aabb.h
index 0fada859c0..57fe1b32f5 100644
--- a/core/math/aabb.h
+++ b/core/math/aabb.h
@@ -47,21 +47,21 @@ public:
 
 	float get_area() const; /// get area
 	_FORCE_INLINE_ bool has_no_area() const {
-	
+
 		return (size.x<=CMP_EPSILON || size.y<=CMP_EPSILON  || size.z<=CMP_EPSILON);
 	}
 
 	_FORCE_INLINE_ bool has_no_surface() const {
-	
+
 		return (size.x<=CMP_EPSILON && size.y<=CMP_EPSILON  && size.z<=CMP_EPSILON);
 	}
-	
+
 	const Vector3& get_pos() const { return pos; }
 	void set_pos(const Vector3& p_pos) { pos=p_pos; }
 	const Vector3& get_size() const { return size; }
 	void set_size(const Vector3& p_size) { size=p_size; }
 
-	
+
 	bool operator==(const AABB& p_rval) const;
 	bool operator!=(const AABB& p_rval) const;
 
@@ -265,7 +265,7 @@ bool AABB::has_point(const Vector3& p_point) const {
 		return false;
 	if (p_point.z>pos.z+size.z)
 		return false;
-		
+
 	return true;
 }
 
@@ -297,11 +297,11 @@ void AABB::project_range_in_plane(const Plane& p_plane,float &r_min,float& r_max
 
 	Vector3 half_extents( size.x * 0.5, size.y * 0.5, size.z * 0.5 );
 	Vector3 center( pos.x + half_extents.x, pos.y + half_extents.y, pos.z + half_extents.z );
-		
+
 	float length = p_plane.normal.abs().dot(half_extents);
 	float distance = p_plane.distance_to( center );
 	r_min = distance - length;
-	r_max = distance + length;	
+	r_max = distance + length;
 }
 
 inline real_t AABB::get_longest_axis_size() const {
diff --git a/core/math/bsp_tree.cpp b/core/math/bsp_tree.cpp
index 0c07b733f0..d16495217c 100644
--- a/core/math/bsp_tree.cpp
+++ b/core/math/bsp_tree.cpp
@@ -66,12 +66,12 @@ Vector<Plane> BSP_Tree::get_planes() const {
 
 	return planes;
 }
-	
+
 AABB 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 {
 
 
@@ -245,22 +245,22 @@ bool BSP_Tree::point_is_inside(const Vector3& p_point) const {
 	if (!aabb.has_point(p_point)) {
 		return false;
 	}
-	
+
 	int node_count=nodes.size();
-	
+
 	if (node_count==0) // no nodes!
 		return false;
-	
-	
+
+
 	const Node *nodesptr=&nodes[0];
 	const Plane *planesptr=&planes[0];
 	int plane_count=planes.size();
-		
+
 	int idx=node_count-1;
 	int steps=0;
-	
+
 	while(true) {
-	
+
 		if (idx==OVER_LEAF) {
 			return false;
 		}
@@ -268,28 +268,28 @@ bool BSP_Tree::point_is_inside(const Vector3& p_point) const {
 
 			return true;
 		}
-			
+
 		uint16_t plane=nodesptr[ idx ].plane;
 #ifdef DEBUG_ENABLED
-			
+
 		ERR_FAIL_INDEX_V( plane, plane_count, false );
 #endif
 		bool over = planesptr[ nodesptr[ idx ].plane ].is_point_over(p_point);
 
 		idx =  over ? nodes[ idx ].over : nodes[ idx ].under;
-		
+
 #ifdef DEBUG_ENABLED
-			
+
 		ERR_FAIL_COND_V( idx<MAX_NODES && idx>=node_count, false );
 #endif
-		
+
 		steps++;
 	}
 
 	return false;
 }
-	
-	
+
+
 static int _bsp_find_best_half_plane(const Face3* p_faces,const Vector<int>& p_indices,float p_tolerance) {
 
 	int ic = p_indices.size();
@@ -304,7 +304,7 @@ static int _bsp_find_best_half_plane(const Face3* p_faces,const Vector<int>& p_i
 
 		const Face3& f=p_faces[ indices[i] ];
 		Plane p = f.get_plane();
-		
+
 		int num_over=0,num_under=0,num_spanning=0;
 
 		for(int j=0;j<ic;j++) {
@@ -335,17 +335,17 @@ static int _bsp_find_best_half_plane(const Face3* p_faces,const Vector<int>& p_i
 				num_over++;
 			else
 				num_under++;
-				
+
 		}
 
 
 
 		//double split_cost = num_spanning / (double) face_count;
 		double relation = Math::abs(num_over-num_under) / (double) 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
-		
+
 		double 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);
@@ -360,10 +360,10 @@ static int _bsp_find_best_half_plane(const Face3* p_faces,const Vector<int>& p_i
 	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,float p_tolerance) {
-	
+
 	ERR_FAIL_COND_V( p_nodes.size() == BSP_Tree::MAX_NODES, -1 );
 
 	// should not reach here
@@ -387,7 +387,7 @@ static int _bsp_create_node(const Face3 *p_faces,const Vector<int>& p_indices,Ve
 
 		if (i==divisor_idx)
 			continue;
-			
+
 		const Face3& f=p_faces[ indices[i] ];
 
 		//if (f.get_plane().is_almost_like(divisor_plane))
@@ -416,7 +416,7 @@ static int _bsp_create_node(const Face3 *p_faces,const Vector<int>& p_indices,Ve
 	}
 
 
-	
+
 	uint16_t over_idx=BSP_Tree::OVER_LEAF,under_idx=BSP_Tree::UNDER_LEAF;
 
 	if (faces_over.size()>0) { //have facess above?
@@ -434,13 +434,13 @@ static int _bsp_create_node(const Face3 *p_faces,const Vector<int>& p_indices,Ve
 	}
 
 	/* Create the node */
-	
+
 	// find existing divisor plane
 	int divisor_plane_idx=-1;
-	
-	
+
+
 	for (int i=0;i<p_planes.size();i++) {
-	
+
 		if (p_planes[i].is_almost_like( divisor_plane )) {
 			divisor_plane_idx=i;
 			break;
@@ -448,22 +448,22 @@ static int _bsp_create_node(const Face3 *p_faces,const Vector<int>& p_indices,Ve
 	}
 
 	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 );
 	}
-	
+
 	BSP_Tree::Node node;
 	node.plane=divisor_plane_idx;
 	node.under=under_idx;
 	node.over=over_idx;
-	
+
 	p_nodes.push_back(node);
-	
+
 	return p_nodes.size()-1;
 }
-	
+
 
 BSP_Tree::operator Variant() const {
 
@@ -563,7 +563,7 @@ BSP_Tree::BSP_Tree(const Variant& p_variant) {
 BSP_Tree::BSP_Tree(const DVector<Face3>& p_faces,float p_error_radius) {
 
 	// compute aabb
-		
+
 	int face_count=p_faces.size();
 	DVector<Face3>::Read faces_r=p_faces.read();
 	const Face3 *facesptr = faces_r.ptr();
@@ -574,26 +574,26 @@ BSP_Tree::BSP_Tree(const DVector<Face3>& p_faces,float p_error_radius) {
 	Vector<int> indices;
 
 	for (int i=0;i<face_count;i++) {
-			
+
 		const Face3& f=facesptr[i];
-		
+
 		if (f.is_degenerate())
 			continue;
-			
+
 		for (int j=0;j<3;j++) {
-		
+
 			if (first) {
-			
+
 				aabb.pos=f.vertex[0];
 				first=false;
 			} else {
-			
+
 				aabb.expand_to(f.vertex[j]);
 			}
 		}
 
 		indices.push_back(i);
-		
+
 	}
 
 	ERR_FAIL_COND( aabb.has_no_area() );
@@ -609,7 +609,7 @@ BSP_Tree::BSP_Tree(const DVector<Face3>& p_faces,float p_error_radius) {
 
 
 
-	
+
 	error_radius=p_error_radius;
 }
 
diff --git a/core/math/bsp_tree.h b/core/math/bsp_tree.h
index a7145f9ff1..2bfc26b51e 100644
--- a/core/math/bsp_tree.h
+++ b/core/math/bsp_tree.h
@@ -43,7 +43,7 @@ class BSP_Tree {
 public:
 
 	enum {
-	
+
 		UNDER_LEAF=0xFFFF,
 		OVER_LEAF=0xFFFE,
 		MAX_NODES=0xFFFE,
@@ -51,22 +51,22 @@ public:
 	};
 
 	struct Node {
-		
+
 		uint16_t plane;
 		uint16_t under;
 		uint16_t over;
 	};
 
-	
-private:	
-	// thanks to the properties of Vector, 
+
+private:
+	// thanks to the properties of Vector,
 	// this class can be assigned and passed around between threads
 	// with no cost.
-	
+
 	Vector<Node> nodes;
 	Vector<Plane> planes;
 	AABB aabb;
-	float error_radius;	
+	float error_radius;
 
 	int _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;
 
@@ -79,8 +79,8 @@ public:
 	Vector<Node> get_nodes() const;
 	Vector<Plane> get_planes() const;
 	AABB get_aabb() const;
-		
-	bool point_is_inside(const Vector3& p_point) const;		
+
+	bool point_is_inside(const Vector3& p_point) const;
 	int get_points_inside(const Vector3* p_points, int p_point_count) const;
 	template<class T>
 	bool convex_is_inside(const T& p_convex) const;
@@ -91,8 +91,8 @@ public:
 
 	BSP_Tree();
 	BSP_Tree(const Variant& p_variant);
-	BSP_Tree(const DVector<Face3>& p_faces,float p_error_radius=0);	
-	BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const AABB& p_aabb,float p_error_radius=0);	
+	BSP_Tree(const DVector<Face3>& p_faces,float p_error_radius=0);
+	BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const AABB& p_aabb,float p_error_radius=0);
 	~BSP_Tree();
 
 };
diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp
index 61c8b78e0a..f7dd8839b8 100644
--- a/core/math/camera_matrix.cpp
+++ b/core/math/camera_matrix.cpp
@@ -33,9 +33,9 @@
 void CameraMatrix::set_identity() {
 
 	for (int i=0;i<4;i++) {
-	
+
 		for (int j=0;j<4;j++) {
-		
+
 			matrix[i][j]=(i==j)?1:0;
 		}
 	}
@@ -90,7 +90,7 @@ void CameraMatrix::set_perspective(float p_fovy_degrees, float p_aspect, float p
 	matrix[2][2] = -(p_z_far + p_z_near) / deltaZ;
 	matrix[2][3] = -1;
 	matrix[3][2] = -2 * p_z_near * p_z_far / deltaZ;
-	matrix[3][3] = 0;	
+	matrix[3][3] = 0;
 
 }
 
@@ -155,95 +155,95 @@ void CameraMatrix::set_frustum(float p_left, float p_right, float p_bottom, floa
 
 
 float CameraMatrix::get_z_far() const {
-	
-	const float * matrix = (const float*)this->matrix;			
+
+	const float * matrix = (const float*)this->matrix;
 	Plane new_plane=Plane(matrix[ 3] - matrix[ 2],
 	                matrix[ 7] - matrix[ 6],
 	                matrix[11] - matrix[10],
 	                matrix[15] - matrix[14]);
-	
+
 	new_plane.normal=-new_plane.normal;
 	new_plane.normalize();
-	
+
 	return new_plane.d;
 }
 float CameraMatrix::get_z_near() const {
-	
-	const float * matrix = (const float*)this->matrix;			
+
+	const float * matrix = (const float*)this->matrix;
 	Plane new_plane=Plane(matrix[ 3] + matrix[ 2],
 	                matrix[ 7] + matrix[ 6],
 	                matrix[11] + matrix[10],
 	               -matrix[15] - matrix[14]);
-	
+
 	new_plane.normalize();
 	return new_plane.d;
 }
 
 void CameraMatrix::get_viewport_size(float& r_width, float& r_height) const {
 
-	const float * matrix = (const float*)this->matrix;		
+	const float * matrix = (const float*)this->matrix;
 	///////--- Near Plane ---///////
 	Plane near_plane=Plane(matrix[ 3] + matrix[ 2],
 	                matrix[ 7] + matrix[ 6],
 	                matrix[11] + matrix[10],
 			-matrix[15] - matrix[14]).normalized();
-		
+
 	///////--- Right Plane ---///////
 	Plane right_plane=Plane(matrix[ 3] - matrix[ 0],
 	                matrix[ 7] - matrix[ 4],
 	                matrix[11] - matrix[ 8],
 			- matrix[15] + matrix[12]).normalized();
-	
+
 	Plane top_plane=Plane(matrix[ 3] - matrix[ 1],
 	                matrix[ 7] - matrix[ 5],
 	                matrix[11] - matrix[ 9],
 			-matrix[15] + matrix[13]).normalized();
-	
+
 	Vector3 res;
 	near_plane.intersect_3(right_plane,top_plane,&res);
-	
+
 	r_width=res.x;
 	r_height=res.y;
 }
 
 bool CameraMatrix::get_endpoints(const Transform& p_transform, Vector3 *p_8points) const {
 
-	const float * matrix = (const float*)this->matrix;		
-		
+	const float * matrix = (const float*)this->matrix;
+
 	///////--- Near Plane ---///////
 	Plane near_plane=Plane(matrix[ 3] + matrix[ 2],
 	                matrix[ 7] + matrix[ 6],
 	                matrix[11] + matrix[10],
 			-matrix[15] - matrix[14]).normalized();
-	
+
 	///////--- Far Plane ---///////
 	Plane far_plane=Plane(matrix[ 2] - matrix[ 3],
 		      matrix[ 6] - matrix[ 7],
 		      matrix[10] - matrix[11],
 		      matrix[15] - matrix[14]).normalized();
 
-		
+
 	///////--- Right Plane ---///////
 	Plane right_plane=Plane(matrix[ 0] - matrix[ 3],
 	                matrix[ 4] - matrix[ 7],
 	                matrix[8] - matrix[ 11],
 			- matrix[15] + matrix[12]).normalized();
-	
-	///////--- Top Plane ---///////	
+
+	///////--- Top Plane ---///////
 	Plane top_plane=Plane(matrix[ 1] - matrix[ 3],
 	                matrix[ 5] - matrix[ 7],
 	                matrix[9] - matrix[ 11],
 			-matrix[15] + matrix[13]).normalized();
-		
+
 	Vector3 near_endpoint;
 	Vector3 far_endpoint;
-	
+
 	bool res=near_plane.intersect_3(right_plane,top_plane,&near_endpoint);
 	ERR_FAIL_COND_V(!res,false);
-	
+
 	res=far_plane.intersect_3(right_plane,top_plane,&far_endpoint);
 	ERR_FAIL_COND_V(!res,false);
-	
+
 	p_8points[0]=p_transform.xform( Vector3( near_endpoint.x, near_endpoint.y, near_endpoint.z ) );
 	p_8points[1]=p_transform.xform( Vector3( near_endpoint.x,-near_endpoint.y, near_endpoint.z ) );
 	p_8points[2]=p_transform.xform( Vector3(-near_endpoint.x, near_endpoint.y, near_endpoint.z ) );
@@ -252,7 +252,7 @@ bool CameraMatrix::get_endpoints(const Transform& p_transform, Vector3 *p_8point
 	p_8points[5]=p_transform.xform( Vector3( far_endpoint.x,-far_endpoint.y, far_endpoint.z ) );
 	p_8points[6]=p_transform.xform( Vector3(-far_endpoint.x, far_endpoint.y, far_endpoint.z ) );
 	p_8points[7]=p_transform.xform( Vector3(-far_endpoint.x,-far_endpoint.y, far_endpoint.z ) );
-	
+
 	return true;
 }
 
@@ -263,10 +263,10 @@ Vector<Plane> CameraMatrix::get_projection_planes(const Transform& p_transform)
 	 * http://www.markmorley.com/opengl/frustumculling.html
 	 * http://www2.ravensoft.com/users/ggribb/plane%20extraction.pdf
 	 */
-	 
+
 	Vector<Plane> planes;
-	
-	const float * matrix = (const float*)this->matrix;			
+
+	const float * matrix = (const float*)this->matrix;
 
 	Plane new_plane;
 
@@ -275,7 +275,7 @@ Vector<Plane> CameraMatrix::get_projection_planes(const Transform& p_transform)
 		      matrix[ 7] + matrix[ 6],
 		      matrix[11] + matrix[10],
 		      matrix[15] + matrix[14]);
-	
+
 	new_plane.normal=-new_plane.normal;
 	new_plane.normalize();
 
@@ -298,7 +298,7 @@ Vector<Plane> CameraMatrix::get_projection_planes(const Transform& p_transform)
 		      matrix[ 7] + matrix[ 4],
 		      matrix[11] + matrix[ 8],
 		      matrix[15] + matrix[12]);
-		      
+
 	new_plane.normal=-new_plane.normal;
 	new_plane.normalize();
 
@@ -310,8 +310,8 @@ Vector<Plane> CameraMatrix::get_projection_planes(const Transform& p_transform)
 		      matrix[ 7] - matrix[ 5],
 		      matrix[11] - matrix[ 9],
 		      matrix[15] - matrix[13]);
-		      
-	
+
+
 	new_plane.normal=-new_plane.normal;
 	new_plane.normalize();
 
@@ -324,10 +324,10 @@ Vector<Plane> CameraMatrix::get_projection_planes(const Transform& p_transform)
 		      matrix[11] - matrix[ 8],
 		      matrix[15] - matrix[12]);
 
-	
+
 	new_plane.normal=-new_plane.normal;
 	new_plane.normalize();
-	
+
 	planes.push_back( p_transform.xform(new_plane) );
 
 
@@ -337,12 +337,12 @@ Vector<Plane> CameraMatrix::get_projection_planes(const Transform& p_transform)
 		      matrix[11] + matrix[ 9],
 		      matrix[15] + matrix[13]);
 
-	
+
 	new_plane.normal=-new_plane.normal;
 	new_plane.normalize();
 
 	planes.push_back( p_transform.xform(new_plane) );
-	
+
 	return planes;
 }
 
@@ -356,7 +356,7 @@ CameraMatrix CameraMatrix::inverse() const {
 }
 
 void CameraMatrix::invert() {
-	
+
 	int i,j,k;
 	int pvt_i[4], pvt_j[4];            /* Locations of pivot matrix */
 	float pvt_val;                     /* Value of current pivot element */
@@ -448,7 +448,7 @@ void CameraMatrix::invert() {
 			}
 	}
 
-	
+
 }
 
 CameraMatrix::CameraMatrix() {
@@ -475,31 +475,31 @@ CameraMatrix CameraMatrix::operator*(const CameraMatrix& p_matrix) const {
 void CameraMatrix::set_light_bias() {
 
 	float *m=&matrix[0][0];
-	
-	m[0]=0.5, 
-	m[1]=0.0, 
-	m[2]=0.0, 
+
+	m[0]=0.5,
+	m[1]=0.0,
+	m[2]=0.0,
 	m[3]=0.0,
-	m[4]=0.0, 
-	m[5]=0.5, 
-	m[6]=0.0, 
+	m[4]=0.0,
+	m[5]=0.5,
+	m[6]=0.0,
 	m[7]=0.0,
-	m[8]=0.0, 
-	m[9]=0.0, 
-	m[10]=0.5, 
+	m[8]=0.0,
+	m[9]=0.0,
+	m[10]=0.5,
 	m[11]=0.0,
-	m[12]=0.5, 
-	m[13]=0.5, 
-	m[14]=0.5, 
-	m[15]=1.0;	
-		
+	m[12]=0.5,
+	m[13]=0.5,
+	m[14]=0.5,
+	m[15]=1.0;
+
 }
 
 CameraMatrix::operator String() const {
 
 	String str;
-	for (int i=0;i<4;i++) 
-		for (int j=0;j<4;j++) 
+	for (int i=0;i<4;i++)
+		for (int j=0;j<4;j++)
 			str+=String((j>0)?", ":"\n")+rtos(matrix[i][j]);
 
 	return str;
@@ -513,7 +513,7 @@ float CameraMatrix::get_aspect() const {
 }
 
 float CameraMatrix::get_fov() const {
-	const float * matrix = (const float*)this->matrix;		
+	const float * matrix = (const float*)this->matrix;
 
 	Plane right_plane=Plane(matrix[ 3] - matrix[ 0],
 			matrix[ 7] - matrix[ 4],
@@ -588,7 +588,7 @@ CameraMatrix::CameraMatrix(const Transform& p_transform) {
 
 	const Transform &tr = p_transform;
 	float *m=&matrix[0][0];
-	
+
 	m[0]=tr.basis.elements[0][0];
 	m[1]=tr.basis.elements[1][0];
 	m[2]=tr.basis.elements[2][0];
@@ -604,7 +604,7 @@ CameraMatrix::CameraMatrix(const Transform& p_transform) {
   	m[12]=tr.origin.x;
 	m[13]=tr.origin.y;
 	m[14]=tr.origin.z;
-	m[15]=1.0;		
+	m[15]=1.0;
 }
 
 CameraMatrix::~CameraMatrix()
diff --git a/core/math/camera_matrix.h b/core/math/camera_matrix.h
index 27500a545e..d192b1fef1 100644
--- a/core/math/camera_matrix.h
+++ b/core/math/camera_matrix.h
@@ -48,8 +48,8 @@ struct CameraMatrix {
 	};
 
  	float matrix[4][4];
-		
-		
+
+
 	void set_identity();
 	void set_zero();
 	void set_light_bias();
@@ -67,12 +67,12 @@ struct CameraMatrix {
 	float get_z_near() const;
 	float get_aspect() const;
 	float get_fov() const;
-	
+
 	Vector<Plane> get_projection_planes(const Transform& p_transform) const;
-	
+
 	bool get_endpoints(const Transform& p_transform,Vector3 *p_8points) const;
 	void get_viewport_size(float& r_width, float& r_height) const;
-	
+
 	void invert();
 	CameraMatrix inverse() const;
 
@@ -80,15 +80,15 @@ struct CameraMatrix {
 
 	Plane xform4(const Plane& p_vec4);
 	_FORCE_INLINE_ Vector3 xform(const Vector3& p_vec3) const;
-	
+
 	operator String() const;
 
 	void scale_translate_to_fit(const AABB& p_aabb);
 	void make_scale(const Vector3 &p_scale);
 	operator Transform() const;
 
-	CameraMatrix();	
-	CameraMatrix(const Transform& p_transform);	
+	CameraMatrix();
+	CameraMatrix(const Transform& p_transform);
 	~CameraMatrix();
 
 };
diff --git a/core/math/face3.h b/core/math/face3.h
index c36fdd1332..bc34be9935 100644
--- a/core/math/face3.h
+++ b/core/math/face3.h
@@ -55,7 +55,7 @@ public:
          * @param _epsilon constant used for numerical error rounding, to add "thickness" to the plane (so coplanar points can happen)
          * @return amount of faces generated by the split, either 0 (means no split possible), 2 or 3
          */
-                  
+
         int split_by_plane(const Plane& p_plane,Face3 *p_res,bool *p_is_point_over) const;
 
 	Plane get_plane(ClockDirection p_dir=CLOCKWISE) const;
@@ -77,7 +77,7 @@ public:
 
         void get_support(const Vector3& p_normal,const Transform& p_transform,Vector3 *p_vertices,int* p_count,int p_max) const;
         void project_range(const Vector3& p_normal,const Transform& p_transform,float& r_min, float& r_max) const;
-        
+
         AABB get_aabb() const {
 
                 AABB aabb( vertex[0], Vector3() );
diff --git a/core/math/geometry.cpp b/core/math/geometry.cpp
index 2905d26fe5..5b767212f5 100644
--- a/core/math/geometry.cpp
+++ b/core/math/geometry.cpp
@@ -211,7 +211,7 @@ DVector< DVector< Face3 > > Geometry::separate_objects( DVector< Face3 > p_array
 	int len = p_array.size();
 
 	DVector<Face3>::Read r=p_array.read();
-	
+
 	const Face3* arrayptr = r.ptr();
 
 	DVector< _FaceClassify> fc;
@@ -219,7 +219,7 @@ DVector< DVector< Face3 > > Geometry::separate_objects( DVector< Face3 > p_array
 	fc.resize( len );
 
 	DVector< _FaceClassify >::Write fcw=fc.write();
-	
+
 	_FaceClassify * _fcptr = fcw.ptr();
 
 	for (int i=0;i<len;i++) {
@@ -278,7 +278,7 @@ DVector< DVector< Face3 > > Geometry::separate_objects( DVector< Face3 > p_array
 /*** GEOMETRY WRAPPER ***/
 
 enum _CellFlags {
-	
+
 	_CELL_SOLID=1,
  	_CELL_EXTERIOR=2,
   	_CELL_STEP_MASK=0x1C,
@@ -299,7 +299,7 @@ enum _CellFlags {
 	_CELL_PREV_Z_POS=5<<5,
 	_CELL_PREV_Z_NEG=6<<5,
 	_CELL_PREV_FIRST=7<<5,
-	
+
 };
 
 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) {
@@ -316,9 +316,9 @@ static inline void _plot_face(uint8_t*** p_cell_status,int x,int y,int z,int len
 		p_cell_status[x][y][z]=_CELL_SOLID;
 		return;
 	}
-	
-	
- 
+
+
+
 	int div_x=len_x>1?2:1;
 	int div_y=len_y>1?2:1;
 	int div_z=len_z>1?2:1;
@@ -343,14 +343,14 @@ static inline void _plot_face(uint8_t*** p_cell_status,int x,int y,int z,int len
 	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);
@@ -365,39 +365,39 @@ static inline void _mark_outside(uint8_t*** p_cell_status,int x,int y,int z,int
 
 	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];
-		
+
 		//printf("at %i,%i,%i\n",x,y,z);
-		
-		if ( (c&_CELL_STEP_MASK)==_CELL_STEP_NONE) {	
+
+		if ( (c&_CELL_STEP_MASK)==_CELL_STEP_NONE) {
 			/* Haven't been in here, mark as outside */
 			p_cell_status[x][y][z]|=_CELL_EXTERIOR;
 			//printf("not marked as anything, marking exterior\n");
 		}
-		
+
 		//printf("cell step is %i\n",(c&_CELL_STEP_MASK));
-		
+
 		if ( (c&_CELL_STEP_MASK)!=_CELL_STEP_DONE) {
 			/* if not done, increase step */
 			c+=1<<2;
 			//printf("incrementing cell step\n");
 		}
-		
+
 		if ( (c&_CELL_STEP_MASK)==_CELL_STEP_DONE) {
 			/* Go back */
 			//printf("done, going back a cell\n");
-			
+
 			switch(c&_CELL_PREV_MASK) {
 				case _CELL_PREV_FIRST: {
-					//printf("at end, finished marking\n");				
+					//printf("at end, finished marking\n");
 					return;
 				} break;
-				case _CELL_PREV_Y_POS: {	
+				case _CELL_PREV_Y_POS: {
 					y++;
 					ERR_FAIL_COND(y>=len_y);
 				} break;
@@ -427,16 +427,16 @@ static inline void _mark_outside(uint8_t*** p_cell_status,int x,int y,int z,int
 			}
 			continue;
 		}
-		
+
 		//printf("attempting new cell!\n");
-		
+
 		int next_x=x,next_y=y,next_z=z;
 		uint8_t prev=0;
-		
+
 		switch(c&_CELL_STEP_MASK) {
-			
+
 			case _CELL_STEP_Y_POS: {
-				
+
 				next_y++;
 				prev=_CELL_PREV_Y_NEG;
 			} break;
@@ -454,32 +454,32 @@ static inline void _mark_outside(uint8_t*** p_cell_status,int x,int y,int z,int
 			} break;
 			case _CELL_STEP_Z_POS: {
 				next_z++;
-				prev=_CELL_PREV_Z_NEG;				
+				prev=_CELL_PREV_Z_NEG;
 			} break;
 			case _CELL_STEP_Z_NEG: {
 				next_z--;
-				prev=_CELL_PREV_Z_POS;				
+				prev=_CELL_PREV_Z_POS;
 			} break;
-			default: ERR_FAIL(); 
-			
+			default: ERR_FAIL();
+
 		}
-		
+
 		//printf("testing if new cell will be ok...!\n");
-		
+
 		if (next_x<0 || next_x>=len_x)
 			continue;
 		if (next_y<0 || next_y>=len_y)
 			continue;
 		if (next_z<0 || next_z>=len_z)
 			continue;
-			
+
 		//printf("testing if new cell is traversable\n");
-			
+
 		if (p_cell_status[next_x][next_y][next_z]&3)
 			continue;
-		
+
 		//printf("move to it\n");
-		
+
 		x=next_x;
 		y=next_y;
 		z=next_z;
@@ -488,14 +488,14 @@ static inline void _mark_outside(uint8_t*** p_cell_status,int x,int y,int z,int
 }
 
 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,DVector<Face3>& p_faces) {
-	
+
 	ERR_FAIL_INDEX(x,len_x);
 	ERR_FAIL_INDEX(y,len_y);
 	ERR_FAIL_INDEX(z,len_z);
-	
+
 	if (p_cell_status[x][y][z]&_CELL_EXTERIOR)
-		return;	
-	
+		return;
+
 /*	static const Vector3 vertices[8]={
 		Vector3(0,0,0),
 		Vector3(0,0,1),
@@ -510,73 +510,73 @@ static inline void _build_faces(uint8_t*** p_cell_status,int x,int y,int z,int l
 #define vert(m_idx) Vector3( (m_idx&4)>>2, (m_idx&2)>>1, m_idx&1 )
 
 	static const uint8_t indices[6][4]={
-		{7,6,4,5},		
+		{7,6,4,5},
 		{7,3,2,6},
-		{7,5,1,3},				
-		{0,2,3,1},			
-		{0,1,5,4},		
+		{7,5,1,3},
+		{0,2,3,1},
+		{0,1,5,4},
 		{0,4,6,2},
 
 	};
-/*	
+/*
 
-		{0,1,2,3},			
-		{0,1,4,5},		
+		{0,1,2,3},
+		{0,1,4,5},
 		{0,2,4,6},
-		{4,5,6,7},		
+		{4,5,6,7},
 		{2,3,7,6},
-		{1,3,5,7},				
+		{1,3,5,7},
 
-		{0,2,3,1},			
-		{0,1,5,4},		
+		{0,2,3,1},
+		{0,1,5,4},
 		{0,4,6,2},
-		{7,6,4,5},		
+		{7,6,4,5},
 		{7,3,2,6},
-		{7,5,1,3},				
+		{7,5,1,3},
 */
-	
+
 	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);
 		int disp_z=z+(((i-2)%3)==0?((i<3)?1:-1):0);
-		
+
 		bool plot=false;
-		
+
 		if (disp_x<0 || disp_x>=len_x)
 			plot=true;
 		if (disp_y<0 || disp_y>=len_y)
 			plot=true;
 		if (disp_z<0 || disp_z>=len_z)
 			plot=true;
-		
+
 		if (!plot && (p_cell_status[disp_x][disp_y][disp_z]&_CELL_EXTERIOR))
 			plot=true;
-			
+
 		if (!plot)
 			continue;
-		
+
 		for (int j=0;j<4;j++)
 			face_points[j]=vert( indices[i][j] ) + Vector3(x,y,z);
-		
-		p_faces.push_back( 
-			Face3( 
+
+		p_faces.push_back(
+			Face3(
 				face_points[0],
 				face_points[1],
 				face_points[2]
 			     )
 		);
-    
-		p_faces.push_back( 
-			Face3( 
+
+		p_faces.push_back(
+			Face3(
 				face_points[2],
 				face_points[3],
 				face_points[0]
 			     )
 		);
-		
-	}	
+
+	}
 
 }
 
@@ -601,7 +601,7 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro
 			global_aabb.merge_with( faces[i].get_aabb() );
 		}
 	}
-	
+
 	global_aabb.grow_by(0.01); // avoid numerical error
 
 	// determine amount of cells in grid axis
@@ -649,7 +649,7 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro
 
 	// plot faces into cells
 	print_line("Wrapper (1/6): Plotting Faces");
-	
+
 	for (int i=0;i<face_count;i++) {
 
 		Face3 f=faces[i];
@@ -666,68 +666,68 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro
 	print_line("Wrapper (2/6) Flood Filling");
 
 	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);
 		}
 	}
-	
+
 	// build faces for the inside-outside cell divisors
-	
+
 	print_line("Wrapper (3/6): Building Faces");
 
 	DVector<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);				
+
+				_build_faces(cell_status,i,j,k,div_x,div_y,div_z,wrapped_faces);
 			}
 		}
 	}
-	
+
 	print_line("Wrapper (4/6): Transforming Back Vertices");
 
 	// transform face vertices to global coords
-	
+
 	int wrapped_faces_count=wrapped_faces.size();
 	DVector<Face3>::Write wrapped_facesw=wrapped_faces.write();
 	Face3* wrapped_faces_ptr=wrapped_facesw.ptr();
-	
+
 	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.pos;
 		}
 	}
-	
-	// clean up grid 
+
+	// clean up grid
 	print_line("Wrapper (5/6): Grid Cleanup");
 
 	for(int i=0;i<div_x;i++) {
@@ -736,14 +736,14 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro
 
 			memdelete_arr( cell_status[i][j] );
 		}
-		
+
 		memdelete_arr( cell_status[i] );
 	}
-	
+
 	memdelete_arr(cell_status);
 	if (p_error)
 		*p_error=voxelsize.length();
-	
+
 	print_line("Wrapper (6/6): Finished.");
 	return wrapped_faces;
 }
@@ -751,67 +751,67 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro
 Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) {
 
 	MeshData mesh;
-	
-	
+
+
 #define SUBPLANE_SIZE 1024.0
-	
+
 	float 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);
-		
+
 		if (ABS(p.normal.dot(ref))>0.95)
 			ref=Vector3(0.0,0.0,1.0); // change axis
-			
+
 		Vector3 right = p.normal.cross(ref).normalized();
 		Vector3 up = p.normal.cross( right ).normalized();
-				
+
 		Vector< Vector3 > vertices;
-		
+
 		Vector3 center = p.get_any_point();
 		// make a quad clockwise
 		vertices.push_back( center - up * subplane_size + right * subplane_size );
 		vertices.push_back( center - up * subplane_size - right * subplane_size );
 		vertices.push_back( center + up * subplane_size - right * subplane_size );
 		vertices.push_back( center + up * subplane_size + right * subplane_size );
-		
+
 		for (int j=0;j<p_planes.size();j++) {
 
 			if (j==i)
 				continue;
-			
+
 
 			Vector< Vector3 > new_vertices;
 			Plane clip=p_planes[j];
-			
+
 			if (clip.normal.dot(p.normal)>0.95)
 				continue;
-				
+
 			if (vertices.size()<3)
 				break;
-				
+
 			for(int k=0;k<vertices.size();k++) {
-			
+
 				int k_n=(k+1)%vertices.size();
-				
+
 				Vector3 edge0_A=vertices[k];
 				Vector3 edge1_A=vertices[k_n];
-				
+
 				real_t dist0 = clip.distance_to(edge0_A);
 				real_t dist1 = clip.distance_to(edge1_A);
-				
-							
-				if ( dist0 <= 0 ) { // behind plane 
-				
-					new_vertices.push_back(vertices[k]);					
+
+
+				if ( dist0 <= 0 ) { // behind plane
+
+					new_vertices.push_back(vertices[k]);
 				}
-				
-				
+
+
 				// check for different sides and non coplanar
-				if ( (dist0*dist1) < 0) { 
-					
+				if ( (dist0*dist1) < 0) {
+
 					// calculate intersection
 					Vector3 rel = edge1_A - edge0_A;
 
@@ -822,55 +822,55 @@ Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) {
 					real_t dist=-(clip.normal.dot( edge0_A )-clip.d)/den;
 					Vector3 inters = edge0_A+rel*dist;
 					new_vertices.push_back(inters);
-				}			
+				}
 			}
-			
+
 			vertices=new_vertices;
 		}
-		
+
 		if (vertices.size()<3)
 			continue;
-		
-		
+
+
 		//result is a clockwise face
-		
+
 		MeshData::Face face;
-				
+
 		// 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]);
 			}
-			
+
 			face.indices.push_back(idx);
 		}
 		face.plane=p;
 		mesh.faces.push_back(face);
-		
+
 		//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;
@@ -878,9 +878,9 @@ Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) {
 				if (mesh.edges[k].b==a && mesh.edges[k].a==b) {
 					found=true;
 					break;
-				}				
+				}
 			}
-			
+
 			if (found)
 				continue;
 			MeshData::Edge edge;
@@ -888,8 +888,8 @@ Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) {
 			edge.b=b;
 			mesh.edges.push_back(edge);
 		}
-		
-		
+
+
 	}
 
 	return mesh;
@@ -899,36 +899,36 @@ Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) {
 DVector<Plane> Geometry::build_box_planes(const Vector3& p_extents) {
 
 	DVector<Plane> planes;
-	
+
 	planes.push_back( Plane( Vector3(1,0,0), p_extents.x ) );
 	planes.push_back( Plane( Vector3(-1,0,0), p_extents.x ) );
 	planes.push_back( Plane( Vector3(0,1,0), p_extents.y ) );
 	planes.push_back( Plane( Vector3(0,-1,0), p_extents.y ) );
 	planes.push_back( Plane( Vector3(0,0,1), p_extents.z ) );
 	planes.push_back( Plane( Vector3(0,0,-1), p_extents.z ) );
-	
+
 	return planes;
 }
 
 DVector<Plane> Geometry::build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis) {
 
 	DVector<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);
-		
+
 		planes.push_back( Plane( normal, p_radius ) );
 	}
-	
+
 	Vector3 axis;
 	axis[p_axis]=1.0;
-	
+
 	planes.push_back( Plane( axis, p_height*0.5 ) );
 	planes.push_back( Plane( -axis, p_height*0.5 ) );
-	
+
 	return planes;
 
 }
@@ -972,34 +972,34 @@ DVector<Plane> Geometry::build_sphere_planes(float p_radius, int p_lats,int p_lo
 DVector<Plane> Geometry::build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis) {
 
 	DVector<Plane> planes;
-	
+
 		Vector3 axis;
 	axis[p_axis]=1.0;
-	
-	Vector3 axis_neg;	
+
+	Vector3 axis_neg;
 	axis_neg[(p_axis+1)%3]=1.0;
 	axis_neg[(p_axis+2)%3]=1.0;
 	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);
-		
+
 		planes.push_back( Plane( normal, p_radius ) );
-		
+
 		for (int j=1;j<=p_lats;j++) {
-			
+
 			Vector3 angle = normal.linear_interpolate(axis,j/(float)p_lats).normalized();
 			Vector3 pos = axis*p_height*0.5 + angle*p_radius;
 			planes.push_back( Plane( pos, angle ) );
 			planes.push_back( Plane( pos * axis_neg, angle * axis_neg) );
-			
+
 		}
 	}
 
-		
+
 	return planes;
 
 }
diff --git a/core/math/geometry.h b/core/math/geometry.h
index 8370990d6e..b353423851 100644
--- a/core/math/geometry.h
+++ b/core/math/geometry.h
@@ -44,7 +44,7 @@
 class Geometry {
 	Geometry();
 public:
-	
+
 
 
 
@@ -201,37 +201,37 @@ public:
 		real_t a =e1.dot(h);
 		if (a>-CMP_EPSILON && a < CMP_EPSILON) // parallel test
 			return false;
-				
+
 		real_t f=1.0/a;
-		
+
 		Vector3 s=p_from-p_v0;
 		real_t u = f * s.dot(h);
-		
+
 		if ( u< 0.0 || u > 1.0)
 			return false;
-		
+
 		Vector3 q=s.cross(e1);
-		
+
 		real_t v = f * p_dir.dot(q);
-		
+
 		if (v < 0.0 || u + v > 1.0)
 			return false;
-		
-		// at this stage we can compute t to find out where 
+
+		// at this stage we can compute t to find out where
 		// the intersection point is on the line
 		real_t t = f * e2.dot(q);
-		
+
 		if (t > 0.00001) {// ray intersection
 			if (r_res)
 				*r_res=p_from+p_dir*t;
 			return true;
-		} else // this means that there is a line intersection  
+		} else // this means that there is a line intersection
 			// but not a ray intersection
 			return false;
-	}	
-	
+	}
+
 	static inline bool segment_intersects_triangle( const Vector3& p_from, const Vector3& p_to, const Vector3& p_v0,const Vector3& p_v1,const Vector3& p_v2,Vector3* r_res=0) {
-	
+
 		Vector3 rel=p_to-p_from;
 		Vector3 e1=p_v1-p_v0;
 		Vector3 e2=p_v2-p_v0;
@@ -239,34 +239,34 @@ public:
 		real_t a =e1.dot(h);
 		if (a>-CMP_EPSILON && a < CMP_EPSILON) // parallel test
 			return false;
-				
+
 		real_t f=1.0/a;
-		
+
 		Vector3 s=p_from-p_v0;
 		real_t u = f * s.dot(h);
-		
+
 		if ( u< 0.0 || u > 1.0)
 			return false;
-		
+
 		Vector3 q=s.cross(e1);
-		
+
 		real_t v = f * rel.dot(q);
-		
+
 		if (v < 0.0 || u + v > 1.0)
 			return false;
-		
-		// at this stage we can compute t to find out where 
+
+		// at this stage we can compute t to find out where
 		// the intersection point is on the line
 		real_t t = f * e2.dot(q);
-		
+
 		if (t > CMP_EPSILON && t<=1.0) {// ray intersection
 			if (r_res)
 				*r_res=p_from+rel*t;
 			return true;
-		} else // this means that there is a line intersection  
+		} else // this means that there is a line intersection
 			// but not a ray intersection
 			return false;
-	}	
+	}
 
 	static inline bool segment_intersects_sphere( const Vector3& p_from, const Vector3& p_to, const Vector3& p_sphere_pos,real_t p_sphere_radius,Vector3* r_res=0,Vector3 *r_norm=0) {
 
@@ -356,24 +356,24 @@ public:
 			real_t box_end=size[i];
 			real_t cmin,cmax;
 
-	
+
 			if (seg_from < seg_to) {
-	
+
 				if (seg_from > box_end || seg_to < box_begin)
 					return false;
 				real_t length=seg_to-seg_from;
 				cmin = (seg_from < box_begin)?((box_begin - seg_from)/length):0;
 				cmax = (seg_to > box_end)?((box_end - seg_from)/length):1;
-	
+
 			} else {
-	
+
 				if (seg_to > box_end || seg_from < box_begin)
 					return false;
 				real_t length=seg_to-seg_from;
 				cmin = (seg_from > box_end)?(box_end - seg_from)/length:0;
 				cmax = (seg_to < box_begin)?(box_begin - seg_from)/length:1;
 			}
-	
+
 			if (cmin > min) {
 				min = cmin;
 				axis=i;
@@ -468,9 +468,9 @@ public:
 		if (l<1e-10)
 			return p_segment[0]; // both points are the same, just give any
 		n/=l;
-	
+
 		float d=n.dot(p);
-	
+
 		if (d<=0.0)
 			return p_segment[0]; // before first point
 		else if (d>=l)
@@ -570,27 +570,27 @@ public:
 
 
 	static inline bool point_in_projected_triangle(const Vector3& p_point,const Vector3& p_v1,const Vector3& p_v2,const Vector3& p_v3) {
-	
-	
-		Vector3 face_n =  (p_v1-p_v3).cross(p_v1-p_v2);		
-		
-		Vector3 n1 =  (p_point-p_v3).cross(p_point-p_v2);		
-		
+
+
+		Vector3 face_n =  (p_v1-p_v3).cross(p_v1-p_v2);
+
+		Vector3 n1 =  (p_point-p_v3).cross(p_point-p_v2);
+
 		if (face_n.dot(n1)<0)
 			return false;
-			
-		Vector3 n2 =  (p_v1-p_v3).cross(p_v1-p_point);		
-		
+
+		Vector3 n2 =  (p_v1-p_v3).cross(p_v1-p_point);
+
 		if (face_n.dot(n2)<0)
 			return false;
-		
-		Vector3 n3 =  (p_v1-p_point).cross(p_v1-p_v2);		
-	
+
+		Vector3 n3 =  (p_v1-p_point).cross(p_v1-p_v2);
+
 		if (face_n.dot(n3)<0)
 			return false;
-	
+
 		return true;
-	
+
 	}
 
 	static inline bool triangle_sphere_intersection_test(const Vector3 *p_triangle,const Vector3& p_normal,const Vector3& p_sphere_pos, real_t p_sphere_radius,Vector3& r_triangle_contact,Vector3& r_sphere_contact) {
@@ -814,21 +814,21 @@ public:
 
 
 	struct MeshData {
-		
+
 		struct Face {
 			Plane plane;
 			Vector<int> indices;
 		};
-		
+
 		Vector<Face> faces;
-		
+
 		struct Edge {
-		
+
 			int a,b;
 		};
-		
+
 		Vector<Edge> edges;
-		
+
 		Vector< Vector3 > vertices;
 
 		void optimize_vertices();
@@ -927,7 +927,7 @@ public:
 
 	static void make_atlas(const Vector<Size2i>& p_rects,Vector<Point2i>& r_result, Size2i& r_size);
 
-	
+
 };
 
 
diff --git a/core/math/math_2d.cpp b/core/math/math_2d.cpp
index a485125cb4..0e2060008c 100644
--- a/core/math/math_2d.cpp
+++ b/core/math/math_2d.cpp
@@ -45,10 +45,10 @@ float Vector2::length_squared() const {
 }
 
 void Vector2::normalize() {
-	
+
 	float l = x*x + y*y;
 	if (l!=0) {
-		
+
 		l=Math::sqrt(l);
 		x/=l;
 		y/=l;
@@ -56,14 +56,14 @@ void Vector2::normalize() {
 }
 
 Vector2 Vector2::normalized() const {
-	
+
 	Vector2 v=*this;
 	v.normalize();
 	return v;
 }
 
 float Vector2::distance_to(const Vector2& p_vector2) const {
-	
+
 	return Math::sqrt( (x-p_vector2.x)*(x-p_vector2.x) + (y-p_vector2.y)*(y-p_vector2.y));
 }
 
@@ -73,7 +73,7 @@ float Vector2::distance_squared_to(const Vector2& p_vector2) const {
 }
 
 float Vector2::angle_to(const Vector2& p_vector2) const  {
-	
+
 	return Math::atan2( tangent().dot(p_vector2), dot(p_vector2) );
 }
 
@@ -83,7 +83,7 @@ float Vector2::angle_to_point(const Vector2& p_vector2) const  {
 }
 
 float Vector2::dot(const Vector2& p_other) const {
-	
+
 	return x*p_other.x + y*p_other.y;
 }
 
@@ -99,62 +99,62 @@ Vector2 Vector2::cross(real_t p_other) const {
 
 
 Vector2 Vector2::operator+(const Vector2& p_v) const {
-	
+
 	return Vector2(x+p_v.x,y+p_v.y);
 }
 void Vector2::operator+=(const Vector2& p_v) {
-	
+
 	x+=p_v.x; y+=p_v.y;
 }
 Vector2 Vector2::operator-(const Vector2& p_v) const {
-	
+
 	return Vector2(x-p_v.x,y-p_v.y);
 }
 void Vector2::operator-=(const Vector2& p_v) {
-	
+
 	x-=p_v.x; y-=p_v.y;
 }
 
 Vector2 Vector2::operator*(const Vector2 &p_v1) const {
-	
+
 	return Vector2(x * p_v1.x, y * p_v1.y);
 };
 
 Vector2 Vector2::operator*(const float &rvalue) const {
-	
+
 	return Vector2(x * rvalue, y * rvalue);
 };
 void Vector2::operator*=(const float &rvalue) {
-	
+
 	x *= rvalue; y *= rvalue;
 };
 
 Vector2 Vector2::operator/(const Vector2 &p_v1) const {
-	
+
 	return Vector2(x / p_v1.x, y / p_v1.y);
 };
 
 Vector2 Vector2::operator/(const float &rvalue) const {
-	
+
 	return Vector2(x / rvalue, y / rvalue);
 };
 
 void Vector2::operator/=(const float &rvalue) {
-	
+
 	x /= rvalue; y /= rvalue;
 };
 
 Vector2 Vector2::operator-() const {
-	
+
 	return Vector2(-x,-y);
 }
 
 bool Vector2::operator==(const Vector2& p_vec2) const {
-	
+
 	return x==p_vec2.x && y==p_vec2.y;
 }
 bool Vector2::operator!=(const Vector2& p_vec2) const {
-	
+
 	return x!=p_vec2.x || y!=p_vec2.y;
 }
 Vector2 Vector2::floor() const {
@@ -621,25 +621,25 @@ float Matrix32::basis_determinant() const {
 }
 
 Matrix32 Matrix32::interpolate_with(const Matrix32& p_transform, float p_c) const {
-	
+
 	//extract parameters
 	Vector2 p1 = get_origin();
 	Vector2 p2 = p_transform.get_origin();
-	
+
 	real_t r1 = get_rotation();
 	real_t r2 = p_transform.get_rotation();
-	
+
 	Vector2 s1 = get_scale();
 	Vector2 s2 = p_transform.get_scale();
-	
+
 	//slerp rotation
 	Vector2 v1(Math::cos(r1), Math::sin(r1));
 	Vector2 v2(Math::cos(r2), Math::sin(r2));
-	
+
 	real_t dot = v1.dot(v2);
-	
+
 	dot = (dot < -1.0) ? -1.0 : ((dot > 1.0) ? 1.0 : dot); //clamp dot to [-1,1]
-	
+
 	Vector2 v;
 
 	if (dot > 0.9995) {
@@ -649,7 +649,7 @@ Matrix32 Matrix32::interpolate_with(const Matrix32& p_transform, float p_c) cons
 		Vector2 v3 = (v2 - v1*dot).normalized();
 		v = v1*Math::cos(angle) + v3*Math::sin(angle);
 	}
-	
+
 	//construct matrix
 	Matrix32 res(Math::atan2(v.y, v.x), Vector2::linear_interpolate(p1, p2, p_c));
 	res.scale_basis(Vector2::linear_interpolate(s1, s2, p_c));
diff --git a/core/math/math_2d.h b/core/math/math_2d.h
index 1171364671..ad4655b8f7 100644
--- a/core/math/math_2d.h
+++ b/core/math/math_2d.h
@@ -35,15 +35,15 @@
 	@author Juan Linietsky <reduzio@gmail.com>
 */
 enum Margin {
-	
+
 	MARGIN_LEFT,
 	MARGIN_TOP,
 	MARGIN_RIGHT,
-	MARGIN_BOTTOM	
+	MARGIN_BOTTOM
 };
 
 enum Orientation {
-	
+
 	HORIZONTAL,
 	VERTICAL
 };
@@ -63,7 +63,7 @@ enum VAlign {
 };
 
 struct Vector2 {
-	
+
 	union {
 		float x;
 		float width;
@@ -87,7 +87,7 @@ struct Vector2 {
 	float length() const;
 	float length_squared() const;
 
-	float distance_to(const Vector2& p_vector2) const; 
+	float distance_to(const Vector2& p_vector2) const;
 	float distance_squared_to(const Vector2& p_vector2) const;
 	float angle_to(const Vector2& p_vector2) const;
 	float angle_to_point(const Vector2& p_vector2) const;
@@ -114,19 +114,19 @@ struct Vector2 {
 	Vector2 operator-(const Vector2& p_v) const;
 	void operator-=(const Vector2& p_v);
 	Vector2 operator*(const Vector2 &p_v1) const;
-	
+
 	Vector2 operator*(const float &rvalue) const;
 	void operator*=(const float &rvalue);
 	void operator*=(const Vector2 &rvalue) { *this = *this * rvalue; }
 
 	Vector2 operator/(const Vector2 &p_v1) const;
-	
+
 	Vector2 operator/(const float &rvalue) const;
-	
+
 	void operator/=(const float &rvalue);
-	
+
 	Vector2 operator-() const;
-	
+
 	bool operator==(const Vector2& p_vec2) const;
 	bool operator!=(const Vector2& p_vec2) const;
 
@@ -151,14 +151,14 @@ struct Vector2 {
 
 		return Vector2(y,-x);
 	}
-	
+
 	Vector2 floor() const;
 	Vector2 snapped(const Vector2& p_by) const;
 	float get_aspect() const { return width/height; }
 
-	
+
 	operator String() const { return String::num(x)+","+String::num(y); }
-	
+
 	_FORCE_INLINE_ Vector2(float p_x,float p_y) { x=p_x; y=p_y; }
 	_FORCE_INLINE_ Vector2() { x=0; y=0; }
 };
@@ -202,7 +202,7 @@ struct Matrix32;
 
 
 struct Rect2 {
-	
+
 	Point2 pos;
 	Size2 size;
 
@@ -213,7 +213,7 @@ struct Rect2 {
 
 	float get_area() const { return size.width*size.height; }
 
-	inline bool intersects(const Rect2& p_rect) const { 
+	inline bool intersects(const Rect2& p_rect) const {
 		if ( pos.x >= (p_rect.pos.x + p_rect.size.width) )
 			return false;
 		if ( (pos.x+size.width) <= p_rect.pos.x  )
@@ -222,7 +222,7 @@ struct Rect2 {
 			return false;
 		if ( (pos.y+size.height) <= p_rect.pos.y  )
 			return false;
-		
+
 		return true;
 	}
 
@@ -254,73 +254,73 @@ struct Rect2 {
 	bool intersects_segment(const Point2& p_from, const Point2& p_to, Point2* r_pos=NULL, Point2* r_normal=NULL) const;
 
 	inline bool encloses(const Rect2& p_rect) const {
-		
+
 		return 	(p_rect.pos.x>=pos.x) && (p_rect.pos.y>=pos.y) &&
 			((p_rect.pos.x+p_rect.size.x)<(pos.x+size.x)) &&
 			((p_rect.pos.y+p_rect.size.y)<(pos.y+size.y));
-		
+
 	}
-	
+
 	inline bool has_no_area() const {
-		
+
 		return (size.x<=0 || size.y<=0);
-		
+
 	}
 	inline Rect2 clip(const Rect2& p_rect) const { /// return a clipped rect
-		
+
 		Rect2 new_rect=p_rect;
-		
+
 		if (!intersects( new_rect ))
 			return Rect2();
-		
+
 		new_rect.pos.x = MAX( p_rect.pos.x , pos.x );
 		new_rect.pos.y = MAX( p_rect.pos.y , pos.y );
-		
+
 		Point2 p_rect_end=p_rect.pos+p_rect.size;
 		Point2 end=pos+size;
-		
+
 		new_rect.size.x=MIN(p_rect_end.x,end.x) - new_rect.pos.x;
 		new_rect.size.y=MIN(p_rect_end.y,end.y) - new_rect.pos.y;
-		
+
 		return new_rect;
 	}
-	
+
 	inline Rect2 merge(const Rect2& p_rect) const { ///< return a merged rect
-		
+
 		Rect2 new_rect;
-		
+
 		new_rect.pos.x=MIN( p_rect.pos.x , pos.x );
 		new_rect.pos.y=MIN( p_rect.pos.y , pos.y );
-		
-		
+
+
 		new_rect.size.x = MAX( p_rect.pos.x+p_rect.size.x , pos.x+size.x );
 		new_rect.size.y = MAX( p_rect.pos.y+p_rect.size.y , pos.y+size.y );
-		
+
 		new_rect.size = new_rect.size - new_rect.pos; //make relative again
-		
+
 		return new_rect;
 	};
 	inline bool has_point(const Point2& p_point) const {
 		if (p_point.x < pos.x)
-			return false; 
+			return false;
 		if (p_point.y < pos.y)
-			return false; 
-		
+			return false;
+
 		if (p_point.x >= (pos.x+size.x) )
-			return false; 
+			return false;
 		if (p_point.y >= (pos.y+size.y) )
-			return false; 
-		
+			return false;
+
 		return true;
 	}
-	
+
 	inline bool no_area() const { return (size.width<=0 || size.height<=0 ); }
-	
+
 	bool operator==(const Rect2& p_rect) const { return pos==p_rect.pos && size==p_rect.size; }
 	bool operator!=(const Rect2& p_rect) const { return pos!=p_rect.pos || size!=p_rect.size; }
-	
+
 	inline Rect2 grow(real_t p_by) const {
-		
+
 		Rect2 g=*this;
 		g.pos.x-=p_by;
 		g.pos.y-=p_by;
@@ -357,9 +357,9 @@ struct Rect2 {
 
 
 	operator String() const { return String(pos)+","+String(size); }
-	
+
 	Rect2() {}
-	Rect2( float p_x, float p_y, float p_width, float p_height) { pos=Point2(p_x,p_y); size=Size2( p_width, p_height ); }   
+	Rect2( float p_x, float p_y, float p_width, float p_height) { pos=Point2(p_x,p_y); size=Size2( p_width, p_height ); }
 	Rect2( const Point2& p_pos, const Size2& p_size ) { pos=p_pos; size=p_size; }
 };
 
diff --git a/core/math/math_funcs.cpp b/core/math/math_funcs.cpp
index 20d9db3375..07f114725d 100644
--- a/core/math/math_funcs.cpp
+++ b/core/math/math_funcs.cpp
@@ -185,12 +185,12 @@ double Math::fmod(double p_x,double p_y) {
 double Math::fposmod(double p_x,double p_y) {
 
 	if (p_x>=0) {
-	
+
 		return Math::fmod(p_x,p_y);
-		
+
 	} else {
-	
-		return p_y-Math::fmod(-p_x,p_y); 
+
+		return p_y-Math::fmod(-p_x,p_y);
 	}
 
 }
@@ -205,7 +205,7 @@ double Math::ceil(double p_x) {
 }
 
 int Math::decimals(double p_step) {
-	
+
 	int max=4;
 	double llimit = Math::pow(0.1,max);
 	double ulimit = 1.0-llimit;
@@ -220,7 +220,7 @@ int Math::decimals(double p_step) {
 		max--;
 		i++;
 	}
-	
+
 	return i;
 
 }
@@ -251,11 +251,11 @@ double Math::ease(double p_x, double p_c) {
 }
 
 double Math::stepify(double p_value,double p_step) {
-	
+
 	if (p_step!=0) {
-		
-		p_value=floor( p_value / p_step + 0.5 ) * p_step;		
-	}	
+
+		p_value=floor( p_value / p_step + 0.5 ) * p_step;
+	}
 	return p_value;
 }
 
diff --git a/core/math/math_funcs.h b/core/math/math_funcs.h
index 62890b0371..2e1b9c989e 100644
--- a/core/math/math_funcs.h
+++ b/core/math/math_funcs.h
@@ -91,25 +91,25 @@ public:
 
 	static uint32_t rand();
 	static double randf();
-	
+
 	static double round(double p_val);
 
 	static double random(double from, double to);
-	
+
 
 	static _FORCE_INLINE_ real_t abs(real_t g) {
 
-#ifdef REAL_T_IS_DOUBLE	
-	
-		return absd(g);		
+#ifdef REAL_T_IS_DOUBLE
+
+		return absd(g);
 #else
 
-		return absf(g);		
+		return absf(g);
 #endif
 	}
 
 	static _FORCE_INLINE_ float absf(float g) {
-		
+
 		union {
 			float f;
 			uint32_t i;
@@ -174,7 +174,7 @@ public:
 	static double pow(double x, double y);
 	static double log(double x);
 	static double exp(double x);
-	
+
 };
 
 
diff --git a/core/math/matrix3.cpp b/core/math/matrix3.cpp
index f51da80a83..71e6b62212 100644
--- a/core/math/matrix3.cpp
+++ b/core/math/matrix3.cpp
@@ -62,11 +62,11 @@ void Matrix3::invert() {
 	real_t det =	elements[0][0] * co[0]+
 			elements[0][1] * co[1]+
 			elements[0][2] * co[2];
-	
+
 	ERR_FAIL_COND( det == 0 );
 	real_t s = 1.0/det;
-	
-	set(  co[0]*s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s, 
+
+	set(  co[0]*s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
 	      co[1]*s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
 	      co[2]*s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s );
 
@@ -148,7 +148,7 @@ Vector3 Matrix3::get_scale() const {
 		Vector3(elements[0][1],elements[1][1],elements[2][1]).length(),
 		Vector3(elements[0][2],elements[1][2],elements[2][2]).length()
 	);
-		
+
 }
 void Matrix3::rotate(const Vector3& p_axis, real_t p_phi) {
 
@@ -223,7 +223,7 @@ bool Matrix3::operator==(const Matrix3& p_matrix) const {
 				return false;
 		}
 	}
-	
+
 	return true;
 }
 bool Matrix3::operator!=(const Matrix3& p_matrix) const {
@@ -235,16 +235,16 @@ Matrix3::operator String() const {
 
 	String mtx;
 	for (int i=0;i<3;i++) {
-	
+
 		for (int j=0;j<3;j++) {
-	
+
 			if (i!=0 || j!=0)
 				mtx+=", ";
-				
+
 			mtx+=rtos( elements[i][j] );
 		}
 	}
-	
+
 	return mtx;
 }
 
@@ -255,34 +255,34 @@ Matrix3::operator Quat() const {
 
 	real_t trace = m.elements[0][0] + m.elements[1][1] + m.elements[2][2];
 	real_t temp[4];
-	
-	if (trace > 0.0) 
+
+	if (trace > 0.0)
 	{
 		real_t s = Math::sqrt(trace + 1.0);
 		temp[3]=(s * 0.5);
 		s = 0.5 / s;
-		
+
 		temp[0]=((m.elements[2][1] - m.elements[1][2]) * s);
 		temp[1]=((m.elements[0][2] - m.elements[2][0]) * s);
 		temp[2]=((m.elements[1][0] - m.elements[0][1]) * s);
-	} 
-	else 
+	}
+	else
 	{
 		int i = m.elements[0][0] < m.elements[1][1] ?
 			(m.elements[1][1] < m.elements[2][2] ? 2 : 1) :
 			(m.elements[0][0] < m.elements[2][2] ? 2 : 0);
-		int j = (i + 1) % 3;  
+		int j = (i + 1) % 3;
 		int k = (i + 2) % 3;
-		
+
 		real_t s = Math::sqrt(m.elements[i][i] - m.elements[j][j] - m.elements[k][k] + 1.0);
 		temp[i] = s * 0.5;
 		s = 0.5 / s;
-		
+
 		temp[3] = (m.elements[k][j] - m.elements[j][k]) * s;
 		temp[j] = (m.elements[j][i] + m.elements[i][j]) * s;
 		temp[k] = (m.elements[k][i] + m.elements[i][k]) * s;
 	}
-	
+
 	return Quat(temp[0],temp[1],temp[2],temp[3]);
 
 }
@@ -439,7 +439,7 @@ void Matrix3::get_axis_and_angle(Vector3 &r_axis,real_t& r_angle) const {
 Matrix3::Matrix3(const Vector3& p_euler) {
 
 	set_euler( p_euler );
-		
+
 }
 
 Matrix3::Matrix3(const Quat& p_quat) {
@@ -450,8 +450,8 @@ Matrix3::Matrix3(const Quat& p_quat) {
 	real_t wx = p_quat.w * xs,  wy = p_quat.w * ys,  wz = p_quat.w * zs;
 	real_t xx = p_quat.x * xs,  xy = p_quat.x * ys,  xz = p_quat.x * zs;
 	real_t yy = p_quat.y * ys,  yz = p_quat.y * zs,  zz = p_quat.z * zs;
-	set(	1.0 - (yy + zz), xy - wz, xz + wy, 	
-		xy + wz, 1.0 - (xx + zz), yz - wx, 
+	set(	1.0 - (yy + zz), xy - wz, xz + wy,
+		xy + wz, 1.0 - (xx + zz), yz - wx,
 		xz - wy, yz + wx, 1.0 - (xx + yy))	;
 
 }
diff --git a/core/math/matrix3.h b/core/math/matrix3.h
index 291934b8eb..e514f490f7 100644
--- a/core/math/matrix3.h
+++ b/core/math/matrix3.h
@@ -39,20 +39,20 @@ class Matrix3 {
 public:
 
 	Vector3 elements[3];
-			
+
 	_FORCE_INLINE_ const Vector3& operator[](int axis) const {
-	
+
 		return elements[axis];
 	}
 	_FORCE_INLINE_ Vector3& operator[](int axis) {
-	
+
 		return elements[axis];
 	}
 
-	void invert(); 
+	void invert();
 	void transpose();
-	
-	Matrix3 inverse() const; 
+
+	Matrix3 inverse() const;
 	Matrix3 transposed() const;
 
 	_FORCE_INLINE_ float determinant() const;
@@ -90,7 +90,7 @@ public:
 	_FORCE_INLINE_ real_t tdotz(const Vector3& v) const {
 		return elements[0][2] * v[0] + elements[1][2] * v[1] + elements[2][2] * v[2];
 	}
-	
+
 	bool operator==(const Matrix3& p_matrix) const;
 	bool operator!=(const Matrix3& p_matrix) const;
 
@@ -110,7 +110,7 @@ public:
 
 
 	_FORCE_INLINE_ void set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
-	
+
 		elements[0][0]=xx;
 		elements[0][1]=xy;
 		elements[0][2]=xz;
@@ -119,15 +119,15 @@ public:
 		elements[1][2]=yz;
 		elements[2][0]=zx;
 		elements[2][1]=zy;
-		elements[2][2]=zz;	
+		elements[2][2]=zz;
 	}
 	_FORCE_INLINE_ Vector3 get_column(int i) const {
-			
+
 		return Vector3(elements[0][i],elements[1][i],elements[2][i]);
 	}
-		
+
 	_FORCE_INLINE_ Vector3 get_row(int i) const {
-			
+
 		return Vector3(elements[i][0],elements[i][1],elements[i][2]);
 	}
 	_FORCE_INLINE_ void set_row(int i, const Vector3& p_row) {
@@ -155,8 +155,8 @@ public:
 			elements[0].z * m[0].y + elements[1].z * m[1].y + elements[2].z * m[2].y,
 			elements[0].z * m[0].z + elements[1].z * m[1].z + elements[2].z * m[2].z);
 	}
-	Matrix3(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) { 
-			
+	Matrix3(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
+
 		set(xx, xy, xz, yx, yy, yz, zx, zy, zz);
 	}
 
@@ -170,7 +170,7 @@ public:
 	Matrix3(const Vector3& p_axis, real_t p_phi);
 
 	_FORCE_INLINE_ Matrix3() {
-	
+
 		elements[0][0]=1;
 		elements[0][1]=0;
 		elements[0][2]=0;
@@ -191,7 +191,7 @@ _FORCE_INLINE_ void Matrix3::operator*=(const Matrix3& p_matrix) {
 		p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
 		p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
 		p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]));
-	
+
 }
 
 _FORCE_INLINE_ Matrix3 Matrix3::operator*(const Matrix3& p_matrix) const {
diff --git a/core/math/octree.h b/core/math/octree.h
index 69edf80e09..6080b21680 100644
--- a/core/math/octree.h
+++ b/core/math/octree.h
@@ -52,11 +52,11 @@ public:
 	typedef void* (*PairCallback)(void*,OctreeElementID, T*,int,OctreeElementID, T*,int);
 	typedef void (*UnpairCallback)(void*,OctreeElementID, T*,int,OctreeElementID, T*,int,void*);
 
-private:	
+private:
 	enum {
-	
+
 		NEG=0,
-		POS=1,		
+		POS=1,
 	};
 
 	enum {
@@ -72,7 +72,7 @@ private:
 
 
 	struct PairKey {
-	
+
 		union {
 			struct {
 				OctreeElementID A;
@@ -80,66 +80,66 @@ private:
 			};
 			uint64_t key;
 		};
-			
+
 		_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;	
+				B=p_B;
 			} else {
-			
+
 				B=p_A;
 				A=p_B;
 			}
 		}
-		
+
 		_FORCE_INLINE_ PairKey() {}
-	};	
-		
+	};
+
 	struct Element;
-		
+
 	struct Octant {
-		
+
 		// cached for FAST plane check
 		AABB aabb;
-			
+
 		uint64_t last_pass;
 		Octant *parent;
 		Octant *children[8];
-		
+
 		int children_count; // cache for amount of childrens (fast check for removal)
 		int parent_index; // cache for parent index (fast check for removal)
-	
+
 		List<Element*,AL> pairable_elements;
 		List<Element*,AL> elements;
-			
+
 		Octant() {
 			children_count=0;
 			parent_index=-1;
 			last_pass=0;
 			parent=NULL;
 			for (int i=0;i<8;i++)
-				children[i]=NULL;			
+				children[i]=NULL;
 		}
-		
+
 		~Octant() {
-			
+
 			//for (int i=0;i<8;i++)
 			//	memdelete_notnull(children[i]);
 		}
 	};
-	
+
 
 	struct PairData;
 
 	struct Element {
-		
+
 		Octree *octree;
 
 		T *userdata;
@@ -147,28 +147,28 @@ private:
 		bool pairable;
 		uint32_t pairable_mask;
 		uint32_t pairable_type;
-		
+
 		uint64_t last_pass;
 		OctreeElementID _id;
 		Octant *common_parent;
-		
+
 		AABB aabb;
 		AABB container_aabb;
 
 		List<PairData*,AL> pair_list;
-		
+
 		struct OctantOwner {
-		
+
 			Octant *octant;
 			typename List<Element*,AL>::Element *E;
-		}; // an element can be in max 8 octants 
-		
+		}; // an element can be in max 8 octants
+
 		List<OctantOwner,AL> octant_owners;
-		
-		
+
+
 		Element() { last_pass=0; _id=0; pairable=false; subindex=0; userdata=0; octree=0; pairable_mask=0; pairable_type=0; common_parent=NULL; }
 	};
-	
+
 
 	struct PairData {
 
@@ -181,15 +181,15 @@ private:
 
 	typedef Map<OctreeElementID, Element, Comparator<OctreeElementID>, AL> ElementMap;
 	typedef Map<PairKey, PairData, Comparator<PairKey>, AL> PairMap;
-	ElementMap element_map;	
-	PairMap pair_map;	
+	ElementMap element_map;
+	PairMap pair_map;
 
 	PairCallback pair_callback;
 	UnpairCallback unpair_callback;
 	void *pair_callback_userdata;
 	void *unpair_callback_userdata;
-	
-	OctreeElementID last_element_id;	
+
+	OctreeElementID last_element_id;
 	uint64_t pass;
 
 	real_t unit_size;
@@ -231,7 +231,7 @@ private:
 
 		if (p_A==p_B || (p_A->userdata==p_B->userdata && p_A->userdata))
 			return;
-			
+
 		if ( 	!(p_A->pairable_type&p_B->pairable_mask) &&
 			!(p_B->pairable_type&p_A->pairable_mask) )
 			return; // none can pair with none
@@ -253,17 +253,17 @@ private:
 //			if (pair_callback)
 //				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;
-	
+
 		PairKey key(p_A->_id, p_B->_id);
 		typename PairMap::Element *E=pair_map.find(key);
 		if (!E) {
@@ -293,7 +293,7 @@ private:
 			p_B->pair_list.erase( E->get().eB );
 			pair_map.erase(E);
 		}
-	
+
 	}
 
 	_FORCE_INLINE_ void _element_check_pairs(Element *p_element) {
@@ -341,7 +341,7 @@ private:
 	void _ensure_valid_root(const AABB& p_aabb);
 	bool _remove_element_from_octant(Element *p_element,Octant *p_octant,Octant *p_limit=NULL);
 	void _remove_element(Element *p_element);
-	void _pair_element(Element *p_element,Octant *p_octant);	
+	void _pair_element(Element *p_element,Octant *p_octant);
 	void _unpair_element(Element *p_element,Octant *p_octant);
 
 
@@ -361,16 +361,16 @@ 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]);
 		}
-		
+
 		memdelete_allocator<Octant,AL>(p_octant);
 	}
 public:
@@ -432,24 +432,24 @@ template<class T,bool use_pairs,class AL>
 void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant) {
 
 	float element_size = p_element->aabb.get_longest_axis_size() * 1.01; // avoid precision issues
-	
+
 	if (p_octant->aabb.size.x/OCTREE_DIVISOR < element_size) {
-	//if (p_octant->aabb.size.x*0.5 < element_size) {		
-		
-		/* at smallest possible size for the element  */	
+	//if (p_octant->aabb.size.x*0.5 < element_size) {
+
+		/* at smallest possible size for the element  */
 		typename Element::OctantOwner owner;
 		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();
 		}
-		
+
 		p_element->octant_owners.push_back( owner );
 
 		if (p_element->common_parent==NULL) {
@@ -461,13 +461,13 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant
 
 
 		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]);	
+					_pair_element(p_element,p_octant->children[i]);
 				}
 			}
 		}
@@ -477,7 +477,7 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant
 		bool candidate=p_element->common_parent==NULL;
 
 		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 ) ) {
@@ -486,20 +486,20 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant
 				}
 			} else {
 				/* check againt AABB where child should be */
-				
+
 				AABB aabb=p_octant->aabb;
 				aabb.size*=0.5;
-				
+
 				if (i&1)
 					aabb.pos.x+=aabb.size.x;
 				if (i&2)
 					aabb.pos.y+=aabb.size.y;
 				if (i&4)
 					aabb.pos.z+=aabb.size.z;
-				
+
 				if (aabb.intersects_inclusive( p_element->aabb) ) {
 					/* if actually intersects, create the child */
-					
+
 					Octant *child = memnew_allocator( Octant, AL );
 					p_octant->children[i]=child;
 					child->parent=p_octant;
@@ -517,14 +517,14 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant
 			}
 
 		}
-		
+
 		if (candidate && splits>1) {
 
 			p_element->common_parent=p_octant;
 		}
-		
+
 	}
-	
+
 	if (use_pairs) {
 
 		typename List<Element*,AL>::Element *E=p_octant->pairable_elements.front();
@@ -532,8 +532,8 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant
 		while(E) {
 			_pair_reference( p_element,E->get() );
 			E=E->next();
-		}		
-		
+		}
+
 		if (p_element->pairable) {
 			// and always test non-pairable if element is pairable
 			E=p_octant->elements.front();
@@ -541,9 +541,9 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant
 				_pair_reference( p_element,E->get() );
 				E=E->next();
 			}
-		}		
+		}
 	}
-	
+
 
 }
 
@@ -553,35 +553,35 @@ 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.pos.x+base.size.x) <= ABS(base.pos.x) ) {
 				/* grow towards positive */
 				base.size*=2.0;
 			} else {
-				base.pos-=base.size;				
+				base.pos-=base.size;
 				base.size*=2.0;
 			}
 		}
-		
+
 		root = memnew_allocator( Octant, AL );
 
-		root->parent=NULL;	
-		root->parent_index=-1;	
+		root->parent=NULL;
+		root->parent_index=-1;
 		root->aabb=base;
-		
+
 		octant_count++;
-		
-		
-	} else {		
-	
+
+
+	} else {
+
 		AABB base=root->aabb;
-		
+
 		while( !base.encloses( p_aabb ) ) {
-			
+
 			if (base.size.x > OCTREE_SIZE_LIMIT) {
 				ERR_EXPLAIN("Octree upper size limit reeached, does the AABB supplied contain NAN?");
 				ERR_FAIL();
@@ -590,7 +590,7 @@ void Octree<T,use_pairs,AL>::_ensure_valid_root(const AABB& p_aabb) {
 			Octant * gp = memnew_allocator( Octant, AL );
 			octant_count++;
 			root->parent=gp;
-			
+
 			if ( ABS(base.pos.x+base.size.x) <= ABS(base.pos.x) ) {
 				/* grow towards positive */
 				base.size*=2.0;
@@ -598,16 +598,16 @@ void Octree<T,use_pairs,AL>::_ensure_valid_root(const AABB& p_aabb) {
 				gp->children[0]=root;
 				root->parent_index=0;
 			} else {
-				base.pos-=base.size;				
+				base.pos-=base.size;
 				base.size*=2.0;
 				gp->aabb=base;
 				gp->children[(1<<0)|(1<<1)|(1<<2)]=root; // add at all-positive
 				root->parent_index=(1<<0)|(1<<1)|(1<<2);
 			}
-						
+
 			gp->children_count=1;
-			root=gp;			
-		}		
+			root=gp;
+		}
 	}
 }
 
@@ -615,16 +615,16 @@ 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
 			return octant_removed;
-			
+
 		bool unpaired=false;
-			
+
 		if (use_pairs && p_octant->last_pass!=pass) {
 			// check wether we should unpair stuff
 			// always test pairable
@@ -644,21 +644,21 @@ bool Octree<T,use_pairs,AL>::_remove_element_from_octant(Element *p_element,Octa
 			p_octant->last_pass=pass;
 			unpaired=true;
 		}
-	
+
 		bool removed=false;
-		
+
 		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
-							
+
 				root=NULL;
 			} else {
 				ERR_FAIL_INDEX_V(p_octant->parent_index,8,octant_removed);
-				
+
 				parent->children[ p_octant->parent_index ]=NULL;
 				parent->children_count--;
 			}
@@ -668,12 +668,12 @@ bool Octree<T,use_pairs,AL>::_remove_element_from_octant(Element *p_element,Octa
 			removed=true;
 			octant_removed=true;
 		}
-		
+
 		if (!removed && !unpaired)
 			return octant_removed; // no reason to keep going up anymore! was already visited and was not removed
-			
+
 		p_octant=parent;
-		
+
 	}
 
 	return octant_removed;
@@ -682,8 +682,8 @@ bool Octree<T,use_pairs,AL>::_remove_element_from_octant(Element *p_element,Octa
 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				
+
+	// always test pairable
 	typename List<Element*,AL>::Element *E=p_octant->pairable_elements.front();
 	while(E) {
 		if (E->get()->last_pass!=pass) { // only remove ONE reference
@@ -692,7 +692,7 @@ void Octree<T,use_pairs,AL>::_unpair_element(Element *p_element,Octant *p_octant
 		}
 		E=E->next();
 	}
-	
+
 	if (p_element->pairable) {
 		// and always test non-pairable if element is pairable
 		E=p_octant->elements.front();
@@ -704,14 +704,14 @@ void Octree<T,use_pairs,AL>::_unpair_element(Element *p_element,Octant *p_octant
 			E=E->next();
 		}
 	}
-	
+
 	p_octant->last_pass=pass;
-	
+
 	if (p_octant->children_count==0)
 		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]);
 	}
@@ -732,7 +732,7 @@ void Octree<T,use_pairs,AL>::_pair_element(Element *p_element,Octant *p_octant)
 		}
 		E=E->next();
 	}
-	
+
 	if (p_element->pairable) {
 		// and always test non-pairable if element is pairable
 		E=p_octant->elements.front();
@@ -745,12 +745,12 @@ void Octree<T,use_pairs,AL>::_pair_element(Element *p_element,Octant *p_octant)
 		}
 	}
 	p_octant->last_pass=pass;
-	
+
 	if (p_octant->children_count==0)
 		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]);
 	}
@@ -760,13 +760,13 @@ 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
@@ -809,14 +809,14 @@ void Octree<T,use_pairs,AL>::_remove_element(Element *p_element) {
 		int remaining=p_element->pair_list.size();
 		//p_element->pair_list.clear();
 		ERR_FAIL_COND( remaining );
-	}	
+	}
 
 }
 
 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 
+	// check for AABB validity
 #ifdef DEBUG_ENABLED
 	ERR_FAIL_COND_V( p_aabb.pos.x > 1e15 || p_aabb.pos.x < -1e15, 0 );
 	ERR_FAIL_COND_V( p_aabb.pos.y > 1e15 || p_aabb.pos.y < -1e15, 0 );
@@ -828,12 +828,12 @@ OctreeElementID Octree<T,use_pairs,AL>::create(T* p_userdata, const AABB& p_aabb
 	ERR_FAIL_COND_V( Math::is_nan(p_aabb.size.y) , 0 );
 	ERR_FAIL_COND_V( Math::is_nan(p_aabb.size.z) , 0 );
 
-	
+
 #endif
 	typename ElementMap::Element *E = element_map.insert(last_element_id++,
 	Element());
 	Element &e = E->get();
-			
+
 	e.aabb=p_aabb;
 	e.userdata=p_userdata;
 	e.subindex=p_subindex;
@@ -843,7 +843,7 @@ OctreeElementID Octree<T,use_pairs,AL>::create(T* p_userdata, const AABB& p_aabb
 	e.pairable_type=p_pairable_type;
 	e.pairable_mask=p_pairable_mask;
 	e._id=last_element_id-1;
-	
+
 	if (!e.aabb.has_no_surface()) {
 		_ensure_valid_root(p_aabb);
 		_insert_element(&e,root);
@@ -964,7 +964,7 @@ void Octree<T,use_pairs,AL>::move(OctreeElementID p_id, const AABB& p_aabb) {
 	_insert_element(&e,common_parent); // reinsert from this point
 
 	pass++;
-	
+
 	for(typename List<typename Element::OctantOwner,AL>::Element *E=owners.front();E;) {
 
 		Octant *o=E->get().octant;
@@ -1018,28 +1018,28 @@ void Octree<T,use_pairs,AL>::set_pairable(OctreeElementID p_id,bool p_pairable,u
 
 	typename ElementMap::Element *E = element_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	
+
 	Element &e = E->get();
 
 	if (p_pairable == e.pairable && e.pairable_type==p_pairable_type && e.pairable_mask==p_pairable_mask)
 		return; // no changes, return
-	
+
 	if (!e.aabb.has_no_surface()) {
 		_remove_element(&e);
 	}
-	
+
 	e.pairable=p_pairable;
 	e.pairable_type=p_pairable_type;
 	e.pairable_mask=p_pairable_mask;
 	e.common_parent=NULL;
-	
+
 	if (!e.aabb.has_no_surface()) {
 		_ensure_valid_root(e.aabb);
 		_insert_element(&e,root);
 		if (use_pairs)
 			_element_check_pairs(&e);
 
-	}	
+	}
 }
 
 
@@ -1048,155 +1048,155 @@ 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);				
+
+		_remove_element(&e);
 	}
-		
+
 	element_map.erase(p_id);
 	_optimize();
 }
 
 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)))
 				continue;
 			e->last_pass=pass;
-			
+
 			if (e->aabb.intersects_convex_shape(p_cull->planes,p_cull->plane_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
 				}
 			}
 		}
 	}
-	
+
 	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)))
 				continue;
 			e->last_pass=pass;
-			
+
 			if (e->aabb.intersects_convex_shape(p_cull->planes,p_cull->plane_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
 				}
 			}
 		}
 	}
-		
+
 	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)) {
 			_cull_convex(p_octant->children[i],p_cull);
 		}
-	}	
+	}
 }
 
 
 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)))
 				continue;
 			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
 				}
 			}
 		}
 	}
-	
+
 	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)))
 				continue;
 			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
 				}
 			}
 		}
-	}	
+	}
 
 	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);
 		}
-	}	
+	}
 
 }
 
@@ -1205,53 +1205,53 @@ void Octree<T,use_pairs,AL>::_cull_segment(Octant *p_octant,const Vector3& p_fro
 
 	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)))
 				continue;
 			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
 				}
 			}
 		}
 	}
-	
+
 	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)))
 				continue;
-				
+
 			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;
@@ -1259,20 +1259,20 @@ void Octree<T,use_pairs,AL>::_cull_segment(Octant *p_octant,const Vector3& p_fro
 					(*p_result_idx)++;
 
 				} else {
-					
+
 					return; // pointless to continue
 				}
 			}
 		}
 	}
-	
+
 
 	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);
 		}
-	}	
+	}
 }
 
 
@@ -1357,7 +1357,7 @@ int Octree<T,use_pairs,AL>::cull_convex(const Vector<Plane>& p_convex,T** p_resu
 
 	if (!root)
 		return 0;
-	
+
 	int result_count=0;
 	pass++;
 	_CullConvexData cdata;
@@ -1367,9 +1367,9 @@ int Octree<T,use_pairs,AL>::cull_convex(const Vector<Plane>& p_convex,T** p_resu
 	cdata.result_max=p_result_max;
 	cdata.result_idx=&result_count;
 	cdata.mask=p_mask;
-	
+
 	_cull_convex(root,&cdata);
-	
+
 	return result_count;
 }
 
@@ -1381,11 +1381,11 @@ int Octree<T,use_pairs,AL>::cull_AABB(const AABB& p_aabb,T** p_result_array,int
 
 	if (!root)
 		return 0;
-	
+
 	int result_count=0;
 	pass++;
 	_cull_AABB(root,p_aabb,p_result_array,&result_count,p_result_max,p_subindex_array,p_mask);
-			
+
 	return result_count;
 }
 
@@ -1395,11 +1395,11 @@ int Octree<T,use_pairs,AL>::cull_segment(const Vector3& p_from, const Vector3& p
 
 	if (!root)
 		return 0;
-	
+
 	int result_count=0;
 	pass++;
 	_cull_segment(root,p_from,p_to,p_result_array,&result_count,p_result_max,p_subindex_array,p_mask);
-			
+
 	return result_count;
 
 }
@@ -1436,7 +1436,7 @@ void Octree<T,use_pairs,AL>::set_unpair_callback( UnpairCallback p_callback, voi
 
 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;
diff --git a/core/math/plane.cpp b/core/math/plane.cpp
index d17ce01bec..b29350fe3c 100644
--- a/core/math/plane.cpp
+++ b/core/math/plane.cpp
@@ -50,7 +50,7 @@ void Plane::normalize() {
 }
 
 Plane Plane::normalized() const {
-	
+
 	Plane p = *this;
 	p.normalize();
 	return p;
@@ -66,12 +66,12 @@ Vector3 Plane::get_any_perpendicular_normal() const {
 	static const Vector3 p1 = Vector3(1,0,0);
 	static const Vector3 p2 = Vector3(0,1,0);
 	Vector3 p;
-	
+
 	if (ABS(normal.dot(p1)) > 0.99) // if too similar to p1
 		p=p2; // use p2
 	else
 		p=p1; // use p1
-	
+
 	p-=normal * normal.dot(p);
 	p.normalize();
 
diff --git a/core/math/plane.h b/core/math/plane.h
index d20e63dc47..81a968682e 100644
--- a/core/math/plane.h
+++ b/core/math/plane.h
@@ -62,9 +62,9 @@ public:
 	bool intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_intersection)  const;
 
 	_FORCE_INLINE_ Vector3 project(const Vector3& p_point) const {
-	
+
 		return p_point - normal * distance_to(p_point);
-	}	
+	}
 
         /* misc */
 
diff --git a/core/math/quat.cpp b/core/math/quat.cpp
index ebc5ec4e65..c6c12129b3 100644
--- a/core/math/quat.cpp
+++ b/core/math/quat.cpp
@@ -30,9 +30,9 @@
 #include "print_string.h"
 
 void Quat::set_euler(const Vector3& p_euler) {
-	real_t half_yaw = p_euler.x * 0.5;  
-	real_t half_pitch = p_euler.y * 0.5;  
-	real_t half_roll = p_euler.z * 0.5;  
+	real_t half_yaw = p_euler.x * 0.5;
+	real_t half_pitch = p_euler.y * 0.5;
+	real_t half_roll = p_euler.z * 0.5;
 	real_t cos_yaw = Math::cos(half_yaw);
 	real_t sin_yaw = Math::sin(half_yaw);
 	real_t cos_pitch = Math::cos(half_pitch);
@@ -75,7 +75,7 @@ void Quat::normalize() {
 
 Quat Quat::normalized() const {
 	return *this / length();
-} 
+}
 
 Quat Quat::inverse() const {
 	return Quat( -x, -y, -z, w );
@@ -252,7 +252,7 @@ Quat Quat::cubic_slerp(const Quat& q, const Quat& prep, const Quat& postq,const
 
 Quat::operator String() const {
 
-	return String::num(x)+","+String::num(y)+","+ String::num(z)+","+ String::num(w); 
+	return String::num(x)+","+String::num(y)+","+ String::num(z)+","+ String::num(w);
 }
 
 Quat::Quat(const Vector3& axis, const real_t& angle) {
@@ -261,7 +261,7 @@ Quat::Quat(const Vector3& axis, const real_t& angle) {
 		set(0,0,0,0);
 	else {
 		real_t s = Math::sin(-angle * 0.5) / d;
-		set(axis.x * s, axis.y * s, axis.z * s, 
+		set(axis.x * s, axis.y * s, axis.z * s,
 			Math::cos(-angle * 0.5));
 	}
 }
diff --git a/core/math/quat.h b/core/math/quat.h
index 738b6946c7..0d206bb3b7 100644
--- a/core/math/quat.h
+++ b/core/math/quat.h
@@ -89,18 +89,18 @@ public:
 	_FORCE_INLINE_ Quat operator-() const;
 	_FORCE_INLINE_ Quat operator*(const real_t& s) const;
 	_FORCE_INLINE_ Quat operator/(const real_t& s) const;
-	
+
 
 	_FORCE_INLINE_ bool operator==(const Quat& p_quat) const;
 	_FORCE_INLINE_ bool operator!=(const Quat& p_quat) const;
-	
+
 	operator String() const;
-	
+
 	inline void set( real_t p_x, real_t p_y, real_t p_z, real_t p_w) {
-		x=p_x; y=p_y; z=p_z; w=p_w;	
+		x=p_x; y=p_y; z=p_z; w=p_w;
 	}
 	inline Quat(real_t p_x, real_t p_y, real_t p_z, real_t p_w) {
-		x=p_x; y=p_y; z=p_z; w=p_w;	
+		x=p_x; y=p_y; z=p_z; w=p_w;
 	}
 	Quat(const Vector3& axis, const real_t& angle);
 
@@ -127,7 +127,7 @@ public:
 	}
 
 	inline Quat() {x=y=z=0; w=1; }
-	
+
 
 };
 
@@ -141,7 +141,7 @@ real_t Quat::length_squared() const {
 }
 
 void Quat::operator+=(const Quat& q) {
-	x += q.x; y += q.y; z += q.z; w += q.w;	
+	x += q.x; y += q.y; z += q.z; w += q.w;
 }
 
 void Quat::operator-=(const Quat& q) {
diff --git a/core/math/transform.cpp b/core/math/transform.cpp
index 8371f7e34b..22eb6c4fdd 100644
--- a/core/math/transform.cpp
+++ b/core/math/transform.cpp
@@ -30,7 +30,7 @@
 #include "math_funcs.h"
 #include "os/copymem.h"
 #include "print_string.h"
-	
+
 
 void Transform::affine_invert() {
 
@@ -50,7 +50,7 @@ Transform Transform::affine_inverse() const {
 void Transform::invert() {
 
 	basis.transpose();
-	origin = basis.xform(-origin);	
+	origin = basis.xform(-origin);
 }
 
 Transform Transform::inverse() const {
@@ -87,30 +87,30 @@ void Transform::set_look_at( const Vector3& p_eye, const Vector3& p_target, cons
 
 	// Reference: MESA source code
 	Vector3 v_x, v_y, v_z;
-	
+
 	/* Make rotation matrix */
-	
+
 	/* Z vector */
 	v_z = p_eye - p_target;
-	
+
 	v_z.normalize();
-	
+
 	v_y = p_up;
-	
+
 
 	v_x=v_y.cross(v_z);
-	
+
 	/* Recompute Y = Z cross X */
 	v_y=v_z.cross(v_x);
-	
+
 	v_x.normalize();
 	v_y.normalize();
-	
+
 	basis.set_axis(0,v_x);
 	basis.set_axis(1,v_y);
 	basis.set_axis(2,v_z);
 	origin=p_eye;
-	
+
 }
 
 Transform Transform::interpolate_with(const Transform& p_transform, float p_c) const {
@@ -193,7 +193,7 @@ bool Transform::operator!=(const Transform& p_transform) const {
 void Transform::operator*=(const Transform& p_transform) {
 
 	origin=xform(p_transform.origin);
-	basis*=p_transform.basis;	
+	basis*=p_transform.basis;
 }
 
 Transform Transform::operator*(const Transform& p_transform) const {
diff --git a/core/math/transform.h b/core/math/transform.h
index bd1247084d..f948a4c919 100644
--- a/core/math/transform.h
+++ b/core/math/transform.h
@@ -40,9 +40,9 @@ public:
 
 	Matrix3 basis;
 	Vector3 origin;
-	
-	void invert(); 
-	Transform inverse() const; 
+
+	void invert();
+	Transform inverse() const;
 
 	void affine_invert();
 	Transform affine_inverse() const;
@@ -76,27 +76,27 @@ public:
 
 	_FORCE_INLINE_ Vector3 xform(const Vector3& p_vector) const;
 	_FORCE_INLINE_ Vector3 xform_inv(const Vector3& p_vector) const;
-	
+
 	_FORCE_INLINE_ Plane xform(const Plane& p_plane) const;
 	_FORCE_INLINE_ Plane xform_inv(const Plane& p_plane) const;
 
 	_FORCE_INLINE_ AABB xform(const AABB& p_aabb) const;
 	_FORCE_INLINE_ AABB xform_inv(const AABB& p_aabb) const;
-	
+
 	void operator*=(const Transform& p_transform);
 	Transform operator*(const Transform& p_transform) const;
 
 	Transform interpolate_with(const Transform& p_transform, float p_c) const;
-	
+
 	_FORCE_INLINE_ Transform inverse_xform(const Transform& t) const {
-		
+
 		Vector3 v = t.origin - origin;
 		return Transform(basis.transpose_xform(t.basis),
 			basis.xform(v));
 	}
-	
+
 	void set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz,real_t tx, real_t ty, real_t tz) {
-	
+
 		basis.elements[0][0]=xx;
 		basis.elements[0][1]=xy;
 		basis.elements[0][2]=xz;
@@ -105,14 +105,14 @@ public:
 		basis.elements[1][2]=yz;
 		basis.elements[2][0]=zx;
 		basis.elements[2][1]=zy;
-		basis.elements[2][2]=zz;	
+		basis.elements[2][2]=zz;
 		origin.x=tx;
 		origin.y=ty;
 		origin.z=tz;
 	}
-	
+
 	operator String() const;
-	
+
 	Transform(const Matrix3& p_basis, const Vector3& p_origin=Vector3());
 	Transform() {}
 
@@ -128,9 +128,9 @@ _FORCE_INLINE_ Vector3 Transform::xform(const Vector3& p_vector) const {
 	);
 }
 _FORCE_INLINE_ Vector3 Transform::xform_inv(const Vector3& p_vector) const {
-	
+
 	Vector3 v = p_vector - origin;
-	
+
 	return Vector3(
 		(basis.elements[0][0]*v.x ) + ( basis.elements[1][0]*v.y ) + ( basis.elements[2][0]*v.z ),
 		(basis.elements[0][1]*v.x ) + ( basis.elements[1][1]*v.y ) + ( basis.elements[2][1]*v.z ),
@@ -140,16 +140,16 @@ _FORCE_INLINE_ Vector3 Transform::xform_inv(const Vector3& p_vector) const {
 
 _FORCE_INLINE_ Plane Transform::xform(const Plane& p_plane) const {
 
-	
+
 	Vector3 point=p_plane.normal*p_plane.d;
 	Vector3 point_dir=point+p_plane.normal;
 	point=xform(point);
 	point_dir=xform(point_dir);
-	
+
 	Vector3 normal=point_dir-point;
 	normal.normalize();
 	real_t d=normal.dot(point);
-	
+
 	return Plane(normal,d);
 
 }
@@ -159,11 +159,11 @@ _FORCE_INLINE_ Plane Transform::xform_inv(const Plane& p_plane) const {
 	Vector3 point_dir=point+p_plane.normal;
 	xform_inv(point);
 	xform_inv(point_dir);
-	
+
 	Vector3 normal=point_dir-point;
 	normal.normalize();
 	real_t d=normal.dot(point);
-	
+
 	return Plane(normal,d);
 
 }
@@ -199,17 +199,17 @@ _FORCE_INLINE_ AABB Transform::xform(const AABB& p_aabb) const {
 			Vector3(p_aabb.pos.x,	p_aabb.pos.y,		p_aabb.pos.z+p_aabb.size.z),
 			Vector3(p_aabb.pos.x,	p_aabb.pos.y,		p_aabb.pos.z)
 	};
-	
-	
+
+
 	AABB ret;
-	
+
 	ret.pos=xform(vertices[0]);
-	
+
 	for (int i=1;i<8;i++) {
-	
+
 		ret.expand_to( xform(vertices[i]) );
 	}
-	
+
 	return ret;
 #endif
 
@@ -227,17 +227,17 @@ _FORCE_INLINE_ AABB Transform::xform_inv(const AABB& p_aabb) const {
 			Vector3(p_aabb.pos.x,	p_aabb.pos.y,		p_aabb.pos.z+p_aabb.size.z),
 			Vector3(p_aabb.pos.x,	p_aabb.pos.y,		p_aabb.pos.z)
 	};
-	
-	
+
+
 	AABB ret;
-	
+
 	ret.pos=xform_inv(vertices[0]);
-	
+
 	for (int i=1;i<8;i++) {
-	
+
 		ret.expand_to( xform_inv(vertices[i]) );
 	}
-	
+
 	return ret;
 
 }
diff --git a/core/method_bind.h b/core/method_bind.h
index da3d7c1062..48848c5848 100644
--- a/core/method_bind.h
+++ b/core/method_bind.h
@@ -58,8 +58,8 @@ template<class T>
 struct VariantCaster {
 
 	static _FORCE_INLINE_ T cast(const Variant& p_variant) {
-	
-		return p_variant;			
+
+		return p_variant;
 	}
 };
 
@@ -67,8 +67,8 @@ template<class T>
 struct VariantCaster<T&> {
 
 	static _FORCE_INLINE_ T cast(const Variant& p_variant) {
-	
-		return p_variant;			
+
+		return p_variant;
 	}
 };
 
@@ -76,8 +76,8 @@ template<class T>
 struct VariantCaster<const T&> {
 
 	static _FORCE_INLINE_ T cast(const Variant& p_variant) {
-	
-		return p_variant;			
+
+		return p_variant;
 	}
 };
 
diff --git a/core/object.cpp b/core/object.cpp
index c92fc35b24..7bdec06c1b 100644
--- a/core/object.cpp
+++ b/core/object.cpp
@@ -255,7 +255,7 @@ Object::Connection::Connection(const Variant& p_variant) {
 
 
 bool Object::_predelete() {
-	
+
 	_predelete_ok=1;
 	notification(NOTIFICATION_PREDELETE,true);
 	if (_predelete_ok) {
@@ -269,16 +269,16 @@ void Object::_postinitialize() {
 	_type_ptr=_get_type_namev();
 	_initialize_typev();
 	notification(NOTIFICATION_POSTINITIALIZE);
-	
+
 }
 
 void Object::get_valid_parents_static(List<String> *p_parents) {
-	
-	
+
+
 }
 void Object::_get_valid_parents_static(List<String> *p_parents) {
-	
-	
+
+
 }
 #if 0
 //old style set, deprecated
@@ -286,7 +286,7 @@ void Object::_get_valid_parents_static(List<String> *p_parents) {
 void Object::set(const String& p_name, const Variant& p_value) {
 
 	_setv(p_name,p_value);
-	
+
 	//if (!_use_builtin_script())
 //		return;
 
@@ -303,8 +303,8 @@ void Object::set(const String& p_name, const Variant& p_value) {
 	} else if (script_instance) {
 		script_instance->set(p_name,p_value);
 	}
-	
-	
+
+
 }
 #endif
 
@@ -348,7 +348,7 @@ void Object::set(const StringName& p_name, const Variant& p_value, bool *r_valid
 			*r_valid=true;
 		return;
 	} else {
-		//something inside the object... :|		
+		//something inside the object... :|
 		bool success = _setv(p_name,p_value);
 		if (success) {
 			if (r_valid)
@@ -420,7 +420,7 @@ Variant Object::get(const String& p_name) const {
 	Variant ret=_getv(p_name);
 	if (ret.get_type()!=Variant::NIL)
 		return ret;
-		
+
 	bool success;
 	ObjectTypeDB::get_property(const_cast<Object*>(this),p_name,ret,success);
 	if (success) {
@@ -431,11 +431,11 @@ Variant Object::get(const String& p_name) const {
 		return metadata;
 	else if (p_name=="script/script")
 		return script;
-		
+
 	if (script_instance) {
 		return script_instance->get(p_name);
 	}
-	
+
 	return Variant();
 
 }
@@ -449,10 +449,10 @@ void Object::get_property_list(List<PropertyInfo> *p_list,bool p_reversed) const
 	}
 
 	_get_property_listv(p_list,p_reversed);
-	
+
 	if (!_use_builtin_script())
 		return;
-		
+
 	if (!is_type("Script")) // can still be set, but this is for userfriendlyness
 		p_list->push_back( PropertyInfo( Variant::OBJECT, "script/script", PROPERTY_HINT_RESOURCE_TYPE, "Script",PROPERTY_USAGE_DEFAULT|PROPERTY_USAGE_STORE_IF_NONZERO));
 	if (!metadata.empty())
@@ -460,15 +460,15 @@ void Object::get_property_list(List<PropertyInfo> *p_list,bool p_reversed) const
 	if (script_instance && !p_reversed) {
 		p_list->push_back( PropertyInfo(Variant::NIL,"Script Variables",PROPERTY_HINT_NONE,String(),PROPERTY_USAGE_CATEGORY));
 		script_instance->get_property_list(p_list);
-	}	
-	
+	}
+
 }
 void Object::get_method_list(List<MethodInfo> *p_list) const {
 
 	ObjectTypeDB::get_method_list(get_type_name(),p_list);
 	if (script_instance) {
 		script_instance->get_method_list(p_list);
-	}	
+	}
 }
 
 
@@ -898,22 +898,22 @@ Variant Object::call(const StringName& p_method,const Variant** p_args,int p_arg
 
 
 void Object::notification(int p_notification,bool p_reversed) {
-	
+
 
 	_notificationv(p_notification,p_reversed);
-	
+
 	if (script_instance) {
 		script_instance->notification(p_notification);
 	}
 }
 
 void Object::_changed_callback(Object *p_changed,const char *p_prop) {
-	
-		
+
+
 }
 
 void Object::add_change_receptor( Object *p_receptor ) {
-	
+
 	change_receptors.insert(p_receptor);
 }
 
@@ -941,8 +941,8 @@ void Object::set_script(const RefPtr& p_script) {
 		memdelete(script_instance);
 		script_instance=NULL;
 	}
-	
-	script=p_script;	
+
+	script=p_script;
 	Ref<Script> s(script);
 
 	if (!s.is_null() && s->can_instance() ) {
@@ -1760,7 +1760,7 @@ bool Object::is_edited() const {
 #endif
 
 Object::Object() {
-	
+
 	_type_ptr=NULL;
 	_block_signals=false;
 	_predelete_ok=0;
@@ -1831,12 +1831,12 @@ Object::~Object() {
 
 
 bool predelete_handler(Object *p_object) {
-	
+
 	return p_object->_predelete();
 }
 
 void postinitialize_handler(Object *p_object) {
-	
+
 	p_object->_postinitialize();
 }
 
@@ -1900,8 +1900,8 @@ void ObjectDB::cleanup() {
 
 	GLOBAL_LOCK_FUNCTION;
 	if (instances.size()) {
-			
-		WARN_PRINT("ObjectDB Instances still exist!");		
+
+		WARN_PRINT("ObjectDB Instances still exist!");
 		if (OS::get_singleton()->is_stdout_verbose()) {
 			const uint32_t *K=NULL;
 			while((K=instances.next(K))) {
diff --git a/core/object_type_db.cpp b/core/object_type_db.cpp
index dd9304f1f9..14b595d61b 100644
--- a/core/object_type_db.cpp
+++ b/core/object_type_db.cpp
@@ -200,37 +200,37 @@ ObjectTypeDB::TypeInfo::TypeInfo() {
 	disabled=false;
 }
 ObjectTypeDB::TypeInfo::~TypeInfo() {
-	
-	
+
+
 }
 
 
 bool ObjectTypeDB::is_type(const StringName &p_type,const StringName& p_inherits) {
-	
+
 	OBJTYPE_LOCK;
-	
+
 	StringName inherits=p_type;
-	
+
 	while (inherits.operator String().length()) {
-		
+
 		if (inherits==p_inherits)
 			return true;
 		inherits=type_inherits_from(inherits);
 	}
-	
+
 	return false;
 }
 void ObjectTypeDB::get_type_list( List<StringName> *p_types) {
-	
+
 	OBJTYPE_LOCK;
-	
+
 	const StringName *k=NULL;
-	
+
 	while((k=types.next(k))) {
-		
+
 		p_types->push_back(*k);
 	}
-	
+
 	p_types->sort();
 }
 
@@ -238,11 +238,11 @@ void ObjectTypeDB::get_type_list( List<StringName> *p_types) {
 void ObjectTypeDB::get_inheriters_from( const StringName& p_type,List<StringName> *p_types) {
 
 	OBJTYPE_LOCK;
-	
+
 	const StringName *k=NULL;
-	
+
 	while((k=types.next(k))) {
-		
+
 		if (*k!=p_type && is_type(*k,p_type))
 			p_types->push_back(*k);
 	}
@@ -250,18 +250,18 @@ void ObjectTypeDB::get_inheriters_from( const StringName& p_type,List<StringName
 }
 
 StringName ObjectTypeDB::type_inherits_from(const StringName& p_type) {
-	
+
 	OBJTYPE_LOCK;
-	
+
 	TypeInfo *ti = types.getptr(p_type);
 	ERR_FAIL_COND_V(!ti,"");
 	return ti->inherits;
 }
 
 bool ObjectTypeDB::type_exists(const StringName &p_type) {
-	
+
 	OBJTYPE_LOCK;
-	return types.has(p_type);	
+	return types.has(p_type);
 }
 
 void ObjectTypeDB::add_compatibility_type(const StringName& p_type,const StringName& p_fallback) {
@@ -270,7 +270,7 @@ void ObjectTypeDB::add_compatibility_type(const StringName& p_type,const StringN
 }
 
 Object *ObjectTypeDB::instance(const StringName &p_type) {
-	
+
 	TypeInfo *ti;
 	{
 		OBJTYPE_LOCK;
@@ -288,9 +288,9 @@ Object *ObjectTypeDB::instance(const StringName &p_type) {
 	return ti->creation_func();
 }
 bool ObjectTypeDB::can_instance(const StringName &p_type) {
-	
+
 	OBJTYPE_LOCK;
-	
+
 	TypeInfo *ti = types.getptr(p_type);
 	ERR_FAIL_COND_V(!ti,false);
 	return (!ti->disabled && ti->creation_func!=NULL);
@@ -326,11 +326,11 @@ void ObjectTypeDB::get_method_list(StringName p_type,List<MethodInfo> *p_methods
 
 
 	OBJTYPE_LOCK;
-	
+
 	TypeInfo *type=types.getptr(p_type);
-	
+
 	while(type) {
-	
+
 		if (type->disabled) {
 
 			if (p_no_inheritance)
@@ -348,14 +348,14 @@ void ObjectTypeDB::get_method_list(StringName p_type,List<MethodInfo> *p_methods
 		}
 
 		for( List<StringName>::Element *E=type->method_order.front();E;E=E->next()) {
-		
+
 			MethodBind *method=type->method_map.get(E->get());
 			MethodInfo minfo;
 			minfo.name=E->get();
 			minfo.id=method->get_method_id();
 
 			for (int i=0;i<method->get_argument_count();i++) {
-			
+
 				//Variant::Type t=method->get_argument_type(i);
 
 				minfo.arguments.push_back(method->get_argument_info(i));
@@ -386,24 +386,24 @@ void ObjectTypeDB::get_method_list(StringName p_type,List<MethodInfo> *p_methods
 
 
 #endif
-		
+
 		if (p_no_inheritance)
 			break;
-		
+
 		type=type->inherits_ptr;
 	}
-	
+
 }
 
 
 MethodBind *ObjectTypeDB::get_method(StringName p_type, StringName p_name) {
 
 	OBJTYPE_LOCK;
-	
+
 	TypeInfo *type=types.getptr(p_type);
-	
+
 	while(type) {
-	
+
 		MethodBind **method=type->method_map.getptr(p_name);
 		if (method && *method)
 			return *method;
@@ -416,18 +416,18 @@ MethodBind *ObjectTypeDB::get_method(StringName p_type, StringName p_name) {
 void ObjectTypeDB::bind_integer_constant(const StringName& p_type, const StringName &p_name, int p_constant) {
 
 	OBJTYPE_LOCK;
-	
+
 	TypeInfo *type=types.getptr(p_type);
 	if (!type) {
 
 		ERR_FAIL_COND(!type);
 	}
-	
+
 	if (type->constant_map.has(p_name)) {
 
 		ERR_FAIL();
 	}
-	
+
 	type->constant_map[p_name]=p_constant;
 #ifdef DEBUG_METHODS_ENABLED
 	type->constant_order.push_back(p_name);
@@ -438,11 +438,11 @@ void ObjectTypeDB::bind_integer_constant(const StringName& p_type, const StringN
 void ObjectTypeDB::get_integer_constant_list(const StringName& p_type, List<String> *p_constants, bool p_no_inheritance) {
 
 	OBJTYPE_LOCK;
-	
+
 	TypeInfo *type=types.getptr(p_type);
-	
+
 	while(type) {
-	
+
 #ifdef DEBUG_METHODS_ENABLED
 		for(List<StringName>::Element *E=type->constant_order.front();E;E=E->next())
 			p_constants->push_back(E->get());
@@ -456,7 +456,7 @@ void ObjectTypeDB::get_integer_constant_list(const StringName& p_type, List<Stri
 #endif
 		if (p_no_inheritance)
 			break;
-		
+
 		type=type->inherits_ptr;
 	}
 
@@ -466,28 +466,28 @@ void ObjectTypeDB::get_integer_constant_list(const StringName& p_type, List<Stri
 int ObjectTypeDB::get_integer_constant(const StringName& p_type, const StringName &p_name, bool *p_success) {
 
 	OBJTYPE_LOCK;
-	
-	
+
+
 	TypeInfo *type=types.getptr(p_type);
-	
+
 	while(type) {
-	
+
 
 		int *constant=type->constant_map.getptr(p_name);
 		if (constant) {
-			
+
 			if (p_success)
 				*p_success=true;
 			return *constant;
 		}
-		
+
 		type=type->inherits_ptr;
 	}
-		
+
 	if (p_success)
-		*p_success=false;	
+		*p_success=false;
 
-	return 0;	
+	return 0;
 }
 
 void ObjectTypeDB::add_signal(StringName p_type,const MethodInfo& p_signal) {
@@ -966,7 +966,7 @@ void ObjectTypeDB::init() {
 }
 
 void ObjectTypeDB::cleanup() {
-	
+
 
 #ifndef NO_THREADS
 
@@ -974,19 +974,19 @@ void ObjectTypeDB::cleanup() {
 #endif
 
 	//OBJTYPE_LOCK; hah not here
-	
+
 	const StringName *k=NULL;
-	
+
 	while((k=types.next(k))) {
-		
+
 		TypeInfo &ti=types[*k];
-		
+
 		const StringName *m=NULL;
 		while((m=ti.method_map.next(m))) {
-			
+
 			memdelete( ti.method_map[*m] );
 		}
-	}	
+	}
 	types.clear();
 	resource_base_extensions.clear();
 	compat_types.clear();
diff --git a/core/object_type_db.h b/core/object_type_db.h
index f6caf14be5..a4896fff81 100644
--- a/core/object_type_db.h
+++ b/core/object_type_db.h
@@ -42,9 +42,9 @@ struct ParamHint {
 	PropertyHint hint;
 	String hint_text;
 	Variant default_val;
-	
+
 	ParamHint(const String& p_name="", PropertyHint p_hint=PROPERTY_HINT_NONE, const String& p_hint_text="",Variant p_default_val=Variant()) {
-	
+
 		name=p_name;
 		hint=p_hint;
 		hint_text=p_hint_text;
@@ -73,9 +73,9 @@ struct MethodDefinition {
 
 	StringName name;
 	Vector<StringName> args;
-	MethodDefinition() {}	
+	MethodDefinition() {}
 	MethodDefinition(const char *p_name) { name=p_name; }
-	MethodDefinition(const StringName& p_name) { name=p_name; }	
+	MethodDefinition(const StringName& p_name) { name=p_name; }
 };
 
 
@@ -109,7 +109,7 @@ static _FORCE_INLINE_ const char* _MD(const char* m_name, ...) { return m_name;
 #endif
 
 class ObjectTypeDB {
-	
+
 	struct PropertySetGet {
 
 		int index;
@@ -121,7 +121,7 @@ class ObjectTypeDB {
 	};
 
 	struct TypeInfo {
-		
+
 		TypeInfo *inherits_ptr;
 		HashMap<StringName,MethodBind*,StringNameHasher> method_map;
 		HashMap<StringName,int,StringNameHasher> constant_map;
@@ -143,12 +143,12 @@ class ObjectTypeDB {
 		TypeInfo();
 		~TypeInfo();
 	};
-	
+
 	template<class T>
 	static Object *creator() {
 		return memnew( T );
 	}
-	
+
 	static Mutex *lock;
 	static HashMap<StringName,TypeInfo,StringNameHasher> types;
 	static HashMap<StringName,StringName,StringNameHasher> resource_base_extensions;
@@ -163,8 +163,8 @@ class ObjectTypeDB {
 
 
 	static void _add_type2(const StringName& p_type, const StringName& p_inherits);
-public:	
-	
+public:
+
 	// DO NOT USE THIS!!!!!! NEEDS TO BE PUBLIC BUT DO NOT USE NO MATTER WHAT!!!
 	template<class T>
 	static void _add_type() {
@@ -195,7 +195,7 @@ public:
 
 	template<class T>
 	static void register_type() {
-		
+
 		GLOBAL_LOCK_FUNCTION;
 		T::initialize_type();
 		TypeInfo *t=types.getptr(T::get_type_static());
@@ -206,7 +206,7 @@ public:
 
 	template<class T>
 	static void register_virtual_type() {
-		
+
 		GLOBAL_LOCK_FUNCTION;
 		T::initialize_type();
 		//nothing
@@ -247,9 +247,9 @@ public:
 		ParamDef d4=ParamDef(),
 		ParamDef d5=ParamDef()
 		) {
-		
+
 		return bind_methodf(METHOD_FLAGS_DEFAULT,p_method_name, p_method, d1,d2,d3,d4,d5);
-	}	
+	}
 
 
 
@@ -472,7 +472,7 @@ public:
 
 	static void add_virtual_method(const StringName& p_type,const MethodInfo& p_method,bool p_virtual=true );
 	static void get_virtual_methods(const StringName& p_type,List<MethodInfo> * p_methods,bool p_no_inheritance=false );
-	
+
 	static void bind_integer_constant(const StringName& p_type, const StringName &p_name, int p_constant);
 	static void get_integer_constant_list(const StringName& p_type, List<String> *p_constants, bool p_no_inheritance=false);
 	static int get_integer_constant(const StringName& p_type, const StringName &p_name, bool *p_success=NULL);
diff --git a/core/os/copymem.cpp b/core/os/copymem.cpp
index 234ca50b45..49f53f1a51 100644
--- a/core/os/copymem.cpp
+++ b/core/os/copymem.cpp
@@ -32,7 +32,7 @@
 
 void movemem_system(void *to, void *from,int amount) {
 
-  memmove(to,from,amount);  
+  memmove(to,from,amount);
 
 }
 
diff --git a/core/os/dir_access.cpp b/core/os/dir_access.cpp
index 32d66a7408..9a7135913a 100644
--- a/core/os/dir_access.cpp
+++ b/core/os/dir_access.cpp
@@ -344,7 +344,7 @@ DirAccess *DirAccess::open(const String& p_path,Error *r_error) {
 }
 
 DirAccess *DirAccess::create(AccessType p_access) {
-	
+
 	DirAccess * da = create_func[p_access]?create_func[p_access]():NULL;
 	if (da) {
 		da->_access_type=p_access;
@@ -359,7 +359,7 @@ String DirAccess::get_full_path(const String& p_path,AccessType p_access) {
 	DirAccess *d=DirAccess::create(p_access);
 	if (!d)
 		return p_path;
-		
+
 	d->change_dir(p_path);
 	String full=d->get_current_dir();
 	memdelete(d);
@@ -367,31 +367,31 @@ String DirAccess::get_full_path(const String& p_path,AccessType p_access) {
 }
 
 Error DirAccess::copy(String p_from,String p_to) {
-	
+
 	//printf("copy %s -> %s\n",p_from.ascii().get_data(),p_to.ascii().get_data());
 	Error err;
 	FileAccess *fsrc = FileAccess::open(p_from, FileAccess::READ,&err);
-	
+
 	if (err) {
 
 		ERR_FAIL_COND_V( err, err );
 	}
 
-	
+
 	FileAccess *fdst = FileAccess::open(p_to, FileAccess::WRITE,&err );
 	if (err) {
-						
+
 		fsrc->close();
 		memdelete( fsrc );
 		ERR_FAIL_COND_V( err, err );
 	}
-	
+
 	fsrc->seek_end(0);
 	int size = fsrc->get_pos();
 	fsrc->seek(0);
 	err = OK;
 	while(size--) {
-		
+
 		if (fsrc->get_error()!=OK) {
 			err= fsrc->get_error();
 			break;
@@ -400,13 +400,13 @@ Error DirAccess::copy(String p_from,String p_to) {
 			err= fdst->get_error();
 			break;
 		}
-		
+
 		fdst->store_8( fsrc->get_8() );
 	}
-	
+
 	memdelete(fsrc);
 	memdelete(fdst);
-	
+
 	return err;
 }
 
diff --git a/core/os/dir_access.h b/core/os/dir_access.h
index e97a065998..7a850ddc6d 100644
--- a/core/os/dir_access.h
+++ b/core/os/dir_access.h
@@ -79,13 +79,13 @@ public:
 	virtual String get_next()=0;
 	virtual bool current_is_dir() const=0;
 	virtual bool current_is_hidden() const=0;
-	
-	virtual void list_dir_end()=0; ///< 
-	
+
+	virtual void list_dir_end()=0; ///<
+
 	virtual int get_drive_count()=0;
 	virtual String get_drive(int p_drive)=0;
 	virtual int get_current_drive();
-	
+
 	virtual Error change_dir(String p_dir)=0; ///< can be relative or absolute, return false on success
 	virtual String get_current_dir()=0; ///< return current dir location
 	virtual Error make_dir(String p_dir)=0;
@@ -100,7 +100,7 @@ public:
 	virtual Error copy(String p_from,String p_to);
 	virtual Error rename(String p_from, String p_to)=0;
 	virtual Error remove(String p_name)=0;
-	
+
 	static String get_full_path(const String& p_path,AccessType p_access);
 	static DirAccess *create_for_path(const String& p_path);
 
@@ -111,7 +111,7 @@ public:
 		FILE_TYPE_FILE,
 		FILE_TYPE_DIR,
 	};
-	
+
 	//virtual DirType get_file_type() const=0;
 */
 	static DirAccess *create(AccessType p_access);
diff --git a/core/os/file_access.cpp b/core/os/file_access.cpp
index 68c9dee84d..0846ef3eb0 100644
--- a/core/os/file_access.cpp
+++ b/core/os/file_access.cpp
@@ -169,69 +169,69 @@ String FileAccess::fix_path(const String& p_path) const {
 			return r_path;
 		} break;
 	}
-	
+
 	return r_path;
 }
 
 /* these are all implemented for ease of porting, then can later be optimized */
 
 uint16_t FileAccess::get_16()const {
-	
+
 	uint16_t res;
 	uint8_t a,b;
-	
+
 	a=get_8();
 	b=get_8();
-	
+
 	if (endian_swap) {
-		
+
 		SWAP( a,b );
 	}
-	
+
 	res=b;
 	res<<=8;
 	res|=a;
-	
+
 	return res;
 }
 uint32_t FileAccess::get_32() const{
-	
+
 	uint32_t res;
 	uint16_t a,b;
-	
+
 	a=get_16();
 	b=get_16();
-	
+
 	if (endian_swap) {
-		
+
 		SWAP( a,b );
 	}
-	
+
 	res=b;
 	res<<=16;
 	res|=a;
-	
-	return res;	
+
+	return res;
 }
 uint64_t FileAccess::get_64()const {
-	
+
 	uint64_t res;
 	uint32_t a,b;
-	
+
 	a=get_32();
 	b=get_32();
-	
+
 	if (endian_swap) {
-		
+
 		SWAP( a,b );
 	}
-	
+
 	res=b;
 	res<<=32;
 	res|=a;
-	
-	return res;	
-	
+
+	return res;
+
 }
 
 float FileAccess::get_float() const {
@@ -262,15 +262,15 @@ String FileAccess::get_line() const {
 	CharString line;
 
 	CharType c=get_8();
-	
+
 	while(!eof_reached()) {
-	
+
 		if (c=='\n' || c=='\0') {
 			line.push_back(0);
 			return String::utf8(line.get_data());
 		} else if (c!='\r')
 			line.push_back(c);
-				
+
 		c=get_8();
 	}
 	line.push_back(0);
@@ -331,7 +331,7 @@ Vector<String> FileAccess::get_csv_line(String delim) const {
 
 
 int FileAccess::get_buffer(uint8_t *p_dst,int p_length) const{
-	
+
 	int i=0;
 	for (i=0; i<p_length && !eof_reached(); i++)
 		p_dst[i]=get_8();
@@ -340,53 +340,53 @@ int FileAccess::get_buffer(uint8_t *p_dst,int p_length) const{
 }
 
 void FileAccess::store_16(uint16_t p_dest) {
-	
+
 	uint8_t a,b;
-	
+
 	a=p_dest&0xFF;
 	b=p_dest>>8;
-	
+
 	if (endian_swap) {
-		
+
 		SWAP( a,b );
 	}
-		
+
 	store_8(a);
 	store_8(b);
 
 }
 void FileAccess::store_32(uint32_t p_dest) {
-	
-	
+
+
 	uint16_t a,b;
-	
+
 	a=p_dest&0xFFFF;
 	b=p_dest>>16;
-	
+
 	if (endian_swap) {
-		
+
 		SWAP( a,b );
 	}
-		
+
 	store_16(a);
 	store_16(b);
-	
+
 }
 void FileAccess::store_64(uint64_t p_dest) {
-	
+
 	uint32_t a,b;
-	
+
 	a=p_dest&0xFFFFFFFF;
 	b=p_dest>>32;
-	
+
 	if (endian_swap) {
-		
+
 		SWAP( a,b );
 	}
-		
+
 	store_32(a);
 	store_32(b);
-	
+
 }
 
 void FileAccess::store_real(real_t p_real) {
@@ -461,7 +461,7 @@ void FileAccess::store_line(const String& p_line) {
 }
 
 void FileAccess::store_buffer(const uint8_t *p_src,int p_length) {
-	
+
 	for (int i=0;i<p_length;i++)
 		store_8(p_src[i]);
 }
diff --git a/core/os/file_access.h b/core/os/file_access.h
index 3249e21ffb..2c894c94eb 100644
--- a/core/os/file_access.h
+++ b/core/os/file_access.h
@@ -80,21 +80,21 @@ public:
 		READ_WRITE=3,
 		WRITE_READ=7,
 	};
-	
-	virtual void close()=0; ///< close a file 
-	virtual bool is_open() const=0; ///< true when file is open 
 
-	virtual void seek(size_t p_position)=0; ///< seek to a given position 
-	virtual void seek_end(int64_t p_position=0)=0; ///< seek from the end of file 
-	virtual size_t get_pos() const=0; ///< get position in the file 
-	virtual size_t get_len() const=0; ///< get size of the file 
+	virtual void close()=0; ///< close a file
+	virtual bool is_open() const=0; ///< true when file is open
 
-	virtual bool eof_reached() const=0; ///< reading passed EOF 
+	virtual void seek(size_t p_position)=0; ///< seek to a given position
+	virtual void seek_end(int64_t p_position=0)=0; ///< seek from the end of file
+	virtual size_t get_pos() const=0; ///< get position in the file
+	virtual size_t get_len() const=0; ///< get size of the file
 
-	virtual uint8_t get_8() const=0; ///< get a byte 
-	virtual uint16_t get_16() const; ///< get 16 bits uint  
-	virtual uint32_t get_32() const; ///< get 32 bits uint 
-	virtual uint64_t get_64() const; ///< get 64 bits uint 
+	virtual bool eof_reached() const=0; ///< reading passed EOF
+
+	virtual uint8_t get_8() const=0; ///< get a byte
+	virtual uint16_t get_16() const; ///< get 16 bits uint
+	virtual uint32_t get_32() const; ///< get 32 bits uint
+	virtual uint64_t get_64() const; ///< get 64 bits uint
 
 	virtual float get_float() const;
 	virtual double get_double() const;
@@ -103,21 +103,21 @@ public:
 	virtual int get_buffer(uint8_t *p_dst,int p_length) const; ///< get an array of bytes
 	virtual String get_line() const;
 	virtual Vector<String> get_csv_line(String delim=",") const;
-	
+
 	/**< use this for files WRITTEN in _big_ endian machines (ie, amiga/mac)
 	 * It's not about the current CPU type but file formats.
 	 * this flags get reset to false (little endian) on each open
 	 */
-	 
+
 	virtual void set_endian_swap(bool p_swap) { endian_swap=p_swap; }
 	inline bool get_endian_swap() const { return endian_swap; }
 
-	virtual Error get_error() const=0; ///< get last error 
+	virtual Error get_error() const=0; ///< get last error
 
-	virtual void store_8(uint8_t p_dest)=0; ///< store a byte 
-	virtual void store_16(uint16_t p_dest); ///< store 16 bits uint 
-	virtual void store_32(uint32_t p_dest); ///< store 32 bits uint 
-	virtual void store_64(uint64_t p_dest); ///< store 64 bits uint 
+	virtual void store_8(uint8_t p_dest)=0; ///< store a byte
+	virtual void store_16(uint16_t p_dest); ///< store 16 bits uint
+	virtual void store_32(uint32_t p_dest); ///< store 32 bits uint
+	virtual void store_64(uint64_t p_dest); ///< store 64 bits uint
 
 	virtual void store_float(float p_dest);
 	virtual void store_double(double p_dest);
@@ -129,9 +129,9 @@ public:
 	virtual void store_pascal_string(const String& p_string);
 	virtual String get_pascal_string();
 
-	virtual void store_buffer(const uint8_t *p_src,int p_length); ///< store an array of bytes 
-	
-	virtual bool file_exists(const String& p_name)=0; ///< return true if a file exists 
+	virtual void store_buffer(const uint8_t *p_src,int p_length); ///< store an array of bytes
+
+	virtual bool file_exists(const String& p_name)=0; ///< return true if a file exists
 
 	virtual Error reopen(const String& p_path, int p_mode_flags); ///< does not change the AccessType
 
diff --git a/core/os/input.h b/core/os/input.h
index 2dd4496f26..535776f39c 100644
--- a/core/os/input.h
+++ b/core/os/input.h
@@ -55,7 +55,7 @@ public:
 
 	static Input *get_singleton();
 
-	virtual bool is_key_pressed(int p_scancode)=0;	
+	virtual bool is_key_pressed(int p_scancode)=0;
 	virtual bool is_mouse_button_pressed(int p_button)=0;
 	virtual bool is_joy_button_pressed(int p_device, int p_button)=0;
 	virtual bool is_action_pressed(const StringName& p_action)=0;
diff --git a/core/os/input_event.cpp b/core/os/input_event.cpp
index 3022a56e2a..2d47645a66 100644
--- a/core/os/input_event.cpp
+++ b/core/os/input_event.cpp
@@ -30,7 +30,7 @@
 #include "input_map.h"
 #include "os/keyboard.h"
 /**
- * 
+ *
  */
 
 bool InputEvent::operator==(const InputEvent &p_event) const {
@@ -40,15 +40,15 @@ bool InputEvent::operator==(const InputEvent &p_event) const {
 InputEvent::operator String() const {
 
 	String str="Device "+itos(device)+" ID "+itos(ID)+" ";
-	
+
 	switch(type) {
-	
+
 		case NONE: {
-		
+
 			return "Event: None";
 		} break;
 		case KEY: {
-			
+
 			str+= "Event: Key ";
 			str=str+"Unicode: "+String::chr(key.unicode)+" Scan: "+itos( key.scancode )+" Echo: "+String(key.echo?"True":"False")+" Pressed"+String(key.pressed?"True":"False")+" Mod: ";
 			if (key.mod.shift)
@@ -59,15 +59,15 @@ InputEvent::operator String() const {
 				str+="A";
 			if (key.mod.meta)
 				str+="M";
-				
+
 			return str;
 		} break;
 		case MOUSE_MOTION: {
-		
+
 			str+= "Event: Motion ";
 			str=str+" Pos: " +itos(mouse_motion.x)+","+itos(mouse_motion.y)+" Rel: "+itos(mouse_motion.relative_x)+","+itos(mouse_motion.relative_y)+" Mask: ";
 			for (int i=0;i<8;i++) {
-			
+
 				if ((1<<i)&mouse_motion.button_mask)
 					str+=itos(i+1);
 			}
@@ -87,7 +87,7 @@ InputEvent::operator String() const {
 			str+= "Event: Button ";
 			str=str+"Pressed: "+itos(mouse_button.pressed)+" Pos: " +itos(mouse_button.x)+","+itos(mouse_button.y)+" Button: "+itos(mouse_button.button_index)+" Mask: ";
 			for (int i=0;i<8;i++) {
-			
+
 				if ((1<<i)&mouse_button.button_mask)
 					str+=itos(i+1);
 			}
@@ -102,9 +102,9 @@ InputEvent::operator String() const {
 				str+="M";
 
 			str+=String(" DoubleClick: ")+(mouse_button.doubleclick?"Yes":"No");
-			
+
 			return str;
-		
+
 		} break;
 		case JOYSTICK_MOTION: {
 			str+= "Event: JoystickMotion ";
@@ -137,7 +137,7 @@ InputEvent::operator String() const {
 		} break;
 
 	}
-	
+
 	return "";
 }
 
diff --git a/core/os/input_event.h b/core/os/input_event.h
index 36c1556524..0588374790 100644
--- a/core/os/input_event.h
+++ b/core/os/input_event.h
@@ -189,7 +189,7 @@ struct InputModifierState {
 struct InputEventKey  {
 
 	InputModifierState mod;
-		
+
 	bool pressed; /// otherwise release
 
 	uint32_t scancode; ///< check keyboard.h , KeyCode enum, without modifier masks
@@ -212,11 +212,11 @@ struct InputEventMouse  {
 
 struct InputEventMouseButton : public InputEventMouse {
 
-	
+
 	int button_index;
 	bool pressed; //otherwise released
 	bool doubleclick; //last even less than doubleclick time
-	
+
 };
 
 struct InputEventMouseMotion : public InputEventMouse {
diff --git a/core/os/keyboard.h b/core/os/keyboard.h
index 0848f8c28e..80472acc09 100644
--- a/core/os/keyboard.h
+++ b/core/os/keyboard.h
@@ -121,7 +121,7 @@ enum KeyList {
 	KEY_DIRECTION_R=SPKEY | 0x33,
 	KEY_BACK=SPKEY | 0x40,
 	KEY_FORWARD=SPKEY | 0x41,
-	KEY_STOP=SPKEY | 0x42, 
+	KEY_STOP=SPKEY | 0x42,
 	KEY_REFRESH=SPKEY | 0x43,
 	KEY_VOLUMEDOWN=SPKEY | 0x44,
 	KEY_VOLUMEMUTE=SPKEY | 0x45,
@@ -159,11 +159,11 @@ enum KeyList {
 	KEY_LAUNCHD=SPKEY | 0x65,
 	KEY_LAUNCHE=SPKEY | 0x66,
 	KEY_LAUNCHF=SPKEY | 0x67,
-	
+
 	KEY_UNKNOWN=SPKEY | 0xFFFFFF,
-		
+
 /* PRINTABLE LATIN 1 CODES */
-	
+
 	KEY_SPACE=0x0020,
 	KEY_EXCLAM=0x0021,
 	KEY_QUOTEDBL=0x0022,
@@ -297,18 +297,18 @@ enum KeyList {
 	KEY_YACUTE=0x00DD,
 	KEY_THORN=0x00DE,
 	KEY_SSHARP=0x00DF,
-	
+
 	KEY_DIVISION=0x00F7,
 	KEY_YDIAERESIS=0x00FF,
-		
-		
+
+
 };
 
 
 enum KeyModifierMask {
-	
+
 	KEY_CODE_MASK=((1<<25)-1), ///< Apply this mask to any keycode to remove modifiers.
-	KEY_MODIFIER_MASK=(0xFF<<24), ///< Apply this mask to isolate modifiers.	
+	KEY_MODIFIER_MASK=(0xFF<<24), ///< Apply this mask to isolate modifiers.
 	KEY_MASK_SHIFT = (1<<25),
 	KEY_MASK_ALT = (1<<26),
 	KEY_MASK_META = (1<<27),
@@ -322,7 +322,7 @@ enum KeyModifierMask {
 	KEY_MASK_KPAD = (1<<29),
 	KEY_MASK_GROUP_SWITCH = (1<<30)
 	// bit 31 can't be used because variant uses regular 32 bits int as datatype
-		
+
 };
 
 String keycode_get_string(uint32_t p_code);
diff --git a/core/os/main_loop.h b/core/os/main_loop.h
index 059624dbe4..a34014983e 100644
--- a/core/os/main_loop.h
+++ b/core/os/main_loop.h
@@ -36,7 +36,7 @@
 	@author Juan Linietsky <reduzio@gmail.com>
 */
 class MainLoop : public Object {
-	
+
 	OBJ_TYPE( MainLoop, Object );
 	OBJ_CATEGORY("Main Loop");
 
@@ -44,7 +44,7 @@ class MainLoop : public Object {
 protected:
 	static void _bind_methods();
 
-public:	
+public:
 
 	enum {
 		NOTIFICATION_WM_MOUSE_ENTER = 3,
@@ -55,7 +55,7 @@ public:
 		NOTIFICATION_WM_UNFOCUS_REQUEST = 8,
 		NOTIFICATION_OS_MEMORY_WARNING = 9,
 	};
-	
+
 	virtual void input_event( const InputEvent& p_event );
 	virtual void input_text( const String& p_text );
 
diff --git a/core/os/memory.cpp b/core/os/memory.cpp
index f7f8fef2b7..c2ff2aa781 100644
--- a/core/os/memory.cpp
+++ b/core/os/memory.cpp
@@ -88,16 +88,16 @@ void Memory::dump_static_mem_to_file(const char* p_file) {
 MID Memory::alloc_dynamic(size_t p_bytes, const char *p_descr) {
 
 	MemoryPoolDynamic::ID id = MemoryPoolDynamic::get_singleton()->alloc(p_bytes,p_descr);
-	
+
 	return MID(id);
 }
 Error Memory::realloc_dynamic(MID p_mid,size_t p_bytes) {
 
 	MemoryPoolDynamic::ID id = p_mid.data?p_mid.data->id:MemoryPoolDynamic::INVALID_ID;
-	
+
 	if (id==MemoryPoolDynamic::INVALID_ID)
 		return ERR_INVALID_PARAMETER;
-		
+
 	return MemoryPoolDynamic::get_singleton()->realloc(p_mid, p_bytes);
 
 }
diff --git a/core/os/memory.h b/core/os/memory.h
index 8eb5ceccb6..8257e66851 100644
--- a/core/os/memory.h
+++ b/core/os/memory.h
@@ -42,61 +42,61 @@
 class MID {
 
 	struct Data {
-	
+
 		SafeRefCount refcount;
 		MemoryPoolDynamic::ID id;
 	};
 
 	mutable Data *data;
-	
+
 	void unref() {
-	
+
 		if (!data)
 			return;
 		if (data->refcount.unref()) {
-		
+
 			if (data->id!=MemoryPoolDynamic::INVALID_ID)
-				MemoryPoolDynamic::get_singleton()->free(data->id);	
-			MemoryPoolStatic::get_singleton()->free(data);	
+				MemoryPoolDynamic::get_singleton()->free(data->id);
+			MemoryPoolStatic::get_singleton()->free(data);
 		}
-		
+
 		data=NULL;
 	}
-	
+
 	void ref(Data *p_data) {
-	
+
 		if (data==p_data)
 			return;
 		unref();
-		
+
 		if (p_data && p_data->refcount.ref())
-			data=p_data;		
+			data=p_data;
 	}
-	
+
 friend class MID_Lock;
 
 	inline void lock() {
-	
+
 		if (data && data->id!=MemoryPoolDynamic::INVALID_ID)
 			MemoryPoolDynamic::get_singleton()->lock(data->id);
 	}
 	inline void unlock() {
-	
+
 		if (data && data->id!=MemoryPoolDynamic::INVALID_ID)
 			MemoryPoolDynamic::get_singleton()->unlock(data->id);
-	
+
 	}
-	
+
 	inline void * get() {
-	
+
 		if (data && data->id!=MemoryPoolDynamic::INVALID_ID)
 			return MemoryPoolDynamic::get_singleton()->get(data->id);
-		
+
 		return NULL;
 	}
-	
-	Error _resize(size_t p_size) { 
-				
+
+	Error _resize(size_t p_size) {
+
 		if (p_size==0 && (!data || data->id==MemoryPoolDynamic::INVALID_ID))
 				return OK;
 		if (p_size && !data) {
@@ -104,46 +104,46 @@ friend class MID_Lock;
 			data = (Data*)MemoryPoolStatic::get_singleton()->alloc(sizeof(Data),"MID::Data");
 			ERR_FAIL_COND_V( !data,ERR_OUT_OF_MEMORY );
 			data->refcount.init();
-			data->id=MemoryPoolDynamic::INVALID_ID;			
+			data->id=MemoryPoolDynamic::INVALID_ID;
 		}
-		
+
 		if (p_size==0 && data && data->id==MemoryPoolDynamic::INVALID_ID) {
-		
+
 			MemoryPoolDynamic::get_singleton()->free(data->id);
 			data->id=MemoryPoolDynamic::INVALID_ID;
 		}
-		
+
 		if (p_size>0) {
-		 
+
 		 	if (data->id==MemoryPoolDynamic::INVALID_ID) {
-		
+
 				data->id=MemoryPoolDynamic::get_singleton()->alloc(p_size,"Unnamed MID");
 				ERR_FAIL_COND_V( data->id==MemoryPoolDynamic::INVALID_ID, ERR_OUT_OF_MEMORY );
 
 			} else {
-			
+
 				MemoryPoolDynamic::get_singleton()->realloc(data->id,p_size);
 				ERR_FAIL_COND_V( data->id==MemoryPoolDynamic::INVALID_ID, ERR_OUT_OF_MEMORY );
-			
+
 			}
-		}				
-		
+		}
+
 		return OK;
 	}
 friend class Memory;
-	
+
 	MID(MemoryPoolDynamic::ID p_id) {
-	
+
 		data = (Data*)MemoryPoolStatic::get_singleton()->alloc(sizeof(Data),"MID::Data");
 		data->refcount.init();
 		data->id=p_id;
 	}
-public:	
+public:
 
 	bool is_valid() const { return data; }
 	operator bool() const { return data; }
-	
-		
+
+
 	size_t get_size() const { return (data && data->id!=MemoryPoolDynamic::INVALID_ID) ? MemoryPoolDynamic::get_singleton()->get_size(data->id) : 0; }
 	Error resize(size_t p_size) { return _resize(p_size); }
 	inline void operator=(const MID& p_mid) { ref( p_mid.data ); }
@@ -157,7 +157,7 @@ public:
 class MID_Lock {
 
 	MID mid;
-	
+
 public:
 
 	void *data() { return mid.get(); }
@@ -174,21 +174,21 @@ class Memory{
 
 	Memory();
 public:
-    
+
 	static void * alloc_static(size_t p_bytes,const char *p_descr="");
 	static void * realloc_static(void *p_memory,size_t p_bytes);
 	static void free_static(void *p_ptr);
 	static size_t get_static_mem_available();
-	static size_t get_static_mem_usage(); 
+	static size_t get_static_mem_usage();
 	static size_t get_static_mem_max_usage();
 	static void dump_static_mem_to_file(const char* p_file);
 
 	static MID alloc_dynamic(size_t p_bytes, const char *p_descr="");
 	static Error realloc_dynamic(MID p_mid,size_t p_bytes);
-    
+
 	static size_t get_dynamic_mem_available();
 	static size_t get_dynamic_mem_usage();
-    
+
 };
 
 template<class T>
@@ -241,7 +241,7 @@ _ALWAYS_INLINE_ void postinitialize_handler(void *) {}
 
 template<class T>
 _ALWAYS_INLINE_ T *_post_initialize(T *p_obj) {
-	
+
 	postinitialize_handler(p_obj);
 	return p_obj;
 }
@@ -272,7 +272,7 @@ _ALWAYS_INLINE_ bool predelete_handler(void *) { return true; }
 
 template<class T>
 void memdelete(T *p_class) {
-		
+
 	if (!predelete_handler(p_class))
 		return; // doesn't want to be deleted
 	p_class->~T();
diff --git a/core/os/memory_pool_dynamic.h b/core/os/memory_pool_dynamic.h
index 82149bcf5d..70752fb10d 100644
--- a/core/os/memory_pool_dynamic.h
+++ b/core/os/memory_pool_dynamic.h
@@ -40,10 +40,10 @@ friend class Memory;
 friend class MID;
 
 	enum {
-	
+
 		INVALID_ID=0xFFFFFFFF
 	};
-	
+
 	static MemoryPoolDynamic* get_singleton();
 
 	typedef uint64_t ID;
@@ -55,12 +55,12 @@ friend class MID;
 	virtual bool is_valid(ID p_id)=0;
 	virtual size_t get_size(ID p_id) const=0;
 	virtual const char* get_description(ID p_id) const=0;
-	
+
 	virtual Error lock(ID p_id)=0;
 	virtual void * get(ID p_ID)=0;
 	virtual Error unlock(ID p_id)=0;
 	virtual bool is_locked(ID p_id) const=0;
-	
+
 	virtual size_t get_available_mem() const=0;
 	virtual size_t get_total_usage() const=0;
 
diff --git a/core/os/memory_pool_dynamic_static.cpp b/core/os/memory_pool_dynamic_static.cpp
index 894066708e..c047c931ec 100644
--- a/core/os/memory_pool_dynamic_static.cpp
+++ b/core/os/memory_pool_dynamic_static.cpp
@@ -37,10 +37,10 @@ MemoryPoolDynamicStatic::Chunk *MemoryPoolDynamicStatic::get_chunk(ID p_id) {
 
 	uint64_t check = p_id/MAX_CHUNKS;
 	uint64_t idx = p_id%MAX_CHUNKS;
-	
+
 	if (!chunk[idx].mem || chunk[idx].check!=check)
 		return NULL;
-		
+
 	return &chunk[idx];
 }
 
@@ -49,32 +49,32 @@ const MemoryPoolDynamicStatic::Chunk *MemoryPoolDynamicStatic::get_chunk(ID p_id
 
 	uint64_t check = p_id/MAX_CHUNKS;
 	uint64_t idx = p_id%MAX_CHUNKS;
-	
+
 	if (!chunk[idx].mem || chunk[idx].check!=check)
 		return NULL;
-		
+
 	return &chunk[idx];
 }
 
 MemoryPoolDynamic::ID MemoryPoolDynamicStatic::alloc(size_t p_amount,const char* p_description) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	int idx=-1;
-	
+
 	for (int i=0;i<MAX_CHUNKS;i++) {
-	
+
 		last_alloc++;
 		if (last_alloc>=MAX_CHUNKS)
 			last_alloc=0;
-			
+
 		if ( !chunk[last_alloc].mem ) {
-		
+
 			idx=last_alloc;
 			break;
 		}
 	}
-	
+
 
 	if (idx==-1) {
 		ERR_EXPLAIN("Out of dynamic Memory IDs");
@@ -86,36 +86,36 @@ MemoryPoolDynamic::ID MemoryPoolDynamicStatic::alloc(size_t p_amount,const char*
 	chunk[idx].mem = memalloc(p_amount);
 	if (!chunk[idx].mem)
 		return INVALID_ID;
-		
+
 	chunk[idx].size=p_amount;
 	chunk[idx].check=++last_check;
 	chunk[idx].descr=p_description;
 	chunk[idx].lock=0;
-	
+
 	total_usage+=p_amount;
 	if (total_usage>max_usage)
 		max_usage=total_usage;
-	
+
 	ID id = chunk[idx].check*MAX_CHUNKS + (uint64_t)idx;
-	
+
 	return id;
-	
+
 }
 void MemoryPoolDynamicStatic::free(ID p_id) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND(!c);
-	
-	
+
+
 	total_usage-=c->size;
 	memfree(c->mem);
 
 	c->mem=0;
-	
+
 	if (c->lock>0) {
-	
+
 		ERR_PRINT("Freed ID Still locked");
 	}
 }
@@ -123,14 +123,14 @@ void MemoryPoolDynamicStatic::free(ID p_id) {
 Error MemoryPoolDynamicStatic::realloc(ID p_id, size_t p_amount) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND_V(!c,ERR_INVALID_PARAMETER);
 	ERR_FAIL_COND_V(c->lock > 0 , ERR_LOCKED );
-	
-	
+
+
 	void * new_mem = memrealloc(c->mem,p_amount);
-	
+
 	ERR_FAIL_COND_V(!new_mem,ERR_OUT_OF_MEMORY);
 	total_usage-=c->size;
 	c->mem=new_mem;
@@ -138,37 +138,37 @@ Error MemoryPoolDynamicStatic::realloc(ID p_id, size_t p_amount) {
 	total_usage+=c->size;
 	if (total_usage>max_usage)
 		max_usage=total_usage;
-	
+
 
 	return OK;
 }
 bool MemoryPoolDynamicStatic::is_valid(ID p_id) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	Chunk *c = get_chunk(p_id);
-	
+
 	return c!=NULL;
 
 }
 size_t MemoryPoolDynamicStatic::get_size(ID p_id) const {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	const Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND_V(!c,0);
-	
+
 	return c->size;
-	
+
 
 }
 const char* MemoryPoolDynamicStatic::get_description(ID p_id) const {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	const Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND_V(!c,"");
-	
+
 	return c->descr;
 
 }
@@ -177,10 +177,10 @@ const char* MemoryPoolDynamicStatic::get_description(ID p_id) const {
 bool MemoryPoolDynamicStatic::is_locked(ID p_id) const {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	const Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND_V(!c,false);
-	
+
 	return c->lock>0;
 
 }
@@ -188,10 +188,10 @@ bool MemoryPoolDynamicStatic::is_locked(ID p_id) const {
 Error MemoryPoolDynamicStatic::lock(ID p_id) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND_V(!c,ERR_INVALID_PARAMETER);
-	
+
 	c->lock++;
 
 	return OK;
@@ -199,23 +199,23 @@ Error MemoryPoolDynamicStatic::lock(ID p_id) {
 void * MemoryPoolDynamicStatic::get(ID p_id) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	const Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND_V(!c,NULL);
 	ERR_FAIL_COND_V( c->lock==0, NULL );
-	
+
 	return c->mem;
 }
 Error MemoryPoolDynamicStatic::unlock(ID p_id) {
 
 	_THREAD_SAFE_METHOD_
-	
+
 	Chunk *c = get_chunk(p_id);
 	ERR_FAIL_COND_V(!c,ERR_INVALID_PARAMETER);
-	
+
 	ERR_FAIL_COND_V( c->lock<=0, ERR_INVALID_PARAMETER );
 	c->lock--;
-	
+
 	return OK;
 }
 
@@ -226,7 +226,7 @@ size_t MemoryPoolDynamicStatic::get_available_mem() const {
 
 size_t MemoryPoolDynamicStatic::get_total_usage() const {
 	_THREAD_SAFE_METHOD_
-	
+
 	return total_usage;
 }
 
diff --git a/core/os/memory_pool_dynamic_static.h b/core/os/memory_pool_dynamic_static.h
index 6177c78de7..a72d39355c 100644
--- a/core/os/memory_pool_dynamic_static.h
+++ b/core/os/memory_pool_dynamic_static.h
@@ -40,19 +40,19 @@ class MemoryPoolDynamicStatic : public MemoryPoolDynamic {
 	enum {
 		MAX_CHUNKS=65536
 	};
-	
-	
+
+
 	struct Chunk {
-	
+
 		uint64_t lock;
 		uint64_t check;
 		void *mem;
 		size_t size;
-		const char *descr;	
-		
+		const char *descr;
+
 		Chunk() { mem=NULL; lock=0; check=0; }
 	};
-	
+
 	Chunk chunk[MAX_CHUNKS];
 	uint64_t last_check;
 	int last_alloc;
@@ -62,14 +62,14 @@ class MemoryPoolDynamicStatic : public MemoryPoolDynamic {
 	Chunk *get_chunk(ID p_id);
 	const Chunk *get_chunk(ID p_id) const;
 public:
-		
+
 	virtual ID alloc(size_t p_amount,const char* p_description);
 	virtual void free(ID p_id);
 	virtual Error realloc(ID p_id, size_t p_amount);
 	virtual bool is_valid(ID p_id);
 	virtual size_t get_size(ID p_id) const;
 	virtual const char* get_description(ID p_id) const;
-	
+
 	virtual bool is_locked(ID p_id) const;
 	virtual Error lock(ID p_id);
 	virtual void * get(ID p_ID);
diff --git a/core/os/memory_pool_static.cpp b/core/os/memory_pool_static.cpp
index 321f4d989e..88c2ba3b3e 100644
--- a/core/os/memory_pool_static.cpp
+++ b/core/os/memory_pool_static.cpp
@@ -31,13 +31,13 @@
 MemoryPoolStatic *MemoryPoolStatic::singleton=0;
 
 MemoryPoolStatic *MemoryPoolStatic::get_singleton() {
-	
+
 	return singleton;
 }
 
 
 MemoryPoolStatic::MemoryPoolStatic() {
-	
+
 	singleton=this;
 }
 
diff --git a/core/os/memory_pool_static.h b/core/os/memory_pool_static.h
index 2e11b7ded4..f7f60b8df8 100644
--- a/core/os/memory_pool_static.h
+++ b/core/os/memory_pool_static.h
@@ -38,17 +38,17 @@
 */
 class MemoryPoolStatic {
 private:
-	
+
 	static MemoryPoolStatic *singleton;
 
 public:
-	
+
 	static MemoryPoolStatic *get_singleton();
-	
+
 	virtual void* alloc(size_t p_bytes,const char *p_description)=0; ///< Pointer in p_description shold be to a const char const like "hello"
 	virtual void* realloc(void * p_memory,size_t p_bytes)=0; ///< Pointer in p_description shold be to a const char const like "hello"
 	virtual void free(void *p_ptr)=0; ///< Pointer in p_description shold be to a const char const
-	
+
 	virtual size_t get_available_mem() const=0;
 	virtual size_t get_total_usage()=0;
 	virtual size_t get_max_usage()=0;
diff --git a/core/os/mutex.cpp b/core/os/mutex.cpp
index 9b379009b9..21400d2ccf 100644
--- a/core/os/mutex.cpp
+++ b/core/os/mutex.cpp
@@ -50,13 +50,13 @@ Mutex::~Mutex() {
 Mutex *_global_mutex=NULL;;
 
 void _global_lock() {
-	
+
 	if (_global_mutex)
 		_global_mutex->lock();
 }
 void _global_unlock() {
-	
+
 	if (_global_mutex)
-		_global_mutex->unlock();	
+		_global_mutex->unlock();
 }
 
diff --git a/core/os/mutex.h b/core/os/mutex.h
index f16375aa26..5870171dc7 100644
--- a/core/os/mutex.h
+++ b/core/os/mutex.h
@@ -33,7 +33,7 @@
 
 
 /**
- * @class Mutex 
+ * @class Mutex
  * @author Juan Linietsky
  * Portable Mutex (thread-safe locking) implementation.
  * Mutexes are always recursive ( they don't self-lock in a single thread ).
@@ -43,9 +43,9 @@
 
 
 class Mutex {
-protected:	
+protected:
 	static Mutex* (*create_func)(bool);
-	
+
 public:
 
 	virtual void lock()=0; ///< Lock the mutex, block if locked by someone else
@@ -53,7 +53,7 @@ public:
 	virtual Error try_lock()=0; ///< Attempt to lock the mutex, OK on success, ERROR means it can't lock.
 
 	static Mutex * create(bool p_recursive=true); ///< Create a mutex
-	
+
 	virtual ~Mutex();
 };
 
diff --git a/core/os/os.h b/core/os/os.h
index a80b81bfa2..65ce44465b 100644
--- a/core/os/os.h
+++ b/core/os/os.h
@@ -71,7 +71,7 @@ public:
 		RENDER_SEPARATE_THREAD
 	};
 	struct VideoMode {
-	
+
 		int width,height;
 		bool fullscreen;
 		bool resizable;
@@ -80,33 +80,33 @@ public:
 	};
 protected:
 friend class Main;
-	
+
 	RenderThreadMode _render_thread_mode;
 
 	// functions used by main to initialize/deintialize the OS
 	virtual int get_video_driver_count() const=0;
 	virtual const char * get_video_driver_name(int p_driver) const=0;
-	
+
 	virtual VideoMode get_default_video_mode() const=0;
-	
+
 	virtual int get_audio_driver_count() const=0;
 	virtual const char * get_audio_driver_name(int p_driver) const=0;
-	
+
 	virtual void initialize_core()=0;
 	virtual void initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver)=0;
-	
-	virtual void set_main_loop( MainLoop * p_main_loop )=0;    
+
+	virtual void set_main_loop( MainLoop * p_main_loop )=0;
 	virtual void delete_main_loop()=0;
-	
+
 	virtual void finalize()=0;
 	virtual void finalize_core()=0;
 
 	virtual void set_cmdline(const char* p_execpath, const List<String>& p_args);
 
 	void _ensure_data_dir();
-	
+
 public:
-	
+
 	typedef int64_t ProcessID;
 
 	static OS* get_singleton();
@@ -148,7 +148,7 @@ public:
 
 	virtual void set_clipboard(const String& p_text);
 	virtual String get_clipboard() const;
-	
+
 	virtual void set_video_mode(const VideoMode& p_video_mode,int p_screen=0)=0;
 	virtual VideoMode get_video_mode(int p_screen=0) const=0;
 	virtual void get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen=0) const=0;
@@ -219,7 +219,7 @@ public:
 		DAY_FRIDAY,
 		DAY_SATURDAY
 	};
-	
+
 	enum Month {
 		MONTH_JANUARY,
 		MONTH_FEBRUARY,
@@ -236,7 +236,7 @@ public:
 	};
 
 	struct Date {
-		
+
 		int year;
 		Month month;
 		int day;
@@ -245,7 +245,7 @@ public:
 	};
 
 	struct Time {
-	
+
 		int hour;
 		int min;
 		int sec;
@@ -262,7 +262,7 @@ public:
 	virtual uint64_t get_unix_time() const;
 	virtual uint64_t get_system_time_secs() const;
 
-	virtual void delay_usec(uint32_t p_usec) const=0; 
+	virtual void delay_usec(uint32_t p_usec) const=0;
 	virtual uint64_t get_ticks_usec() const=0;
 	uint32_t get_ticks_msec() const;
 	uint64_t get_splash_tick_msec() const;
@@ -412,7 +412,7 @@ public:
 
 	virtual void set_context(int p_context);
 
-	OS();	
+	OS();
 	virtual ~OS();
 
 };
diff --git a/core/os/semaphore.h b/core/os/semaphore.h
index b65542ce35..8469408e65 100644
--- a/core/os/semaphore.h
+++ b/core/os/semaphore.h
@@ -35,17 +35,17 @@
 	@author Juan Linietsky <reduzio@gmail.com>
 */
 class Semaphore {
-protected:	
+protected:
 	static Semaphore* (*create_func)();
-	
+
 public:
 
 	virtual Error wait()=0; ///< wait until semaphore has positive value, then decrement and pass
 	virtual Error post()=0; ///< unlock the semaphore, incrementing the    value
 	virtual int get() const=0; ///< get semaphore value
-	
+
 	static Semaphore * create(); ///< Create a mutex
-	
+
 	virtual ~Semaphore();
 };
 
diff --git a/core/os/shell.h b/core/os/shell.h
index 805dd70301..8b0c286d73 100644
--- a/core/os/shell.h
+++ b/core/os/shell.h
@@ -42,7 +42,7 @@ public:
 
 	static Shell * get_singleton();
 	virtual void execute(String p_path)=0;
-	
+
 	Shell();
 	virtual ~Shell();
 };
diff --git a/core/os/thread.cpp b/core/os/thread.cpp
index f5d984876d..c1ae53074b 100644
--- a/core/os/thread.cpp
+++ b/core/os/thread.cpp
@@ -37,26 +37,26 @@ Error (*Thread::set_name_func)(const String&)=NULL;
 Thread::ID Thread::_main_thread_id=0;
 
 Thread::ID Thread::get_caller_ID() {
-	
+
 	if (get_thread_ID_func)
 		return get_thread_ID_func();
 	return 0;
 }
 
 Thread* Thread::create(ThreadCreateCallback p_callback,void * p_user,const Settings& p_settings) {
-	
+
 	if (create_func) {
-		 
+
 		return create_func(p_callback,p_user,p_settings);
 	}
 	return NULL;
 }
 
 void Thread::wait_to_finish(Thread *p_thread) {
-	
+
 	if (wait_to_finish_func)
 		wait_to_finish_func(p_thread);
-		
+
 }
 
 Error Thread::set_name(const String &p_name) {
diff --git a/core/os/thread.h b/core/os/thread.h
index 4fead72b94..7349b83dbc 100644
--- a/core/os/thread.h
+++ b/core/os/thread.h
@@ -41,25 +41,25 @@ typedef void (*ThreadCreateCallback)(void *p_userdata);
 
 class Thread {
 public:
-			
+
 	enum Priority {
-		
+
 		PRIORITY_LOW,
   		PRIORITY_NORMAL,
 		PRIORITY_HIGH
 	};
-	
+
 	struct Settings {
-		
+
 		Priority priority;
 		Settings() { priority=PRIORITY_NORMAL; }
 	};
-	
+
 
 
 	typedef uint64_t ID;
 
-protected:	
+protected:
 	static Thread* (*create_func)(ThreadCreateCallback p_callback,void *,const Settings&);
 	static ID (*get_thread_ID_func)();
 	static void (*wait_to_finish_func)(Thread*);
@@ -72,7 +72,7 @@ protected:
 
 	Thread();
 public:
-		
+
 
 	virtual ID get_ID() const=0;
 
@@ -81,8 +81,8 @@ public:
 	static ID get_caller_ID(); ///< get the ID of the caller function ID
 	static void wait_to_finish(Thread *p_thread); ///< waits until thread is finished, and deallocates it.
 	static Thread * create(ThreadCreateCallback p_callback,void * p_user,const Settings& p_settings=Settings()); ///< Static function to create a thread, will call p_callback
-	
-	
+
+
 	virtual ~Thread();
 
 };
diff --git a/core/os/thread_safe.cpp b/core/os/thread_safe.cpp
index f252190504..a742b1144e 100644
--- a/core/os/thread_safe.cpp
+++ b/core/os/thread_safe.cpp
@@ -30,17 +30,17 @@
 #include "error_macros.h"
 #include "os/memory.h"
 
-ThreadSafe::ThreadSafe() { 
+ThreadSafe::ThreadSafe() {
 
-	mutex = Mutex::create(); 
+	mutex = Mutex::create();
 	if (!mutex) {
-		
+
 		WARN_PRINT("THREAD_SAFE defined, but no default mutex type");
 	}
 }
 
-ThreadSafe::~ThreadSafe() { 
-	
-	if (mutex) 
-		memdelete( mutex ); 
+ThreadSafe::~ThreadSafe() {
+
+	if (mutex)
+		memdelete( mutex );
 }
diff --git a/core/os/thread_safe.h b/core/os/thread_safe.h
index 793dd88543..1c82cbe704 100644
--- a/core/os/thread_safe.h
+++ b/core/os/thread_safe.h
@@ -42,7 +42,7 @@ public:
 
 	ThreadSafe();
 	~ThreadSafe();
-	
+
 };
 
 
@@ -51,11 +51,11 @@ class ThreadSafeMethod {
 	const ThreadSafe *_ts;
 public:
 	ThreadSafeMethod(const ThreadSafe *p_ts) {
-	
+
 		_ts=p_ts;
 		_ts->lock();
 	}
-	
+
 	~ThreadSafeMethod() { _ts->unlock(); }
 };
 
diff --git a/core/packed_data_container.cpp b/core/packed_data_container.cpp
index dd736502a3..91f886ff4b 100644
--- a/core/packed_data_container.cpp
+++ b/core/packed_data_container.cpp
@@ -182,12 +182,12 @@ Variant PackedDataContainer::_key_at_ofs(uint32_t p_ofs,const Variant& p_key,boo
 			err=true;
 			return Variant();
 		}
-		
+
 	} else if (type==TYPE_DICT) {
 
 		uint32_t hash=p_key.hash();
 		uint32_t len = decode_uint32(r+4);
-		
+
 		bool found=false;
 		for(int i=0;i<len;i++) {
 			uint32_t khash=decode_uint32(r+8+i*12+0);
@@ -214,7 +214,7 @@ Variant PackedDataContainer::_key_at_ofs(uint32_t p_ofs,const Variant& p_key,boo
 		err=true;
 		return Variant();
 	}
- 
+
 
 }
 
diff --git a/core/path_db.cpp b/core/path_db.cpp
index d3521fcb23..7545088978 100644
--- a/core/path_db.cpp
+++ b/core/path_db.cpp
@@ -58,17 +58,17 @@ bool NodePath::is_absolute() const {
 
 	if (!data)
 		return false;
-		
+
 	return data->absolute;
-	
+
 }
 int NodePath::get_name_count() const {
 
 	if (!data)
 		return 0;
-		
+
 	return data->path.size();
-	
+
 }
 StringName NodePath::get_name(int p_idx) const {
 
@@ -103,24 +103,24 @@ StringName NodePath::get_subname(int p_idx) const {
 void NodePath::unref() {
 
 	if (data && data->refcount.unref()) {
-	
+
 		memdelete(data);
 	}
 	data=NULL;
-	
+
 }
-	
+
 bool NodePath::operator==(const NodePath& p_path) const {
 
 	if (data==p_path.data)
 		return true;
-		
+
 	if (!data || !p_path.data)
 		return false;
-		
+
 	if (data->absolute != p_path.data->absolute)
 		return false;
-		
+
 	if (data->path.size() != p_path.data->path.size())
 		return false;
 
@@ -131,7 +131,7 @@ bool NodePath::operator==(const NodePath& p_path) const {
 		return false;
 
 	for (int i=0;i<data->path.size();i++) {
-	
+
 		if (data->path[i]!=p_path.data->path[i])
 			return false;
 	}
@@ -148,17 +148,17 @@ bool NodePath::operator!=(const NodePath& p_path) const {
 
 	return (!(*this == p_path));
 }
-	
-	
+
+
 void NodePath::operator=(const NodePath& p_path) {
 
 	if (this==&p_path)
 		return;
 
 	unref();
-	
+
 	if (p_path.data && p_path.data->refcount.ref()) {
-	
+
 		data=p_path.data;
 	}
 }
@@ -167,13 +167,13 @@ NodePath::operator String() const {
 
 	if (!data)
 		return String();
-		
+
 	String ret;
 	if (data->absolute)
 		ret="/";
-		
+
 	for (int i=0;i<data->path.size();i++) {
-	
+
 		if (i>0)
 			ret+="/";
 		ret+=data->path[i].operator String();
@@ -184,7 +184,7 @@ NodePath::operator String() const {
 		ret+=":"+data->subpath[i].operator String();
 	}
 
-	if (data->property.operator String()!="") 
+	if (data->property.operator String()!="")
 		ret+=":"+String(data->property);
 	return ret;
 }
@@ -195,7 +195,7 @@ NodePath::NodePath(const NodePath& p_path) {
 	data=NULL;
 
 	if (p_path.data && p_path.data->refcount.ref()) {
-	
+
 		data=p_path.data;
 	}
 }
@@ -258,17 +258,17 @@ NodePath NodePath::rel_path_to(const NodePath& p_np) const {
 
 
 NodePath::NodePath(const Vector<StringName>& p_path,bool p_absolute,const String& p_property) {
-	
+
 	data=NULL;
-	
+
 	if (p_path.size()==0)
 		return;
-	
+
 	data = memnew( Data );
 	data->refcount.init();
 	data->absolute=p_absolute;
 	data->path=p_path;
-	data->property=p_property;	
+	data->property=p_property;
 }
 
 NodePath::NodePath(const Vector<StringName>& p_path,const Vector<StringName>& p_subpath,bool p_absolute,const String& p_property) {
@@ -327,17 +327,17 @@ NodePath::NodePath(const String& p_path) {
 	String path=p_path;
 	StringName property;
 	Vector<StringName> subpath;
-		
-	int absolute=(path[0]=='/')?1:0;;	
+
+	int absolute=(path[0]=='/')?1:0;;
 	bool valid=false;
 	bool last_is_slash=true;
 	int slices=0;
 	int subpath_pos=path.find(":");
 
 
-	
+
 	if (subpath_pos!=-1) {
-	
+
 		int from=subpath_pos+1;
 
 		for (int i=from;i<=path.length();i++) {
@@ -362,44 +362,44 @@ NodePath::NodePath(const String& p_path) {
 
 		path=path.substr(0,subpath_pos);
 	}
-	
+
 	for (int i=absolute;i<path.length();i++) {
-	
+
 		if (path[i]=='/') {
-		
+
 			last_is_slash=true;
 		} else {
-		
+
 			if (last_is_slash)
 				slices++;
-				
+
 			valid=true;
 			last_is_slash=false;
 		}
 	}
-	
+
 	if (slices==0 && !absolute && !property)
 		return;
-	
+
 	data = memnew( Data );
 	data->refcount.init();
 	data->absolute=absolute?true:false;
 	data->property=property;
 	data->subpath=subpath;
-	
+
 	if (slices==0)
 		return;
-	data->path.resize(slices);		
+	data->path.resize(slices);
 	last_is_slash=true;
 	int from=absolute;
 	int slice=0;
-	
+
 	for (int i=absolute;i<path.length()+1;i++) {
-	
+
 		if (path[i]=='/' || path[i]==0) {
-					
+
 			if (!last_is_slash) {
-				
+
 				String name=path.substr(from,i-from);
 				ERR_FAIL_INDEX( slice,data->path.size() );
 				data->path[slice++]=name;
@@ -410,8 +410,8 @@ NodePath::NodePath(const String& p_path) {
 			last_is_slash=false;
 		}
 	}
-	
-	
+
+
 }
 
 bool NodePath::is_empty() const {
diff --git a/core/path_db.h b/core/path_db.h
index 9c9be65d28..63adb42955 100644
--- a/core/path_db.h
+++ b/core/path_db.h
@@ -41,14 +41,14 @@
 class NodePath {
 
 	struct Data {
-	
+
 		SafeRefCount refcount;
 		StringName property;
-		Vector<StringName> path;	
+		Vector<StringName> path;
 		Vector<StringName> subpath;
 		bool absolute;
 	};
-	
+
 	Data *data;
 	void unref();
 public:
@@ -77,7 +77,7 @@ public:
 	NodePath get_parent() const;
 
 	uint32_t hash() const;
-	
+
 	operator String() const;
 	bool is_empty() const;
 
@@ -88,7 +88,7 @@ public:
 	void simplify();
 	NodePath simplified() const;
 
-	NodePath(const Vector<StringName>& p_path,bool p_absolute,const String& p_property="");	
+	NodePath(const Vector<StringName>& p_path,bool p_absolute,const String& p_property="");
 	NodePath(const Vector<StringName>& p_path,const Vector<StringName>& p_subpath,bool p_absolute,const String& p_property="");
 	NodePath(const NodePath& p_path);
 	NodePath(const String& p_path);
diff --git a/core/pool_allocator.cpp b/core/pool_allocator.cpp
index 23be650fda..849fd75f50 100644
--- a/core/pool_allocator.cpp
+++ b/core/pool_allocator.cpp
@@ -42,11 +42,11 @@ do {								\
 } while (0);
 
 void PoolAllocator::mt_lock() const {
-	
+
 }
 
 void PoolAllocator::mt_unlock() const {
-	
+
 }
 
 
@@ -61,7 +61,7 @@ bool PoolAllocator::get_free_entry(EntryArrayPos* p_pos) {
 			*p_pos=i;
 			return true;
 		}
-		
+
 	}
 
 	ERR_PRINT("Out of memory Chunks!");
@@ -78,7 +78,7 @@ bool PoolAllocator::get_free_entry(EntryArrayPos* p_pos) {
 bool PoolAllocator::find_hole(EntryArrayPos *p_pos, int p_for_size) {
 
 	/* position where previous entry ends. Defaults to zero (begin of pool) */
-	
+
 	int prev_entry_end_pos=0;
 
 	for (int i=0;i<entry_count;i++) {
@@ -106,16 +106,16 @@ bool PoolAllocator::find_hole(EntryArrayPos *p_pos, int p_for_size) {
 		*p_pos=entry_count;
 		return true;
 	}
-	
+
 	return false;
-	
+
 }
 
 
 void PoolAllocator::compact(int p_up_to) {
-	
+
 	uint32_t prev_entry_end_pos=0;
-	
+
 	if (p_up_to<0)
 		p_up_to=entry_count;
 	for (int i=0;i<p_up_to;i++) {
@@ -129,16 +129,16 @@ void PoolAllocator::compact(int p_up_to) {
 
 		/* if we can compact, do it */
 		if (hole_size>0 && !entry.lock) {
-			
+
 			COMPACT_CHUNK(entry,prev_entry_end_pos);
-			
+
 		}
-		
+
 		/* prepare for next one */
 		prev_entry_end_pos=entry_end(entry);
 	}
-	
-	
+
+
 }
 
 void PoolAllocator::compact_up(int p_from) {
@@ -169,81 +169,81 @@ void PoolAllocator::compact_up(int p_from) {
 
 
 bool PoolAllocator::find_entry_index(EntryIndicesPos *p_map_pos,Entry *p_entry) {
-	
+
 	EntryArrayPos entry_pos=entry_max;
-	
+
 	for (int i=0;i<entry_count;i++) {
-		
+
 		if (&entry_array[ entry_indices[ i ] ]==p_entry) {
-			
+
 			entry_pos=i;
 			break;
 		}
 	}
-	
+
 	if (entry_pos==entry_max)
 		return false;
-	
+
 	*p_map_pos=entry_pos;
 	return true;
-	
+
 }
 
 PoolAllocator::ID PoolAllocator::alloc(int p_size) {
-	
+
 	ERR_FAIL_COND_V(p_size<1,POOL_ALLOCATOR_INVALID_ID);
 #ifdef DEBUG_ENABLED
 	if (p_size > free_mem) OS::get_singleton()->debug_break();
 #endif
 	ERR_FAIL_COND_V(p_size>free_mem,POOL_ALLOCATOR_INVALID_ID);
-		
+
 	mt_lock();
-	
+
 	if (entry_count==entry_max) {
 		mt_unlock();
 		ERR_PRINT("entry_count==entry_max");
 		return POOL_ALLOCATOR_INVALID_ID;
 	}
-	
-	
+
+
 	int size_to_alloc=aligned(p_size);
-	
+
 	EntryIndicesPos new_entry_indices_pos;
-	
+
 	if (!find_hole(&new_entry_indices_pos, size_to_alloc)) {
 		/* No hole could be found, try compacting mem */
 		compact();
 		/* Then search again */
-		
+
 		if (!find_hole(&new_entry_indices_pos, size_to_alloc)) {
-			
+
 			mt_unlock();
 			ERR_PRINT("memory can't be compacted further");
-			return POOL_ALLOCATOR_INVALID_ID;						
+			return POOL_ALLOCATOR_INVALID_ID;
 		}
 	}
-	
+
 	EntryArrayPos new_entry_array_pos;
-		
+
 	bool found_free_entry=get_free_entry(&new_entry_array_pos);
-	
+
 	if (!found_free_entry) {
 		mt_unlock();
 		ERR_FAIL_COND_V( !found_free_entry , POOL_ALLOCATOR_INVALID_ID );
 	}
-	
+
 	/* move all entry indices up, make room for this one */
 	for (int i=entry_count;i>new_entry_indices_pos;i--  ) {
-		
+
 		entry_indices[i]=entry_indices[i-1];
 	}
-	
+
 	entry_indices[new_entry_indices_pos]=new_entry_array_pos;
-	
+
 	entry_count++;
-	
+
 	Entry &entry=entry_array[ entry_indices[ new_entry_indices_pos ] ];
-	
+
 	entry.len=p_size;
 	entry.pos=(new_entry_indices_pos==0)?0:entry_end(entry_array[ entry_indices[ new_entry_indices_pos-1 ] ]); //alloc either at begining or end of previous
 	entry.lock=0;
@@ -251,40 +251,40 @@ PoolAllocator::ID PoolAllocator::alloc(int p_size) {
 	free_mem-=size_to_alloc;
 	if (free_mem<free_mem_peak)
 		free_mem_peak=free_mem;
-	
+
 	ID retval = (entry_indices[ new_entry_indices_pos ]<<CHECK_BITS)|entry.check;
 	mt_unlock();
 
 	//ERR_FAIL_COND_V( (uintptr_t)get(retval)%align != 0, retval );
 
 	return retval;
-	
+
 }
 
 PoolAllocator::Entry * PoolAllocator::get_entry(ID p_mem) {
-	
+
 	unsigned int check=p_mem&CHECK_MASK;
 	int entry=p_mem>>CHECK_BITS;
 	ERR_FAIL_INDEX_V(entry,entry_max,NULL);
 	ERR_FAIL_COND_V(entry_array[entry].check!=check,NULL);
 	ERR_FAIL_COND_V(entry_array[entry].len==0,NULL);
-		
+
 	return &entry_array[entry];
 }
 
 const PoolAllocator::Entry * PoolAllocator::get_entry(ID p_mem) const {
-	
+
 	unsigned int check=p_mem&CHECK_MASK;
 	int entry=p_mem>>CHECK_BITS;
 	ERR_FAIL_INDEX_V(entry,entry_max,NULL);
 	ERR_FAIL_COND_V(entry_array[entry].check!=check,NULL);
 	ERR_FAIL_COND_V(entry_array[entry].len==0,NULL);
-		
+
 	return &entry_array[entry];
 }
 
 void PoolAllocator::free(ID p_mem) {
-	
+
 	mt_lock();
 	Entry *e=get_entry(p_mem);
 	if (!e) {
@@ -297,23 +297,23 @@ void PoolAllocator::free(ID p_mem) {
 		ERR_PRINT("e->lock");
 		return;
 	}
-	
+
 	EntryIndicesPos entry_indices_pos;
-	
+
 	bool index_found = find_entry_index(&entry_indices_pos,e);
 	if (!index_found) {
-	
+
 		mt_unlock();
 		ERR_FAIL_COND(!index_found);
 	}
-	
 
-	
+
+
 	for (int i=entry_indices_pos;i<(entry_count-1);i++) {
-		
+
 		entry_indices[ i ] = entry_indices[ i+1 ];
 	}
-	
+
 	entry_count--;
 	free_mem+=aligned(e->len);
 	e->clear();
@@ -327,21 +327,21 @@ int PoolAllocator::get_size(ID p_mem) const {
 
 	const Entry *e=get_entry(p_mem);
 	if (!e) {
-		
+
 		mt_unlock();
 		ERR_PRINT("!e");
 		return 0;
 	}
-	
+
 	size=e->len;
-	
+
 	mt_unlock();
-	
+
 	return size;
-} 
+}
 
 Error PoolAllocator::resize(ID p_mem,int p_new_size) {
-	
+
 	mt_lock();
 	Entry *e=get_entry(p_mem);
 
@@ -443,18 +443,18 @@ Error PoolAllocator::resize(ID p_mem,int p_new_size) {
 
 
 Error PoolAllocator::lock(ID p_mem) {
-	
+
 	if (!needs_locking)
 		return OK;
 	mt_lock();
 	Entry *e=get_entry(p_mem);
 	if (!e) {
-		
+
 		mt_unlock();
 		ERR_PRINT("!e");
 		return ERR_INVALID_PARAMETER;
 	}
-	e->lock++;	
+	e->lock++;
 	mt_unlock();
 	return OK;
 }
@@ -480,85 +480,85 @@ bool PoolAllocator::is_locked(ID p_mem) const {
 const void *PoolAllocator::get(ID p_mem) const {
 
 	if (!needs_locking) {
-	
+
 		const Entry *e=get_entry(p_mem);
 		ERR_FAIL_COND_V(!e,NULL);
 		return &pool[e->pos];
-	
+
 	}
-	
+
 	mt_lock();
 	const Entry *e=get_entry(p_mem);
-	
+
 	if (!e) {
-	
+
 		mt_unlock();
 		ERR_FAIL_COND_V(!e,NULL);
 	}
 	if (e->lock==0) {
-	
+
 		mt_unlock();
 		ERR_PRINT( "e->lock == 0" );
 		return NULL;
 	}
-	
+
 	if (e->pos<0 || (int)e->pos>=pool_size) {
-		
+
 		mt_unlock();
 		ERR_PRINT("e->pos<0 || e->pos>=pool_size");
 		return NULL;
 	}
 	const void *ptr=&pool[e->pos];
-	
+
 	mt_unlock();
-	
+
 	return ptr;
 
 }
 
 void *PoolAllocator::get(ID p_mem) {
-	
+
 	if (!needs_locking) {
-	
+
 		Entry *e=get_entry(p_mem);
 		if (!e) {
 			ERR_FAIL_COND_V(!e,NULL);
 		};
 		return &pool[e->pos];
-	
+
 	}
-	
+
 	mt_lock();
 	Entry *e=get_entry(p_mem);
-	
+
 	if (!e) {
-	
+
 		mt_unlock();
 		ERR_FAIL_COND_V(!e,NULL);
 	}
 	if (e->lock==0) {
-	
+
 		//assert(0);
 		mt_unlock();
 		ERR_PRINT( "e->lock == 0" );
 		return NULL;
 	}
-	
+
 	if (e->pos<0 || (int)e->pos>=pool_size) {
-		
+
 		mt_unlock();
 		ERR_PRINT("e->pos<0 || e->pos>=pool_size");
 		return NULL;
 	}
 	void *ptr=&pool[e->pos];
-	
+
 	mt_unlock();
-	
+
 	return ptr;
-	
+
 }
 void PoolAllocator::unlock(ID p_mem) {
-	
+
 	if (!needs_locking)
 		return;
 	mt_lock();
@@ -568,7 +568,7 @@ void PoolAllocator::unlock(ID p_mem) {
 		ERR_PRINT( "e->lock == 0" );
 		return;
 	}
-	e->lock--;		
+	e->lock--;
 	mt_unlock();
 }
 
@@ -583,34 +583,34 @@ int PoolAllocator::get_free_peak() {
 }
 
 int PoolAllocator::get_free_mem() {
-	
+
 	return free_mem;
 }
 
 void PoolAllocator::create_pool(void * p_mem,int p_size,int p_max_entries) {
-	
+
 	pool=(uint8_t*)p_mem;
 	pool_size=p_size;
-		
+
 	entry_array = memnew_arr( Entry, p_max_entries );
 	entry_indices = memnew_arr( int, p_max_entries );
 	entry_max = p_max_entries;
 	entry_count=0;
-	
+
 	free_mem=p_size;
 	free_mem_peak=p_size;
-	
-	check_count=0;	
+
+	check_count=0;
 }
 
 PoolAllocator::PoolAllocator(int p_size,bool p_needs_locking,int p_max_entries) {
-	
+
 	mem_ptr=Memory::alloc_static( p_size,"PoolAllocator()");
 	ERR_FAIL_COND(!mem_ptr);
 	align=1;
 	create_pool(mem_ptr,p_size,p_max_entries);
 	needs_locking=p_needs_locking;
-	
+
 }
 
 PoolAllocator::PoolAllocator(void * p_mem,int p_size, int p_align ,bool p_needs_locking,int p_max_entries) {
@@ -626,16 +626,16 @@ PoolAllocator::PoolAllocator(void * p_mem,int p_size, int p_align ,bool p_needs_
 			p_mem = (void*)mem8;
 		};
 	};
-	
+
 	create_pool( p_mem,p_size,p_max_entries);
 	needs_locking=p_needs_locking;
 	align=p_align;
-	mem_ptr=NULL;	
+	mem_ptr=NULL;
 }
 
 PoolAllocator::PoolAllocator(int p_align,int p_size,bool p_needs_locking,int p_max_entries) {
-	
-	ERR_FAIL_COND(p_align<1);	
+
+	ERR_FAIL_COND(p_align<1);
 	mem_ptr=Memory::alloc_static( p_size+p_align,"PoolAllocator()");
 	uint8_t *mem8=(uint8_t*)mem_ptr;
 	uint64_t ofs = (uint64_t)mem8;
@@ -647,12 +647,12 @@ PoolAllocator::PoolAllocator(int p_align,int p_size,bool p_needs_locking,int p_m
 }
 
 PoolAllocator::~PoolAllocator() {
-	
+
 	if (mem_ptr)
 		Memory::free_static( mem_ptr );
-	
+
 	memdelete_arr( entry_array );
 	memdelete_arr( entry_indices );
-	
+
 }
 
diff --git a/core/pool_allocator.h b/core/pool_allocator.h
index 2c5920149b..438548bfe4 100644
--- a/core/pool_allocator.h
+++ b/core/pool_allocator.h
@@ -41,66 +41,66 @@
 */
 
 enum {
-	
+
 	POOL_ALLOCATOR_INVALID_ID=-1 ///< default invalid value. use INVALID_ID( id ) to test
 };
 
 class PoolAllocator {
-public:	
+public:
 	typedef int ID;
-private:	
+private:
 	enum {
 		CHECK_BITS=8,
   		CHECK_LEN=(1<<CHECK_BITS),
 		CHECK_MASK=CHECK_LEN-1
-	
+
 	};
-	
-	
+
+
 	struct Entry {
-		
+
 		unsigned int pos;
 		unsigned int len;
 		unsigned int lock;
-		unsigned int check;		
-		
+		unsigned int check;
+
 		inline void clear() { pos=0; len=0; lock=0; check=0; }
 		Entry() { clear(); }
 	};
-	
-	
+
+
 	typedef int EntryArrayPos;
 	typedef int EntryIndicesPos;
-	
+
 	Entry *entry_array;
 	int *entry_indices;
 	int entry_max;
 	int entry_count;
-	
+
 	uint8_t *pool;
 	void *mem_ptr;
 	int pool_size;
-	
+
 	int free_mem;
 	int free_mem_peak;
 
 	unsigned int check_count;
 	int align;
-	
+
 	bool needs_locking;
-	
-	inline int entry_end(const Entry& p_entry) const { 
-		return p_entry.pos+aligned(p_entry.len); 
+
+	inline int entry_end(const Entry& p_entry) const {
+		return p_entry.pos+aligned(p_entry.len);
 	}
 	inline int aligned(int p_size) const {
-			
+
 		int rem=p_size%align;
 		if (rem)
 			p_size+=align-rem;
-			
+
 		return p_size;
 	}
-	
+
 	void compact(int p_up_to=-1);
 	void compact_up(int p_from=0);
 	bool get_free_entry(EntryArrayPos* p_pos);
@@ -108,14 +108,14 @@ private:
 	bool find_entry_index(EntryIndicesPos *p_map_pos,Entry *p_entry);
 	Entry* get_entry(ID p_mem);
 	const Entry* get_entry(ID p_mem) const;
-	
+
 	void create_pool(void * p_mem,int p_size,int p_max_entries);
-protected:	
+protected:
 	virtual void mt_lock() const; ///< Reimplement for custom mt locking
 	virtual void mt_unlock() const; ///< Reimplement for custom mt locking
-	
+
 public:
-	
+
 	enum {
 		DEFAULT_MAX_ALLOCS=4096,
 	};
@@ -124,7 +124,7 @@ public:
 	void free(ID p_mem); ///< Free allocated memory
 	Error resize(ID p_mem,int p_new_size); ///< resize a memory chunk
 	int get_size(ID p_mem) const;
-	
+
 	int get_free_mem(); ///< get free memory
 	int get_used_mem() const;
 	int get_free_peak(); ///< get free memory
@@ -134,13 +134,13 @@ public:
 	const void *get(ID p_mem) const;
 	void unlock(ID p_mem);
 	bool is_locked(ID p_mem) const;
-		
+
 	PoolAllocator(int p_size,bool p_needs_locking=false,int p_max_entries=DEFAULT_MAX_ALLOCS);
 	PoolAllocator(void * p_mem,int p_size, int p_align = 1, bool p_needs_locking=false,int p_max_entries=DEFAULT_MAX_ALLOCS);
 	PoolAllocator(int p_align,int p_size,bool p_needs_locking=false,int p_max_entries=DEFAULT_MAX_ALLOCS);
-		
+
 	virtual ~PoolAllocator();
-	
+
 };
 
 #endif
diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp
index 54431cf381..97bd5f2a32 100644
--- a/core/register_core_types.cpp
+++ b/core/register_core_types.cpp
@@ -81,7 +81,7 @@ extern void unregister_variant_methods();
 
 void register_core_types() {
 
-	
+
 	_global_mutex=Mutex::create();
 
 
@@ -92,7 +92,7 @@ void register_core_types() {
 
 
 	CoreStringNames::create();
-	
+
 	resource_format_po = memnew( TranslationLoaderPO );
 	ResourceLoader::add_resource_format_loader( resource_format_po );
 
diff --git a/core/res_ptr.cpp b/core/res_ptr.cpp
index 11312b8021..2fada627e7 100644
--- a/core/res_ptr.cpp
+++ b/core/res_ptr.cpp
@@ -53,7 +53,7 @@ RefPtr::RefPtr(const RefPtr& p_other) {
 
 	Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
 	Ref<Resource> *ref_other = reinterpret_cast<Ref<Resource>*>( const_cast<char*>(&p_other.data[0]) );
-	
+
 	*ref = *ref_other;
 }
 
diff --git a/core/res_ptr.h b/core/res_ptr.h
index e1dc66b290..54b74bb113 100644
--- a/core/res_ptr.h
+++ b/core/res_ptr.h
@@ -41,7 +41,7 @@
 class ResBase;
 
 class RefPtr {
-friend class ResBase;	
+friend class ResBase;
 	enum {
 
 		DATASIZE=sizeof(void*)*4
diff --git a/core/resource.cpp b/core/resource.cpp
index e0706cf541..672e64b1bb 100644
--- a/core/resource.cpp
+++ b/core/resource.cpp
@@ -156,14 +156,14 @@ void Resource::_resource_path_changed() {
 
 
 }
-	
+
 void Resource::set_path(const String& p_path, bool p_take_over) {
 
 	if (path_cache==p_path)
 		return;
-		
+
 	if (path_cache!="") {
-		
+
 		ResourceCache::resources.erase(path_cache);
 	}
 
@@ -179,19 +179,19 @@ void Resource::set_path(const String& p_path, bool p_take_over) {
 
 	}
 	path_cache=p_path;
-	
+
 	if (path_cache!="") {
-		
+
 		ResourceCache::resources[path_cache]=this;;
 	}
 
 	_change_notify("resource/path");
 	_resource_path_changed();
-	
+
 }
 
 String Resource::get_path() const {
-	
+
 	return path_cache;
 }
 
@@ -342,7 +342,7 @@ Resource::Resource() {
 
 
 Resource::~Resource() {
-	
+
 	if (path_cache!="")
 		ResourceCache::resources.erase(path_cache);
 	if (owners.size()) {
@@ -350,12 +350,12 @@ Resource::~Resource() {
 	}
 }
 
-HashMap<String,Resource*> ResourceCache::resources;	
+HashMap<String,Resource*> ResourceCache::resources;
 
 void ResourceCache::clear() {
 	if (resources.size())
 		ERR_PRINT("Resources Still in use at Exit!");
-		
+
 	resources.clear();
 }
 
@@ -374,18 +374,18 @@ void ResourceCache::reload_externals() {
 bool ResourceCache::has(const String& p_path) {
 
 	GLOBAL_LOCK_FUNCTION
-	
+
 	return resources.has(p_path);
 }
 Resource *ResourceCache::get(const String& p_path) {
-	
+
 	GLOBAL_LOCK_FUNCTION
-	
+
 	Resource **res = resources.getptr(p_path);
 	if (!res) {
 		return NULL;
 	}
-		
+
 	return *res;
 }
 
diff --git a/core/resource.h b/core/resource.h
index f0c86631cc..8bcdd6b4b7 100644
--- a/core/resource.h
+++ b/core/resource.h
@@ -87,7 +87,7 @@ public:
 
 
 class Resource : public Reference {
-	
+
 	OBJ_TYPE( Resource, Reference );
 	OBJ_CATEGORY("Resources");
 	RES_BASE_EXTENSION("res");
@@ -95,8 +95,8 @@ class Resource : public Reference {
 	Set<ObjectID> owners;
 
 friend class ResBase;
-friend class ResourceCache;	
-	
+friend class ResourceCache;
+
 	String name;
 	String path_cache;
 	int subindex;
@@ -109,7 +109,7 @@ friend class ResourceCache;
 #endif
 
 protected:
-	
+
 	void emit_changed();
 
 	void notify_change_to_owners();
@@ -120,7 +120,7 @@ protected:
 	void _set_path(const String& p_path);
 	void _take_over_path(const String& p_path);
 public:
-	
+
 	virtual bool can_reload_from_file();
 	virtual void reload_from_file();
 
@@ -151,7 +151,7 @@ public:
 
 	virtual RID get_rid() const; // some resources may offer conversion to RID
 
-	Resource();	
+	Resource();
 	~Resource();
 
 };
@@ -160,11 +160,11 @@ public:
 typedef Ref<Resource> RES;
 
 class ResourceCache {
-friend class Resource;	
-	static HashMap<String,Resource*> resources;	
+friend class Resource;
+	static HashMap<String,Resource*> resources;
 friend void unregister_core_types();
 	static void clear();
-public:	
+public:
 
 	static void reload_externals();
 	static bool has(const String& p_path);
diff --git a/core/rid.h b/core/rid.h
index 85ae1b15d3..2de6956096 100644
--- a/core/rid.h
+++ b/core/rid.h
@@ -44,19 +44,19 @@ class RID_OwnerBase;
 
 typedef uint32_t ID;
 
-class RID {	
-friend class RID_OwnerBase;	
+class RID {
+friend class RID_OwnerBase;
 	ID _id;
 	RID_OwnerBase *owner;
 public:
 
 	_FORCE_INLINE_ ID get_id() const { return _id; }
 	bool operator==(const RID& p_rid) const {
-	
+
 		return _id==p_rid._id;
 	}
 	_FORCE_INLINE_ bool operator<(const RID& p_rid) const {
-	
+
 		return _id < p_rid._id;
 	}
 	_FORCE_INLINE_ bool operator<=(const RID& p_rid) const {
@@ -64,11 +64,11 @@ public:
 		return _id <= p_rid._id;
 	}
 	_FORCE_INLINE_ bool operator>(const RID& p_rid) const {
-	
+
 		return _id > p_rid._id;
 	}
 	bool operator!=(const RID& p_rid) const {
-	
+
 		return _id!=p_rid._id;
 	}
 	_FORCE_INLINE_ bool is_valid() const { return _id>0; }
@@ -91,7 +91,7 @@ friend class RID;
 	void set_ownage(RID& p_rid) const { p_rid.owner=const_cast<RID_OwnerBase*>(this); }
 	ID new_ID();
 public:
-		
+
 	virtual bool owns(const RID& p_rid) const=0;
 	virtual void get_owned_list(List<RID> *p_owned) const=0;
 
@@ -105,67 +105,67 @@ class RID_Owner : public RID_OwnerBase {
 public:
 
 	typedef void (*ReleaseNotifyFunc)(void*user,T *p_data);
-private:	
+private:
 
 	Mutex *mutex;
 	mutable HashMap<ID,T*> id_map;
-		
+
 public:
 
 	RID make_rid(T * p_data) {
-		
+
 		if (thread_safe) {
 			mutex->lock();
 		}
-		
+
 		ID id = new_ID();
 		id_map[id]=p_data;
 		RID rid;
 		set_id(rid,id);
 		set_ownage(rid);
-		
+
 		if (thread_safe) {
 			mutex->unlock();
 		}
-		
+
 		return rid;
 	}
-	
+
 	_FORCE_INLINE_ T * get(const RID& p_rid) {
-	
+
 		if (thread_safe) {
 			mutex->lock();
 		}
-	
+
 		T**elem = id_map.getptr(p_rid.get_id());
-		
+
 		if (thread_safe) {
 			mutex->unlock();
 		}
 
 		ERR_FAIL_COND_V(!elem,NULL);
-		
+
 		return *elem;
 
 	}
-	
+
 	virtual bool owns(const RID& p_rid) const {
-	
+
 		if (thread_safe) {
 			mutex->lock();
 		}
-	
+
 		T**elem = id_map.getptr(p_rid.get_id());
-		
+
 		if (thread_safe) {
 			mutex->lock();
 		}
-		
+
 		return elem!=NULL;
 	}
-	
-	virtual void free(RID p_rid) { 
-	
+
+	virtual void free(RID p_rid) {
+
 		if (thread_safe) {
 			mutex->lock();
 		}
@@ -173,40 +173,40 @@ public:
 		id_map.erase(p_rid.get_id());
 	}
 	virtual void get_owned_list(List<RID> *p_owned) const {
-	
+
 		if (thread_safe) {
 			mutex->lock();
 		}
-	
+
 		const ID*id=NULL;
 		while((id=id_map.next(id))) {
-		
+
 			RID rid;
 			set_id(rid,*id);
 			set_ownage(rid);
 			p_owned->push_back(rid);
-		
+
 		}
-	
+
 		if (thread_safe) {
 			mutex->lock();
 		}
 
 	}
 	RID_Owner() {
-	
+
 		if (thread_safe) {
-		
+
 			mutex = Mutex::create();
 		}
-		
+
 	}
-	
-	
+
+
 	~RID_Owner() {
-	
+
 		if (thread_safe) {
-		
+
 			memdelete(mutex);
 		}
 	}
diff --git a/core/ring_buffer.h b/core/ring_buffer.h
index 4658ec5e51..7d78fac660 100644
--- a/core/ring_buffer.h
+++ b/core/ring_buffer.h
@@ -38,21 +38,21 @@ class RingBuffer {
 	int read_pos;
 	int write_pos;
 	int size_mask;
-	
+
 	inline int inc(int& p_var, int p_size) {
 		int ret = p_var;
 		p_var += p_size;
 		p_var = p_var&size_mask;
 		return ret;
 	};
-	
+
 public:
 
 	T read() {
 		ERR_FAIL_COND_V(space_left() < 1, T());
 		return data[inc(read_pos, 1)];
 	};
-	
+
 	int read(T* p_buf, int p_size, bool p_advance=true) {
 		int left = data_left();
 		p_size = MIN(left, p_size);
@@ -76,7 +76,7 @@ public:
 	};
 
 	int copy(T* p_buf, int p_offset, int p_size) {
-		
+
 		int left = data_left();
 		if ((p_offset+p_size)>left) {
 			p_size-=left-p_offset;
@@ -106,18 +106,18 @@ public:
 		inc(read_pos, p_n);
 		return p_n;
 	};
-	
+
 	Error write(const T& p_v) {
 		ERR_FAIL_COND_V( space_left() < 1, FAILED);
 		data[inc(write_pos, 1)] = p_v;
 		return OK;
 	};
-	
+
 	int write(const T* p_buf, int p_size) {
-		
+
 		int left = space_left();
 		p_size = MIN(left, p_size);
-		
+
 		int pos = write_pos;
 		int to_write = p_size;
 		int src = 0;
@@ -126,7 +126,7 @@ public:
 			int end = pos + to_write;
 			end = MIN(end, size());
 			int total = end - pos;
-			
+
 			for (int i=0; i<total; i++) {
 				data[pos+i] = p_buf[src++];
 			};
@@ -137,7 +137,7 @@ public:
 		inc(write_pos, p_size);
 		return p_size;
 	};
-	
+
 	inline int space_left() {
 		int left = read_pos - write_pos;
 		if (left < 0) {
@@ -151,7 +151,7 @@ public:
 	inline int data_left() {
 		return size() - space_left() - 1;
 	};
-	
+
 	inline int size() {
 		return data.size();
 	};
@@ -161,7 +161,7 @@ public:
 		write_pos = 0;
 
 	}
-	
+
 	void resize(int p_power) {
 		int old_size = size();
 		int new_size = 1<<p_power;
@@ -176,10 +176,10 @@ public:
 			read_pos = read_pos & mask;
 			write_pos = write_pos & mask;
 		};
-		
+
 		size_mask = mask;
 	};
-	
+
 	RingBuffer<T>(int p_power=0) {
 		read_pos = 0;
 		write_pos = 0;
diff --git a/core/safe_refcount.cpp b/core/safe_refcount.cpp
index 7718e466f2..9736f96f34 100644
--- a/core/safe_refcount.cpp
+++ b/core/safe_refcount.cpp
@@ -40,9 +40,9 @@ long atomic_conditional_increment( register long * pw ) {
 
 	while (true) {
 		long tmp = static_cast< long const volatile& >( *pw );
-		if( tmp == 0 ) 
+		if( tmp == 0 )
       return 0; // if zero, can't add to it anymore
-		if( InterlockedCompareExchange( pw, tmp + 1, tmp ) == tmp ) 
+		if( InterlockedCompareExchange( pw, tmp + 1, tmp ) == tmp )
 			return tmp+1;
 	}
 
diff --git a/core/safe_refcount.h b/core/safe_refcount.h
index e5dc854c23..d976458c1d 100644
--- a/core/safe_refcount.h
+++ b/core/safe_refcount.h
@@ -42,15 +42,15 @@ struct SafeRefCount {
 	int count;
 
 public:
-	
+
 	// destroy() is called when weak_count_ drops to zero.
-	
+
 	bool ref() {  //true on success
-	
+
 		if (count==0)
 			return false;
 		count++;
-		
+
 		return true;
 	}
 
@@ -66,17 +66,17 @@ public:
 
 		if (count>0)
 			count--;
-				
+
 		return count==0;
 	}
-	
+
 	long get() const { // nothrow
-		
+
 		return static_cast<int const volatile &>( count );
 	}
-	
+
 	void init(int p_value=1) {
-	
+
 		count=p_value;
 	};
 
@@ -105,9 +105,9 @@ static inline int atomic_conditional_increment( volatile int * pw ) {
 	// int rv = *pw;
 	// if( rv != 0 ) ++*pw;
 	// return rv;
-	
+
 	int rv, tmp;
-	
+
 	__asm__
 	(
 		"movl %0, %%eax\n\t"
@@ -124,22 +124,22 @@ static inline int atomic_conditional_increment( volatile int * pw ) {
 		"m"( *pw ): // input (%3)
 		"cc" // clobbers
 	);
-	
+
 	return rv;
 }
 
 static inline int atomic_decrement( volatile int *pw) {
-	
+
 	// return --(*pw);
-		
+
 	unsigned char rv;
-	
+
 	__asm__
 	(
 		"lock\n\t"
 		"decl %0\n\t"
-		"setne %1": 
-		"=m" (*pw), "=qm" (rv): 
+		"setne %1":
+		"=m" (*pw), "=qm" (rv):
 		"m" (*pw):
 		"memory"
 	);
@@ -266,15 +266,15 @@ inline long atomic_conditional_increment( register long * pw )
 	asm
 	{
 	loop:
-	
+
 	lwarx   a, 0, pw
 	cmpwi   a, 0
 	beq     store
-	
+
 	addi    a, a, 1
-	
+
 	store:
-	
+
 	stwcx.  a, 0, pw
 	bne-    loop
     }
@@ -288,16 +288,16 @@ inline long atomic_decrement( register long * pw )
     register int a;
 
     asm {
-    
+
 	sync
-	
+
 	loop:
-	
+
 	lwarx   a, 0, pw
 	addi    a, a, -1
 	stwcx.  a, 0, pw
 	bne-    loop
-	
+
 	isync
     }
 
@@ -338,11 +338,11 @@ struct SafeRefCount {
   REFCOUNT_T count;
 
 public:
-	
+
 	// destroy() is called when weak_count_ drops to zero.
-	
+
 	bool ref() {  //true on success
-	
+
 		return atomic_conditional_increment( &count ) != 0;
 	}
 
@@ -356,17 +356,17 @@ public:
 		if( atomic_decrement ( &count ) == 0 ) {
 			return true;
 		}
-		
+
 		return false;
 	}
-	
+
 	long get() const { // nothrow
-		
+
 		return static_cast<REFCOUNT_GET_T>( count );
 	}
-	
+
 	void init(int p_value=1) {
-	
+
 		count=p_value;
 	};
 
@@ -376,4 +376,4 @@ public:
 
 #endif // no thread safe
 
-#endif 
+#endif
diff --git a/core/script_language.cpp b/core/script_language.cpp
index 0eac39e7d1..1503418269 100644
--- a/core/script_language.cpp
+++ b/core/script_language.cpp
@@ -61,26 +61,26 @@ void ScriptServer::set_scripting_enabled(bool p_enabled) {
 }
 
 bool ScriptServer::is_scripting_enabled() {
-	
+
 	return scripting_enabled;
 }
 
 
 int ScriptServer::get_language_count() {
-	
+
 	return _language_count;
-	
+
 }
 
 ScriptLanguage* ScriptServer::get_language(int p_idx) {
 
 	ERR_FAIL_INDEX_V(p_idx,_language_count,NULL);
-	
+
 	return _languages[p_idx];
 }
 
 void ScriptServer::register_language(ScriptLanguage *p_language) {
-	
+
 	ERR_FAIL_COND( _language_count >= MAX_LANGUAGES );
 	_languages[_language_count++]=p_language;
 }
diff --git a/core/script_language.h b/core/script_language.h
index 7e278b8555..1be1aabdab 100644
--- a/core/script_language.h
+++ b/core/script_language.h
@@ -40,15 +40,15 @@ class ScriptLanguage;
 
 class ScriptServer {
 	enum {
-		
+
 		MAX_LANGUAGES=4
 	};
-	
+
 	static ScriptLanguage *_languages[MAX_LANGUAGES];
 	static int _language_count;
 	static bool scripting_enabled;
-public:	
-	
+public:
+
 	static void set_scripting_enabled(bool p_enabled);
 	static bool is_scripting_enabled();
 	static int get_language_count();
@@ -76,14 +76,14 @@ protected:
 friend class PlaceHolderScriptInstance;
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {}
 public:
-	
+
 	virtual bool can_instance() const=0;
 
 	virtual StringName get_instance_base_type() const=0; // this may not work in all scripts, will return empty if so
 	virtual ScriptInstance* instance_create(Object *p_this)=0;
 	virtual bool instance_has(const Object *p_this) const=0;
 
-	
+
 	virtual bool has_source_code() const=0;
 	virtual String get_source_code() const=0;
 	virtual void set_source_code(const String& p_code)=0;
@@ -102,7 +102,7 @@ public:
 
 	virtual void update_exports() {} //editor tool
 
-	
+
 	Script() {}
 };
 
@@ -148,13 +148,13 @@ class ScriptLanguage {
 public:
 
 	virtual String get_name() const=0;
-	
+
 	/* LANGUAGE FUNCTIONS */
-	virtual void init()=0;	
+	virtual void init()=0;
 	virtual String get_type() const=0;
 	virtual String get_extension() const=0;
-	virtual Error execute_file(const String& p_path) =0;	
-	virtual void finish()=0;	
+	virtual Error execute_file(const String& p_path) =0;
+	virtual void finish()=0;
 
 	/* EDITOR FUNCTIONS */
 	virtual void get_reserved_words(List<String> *p_words) const=0;
@@ -197,7 +197,7 @@ public:
 
 	virtual void frame();
 
-	virtual ~ScriptLanguage() {};	
+	virtual ~ScriptLanguage() {};
 };
 
 extern uint8_t script_encryption_key[32];
diff --git a/core/set.h b/core/set.h
index 808ffe5b36..d4d19129d4 100644
--- a/core/set.h
+++ b/core/set.h
@@ -42,16 +42,16 @@
 
 template <class T,class C=Comparator<T>,class A=DefaultAllocator >
 class Set {
-	
-	enum Color {	
+
+	enum Color {
 		RED,
 		BLACK
 	};
-	struct _Data;	
+	struct _Data;
 public:
 
-	
-		
+
+
 	class Element {
 
 	private:
@@ -72,18 +72,18 @@ public:
 			return _next;
 		}
 		Element *next() {
-			
+
 			return _next;
 		}
 		const Element *prev() const {
-			
+
 			return _prev;
 		}
 		Element *prev() {
-			
+
 			return _prev;
 		}
-		const T& get() const { 
+		const T& get() const {
 			return value;
 		};
 		Element() {
@@ -96,7 +96,7 @@ public:
 		};
 	};
 
-	
+
 private:
 
 	struct _Data {
@@ -104,7 +104,7 @@ private:
 		Element* _root;
 		Element* _nil;
 		int size_cache;
-		
+
 
 		_Data() {
 #ifdef GLOBALNIL_DISABLED
@@ -119,7 +119,7 @@ private:
 
 			size_cache=0;
 		}
-		
+
 		void _create_root() {
 
 			_root = memnew_allocator( Element,A );
@@ -136,7 +136,7 @@ private:
 		}
 
 		~_Data() {
-			
+
 			_free_root();
 #ifdef GLOBALNIL_DISABLED
 			memdelete_allocator<Element,A>(_nil);
@@ -144,16 +144,16 @@ private:
 //			memdelete_allocator<Element,A>(_root);
 		}
 	};
-	
+
 	_Data _data;
-	
+
 	inline void _set_color(Element *p_node, int p_color) {
-		
+
 		ERR_FAIL_COND( p_node == _data._nil && p_color == RED );
 		p_node->color=p_color;
 	}
 	inline void _rotate_left(Element *p_node) {
-	
+
 		Element *r=p_node->right;
 		p_node->right=r->left;
 		if (r->left != _data._nil )
@@ -163,14 +163,14 @@ private:
 			p_node->parent->left=r;
 		else
 			p_node->parent->right=r;
-			
+
 		r->left=p_node;
 		p_node->parent=r;
-		
+
 	}
-	
+
 	inline void _rotate_right(Element *p_node) {
-	
+
 		Element *l=p_node->left;
 		p_node->left=l->right;
 		if (l->right != _data._nil)
@@ -180,25 +180,25 @@ private:
 			p_node->parent->right=l;
 		else
 			p_node->parent->left=l;
-			
+
 		l->right=p_node;
 		p_node->parent=l;
-		
+
 	}
-	
-	inline Element* _successor(Element *p_node) const { 
-		
+
+	inline Element* _successor(Element *p_node) const {
+
 		Element *node=p_node;
-				
+
 		if (node->right != _data._nil) {
-			
+
 			node=node->right;
 			while(node->left != _data._nil) { /* returns the minium of the right subtree of node */
 				node=node->left;
 			}
 			return node;
 		} else {
-			
+
 			while(node == node->parent->right) {
 				node=node->parent;
 			}
@@ -207,19 +207,19 @@ private:
 			return node->parent;
 		}
 	}
-	
-	inline Element* _predecessor(Element *p_node) const { 
+
+	inline Element* _predecessor(Element *p_node) const {
 		Element *node=p_node;
-		
+
 		if (node->left != _data._nil) {
-			
+
 			node=node->left;
 			while(node->right != _data._nil) { /* returns the minium of the left subtree of node */
 				node=node->right;
 			}
 			return node;
 		} else {
-			
+
 			while(node == node->parent->left) {
 				if (node->parent == _data._root)
 					return NULL;
@@ -229,23 +229,23 @@ private:
 			return node->parent;
 		}
 	}
-	
-	
+
+
 	Element *_find(const T& p_value) const {
-	
+
 		Element *node = _data._root->left;
-		C less;			
-				
+		C less;
+
 		while(node!=_data._nil) {
-				
-			if (less(p_value,node->value)) 
+
+			if (less(p_value,node->value))
 				node=node->left;
 			else if (less(node->value,p_value))
 				node=node->right;
 			else
 				break; // found
 		}
-		
+
 		return (node!=_data._nil)?node:NULL;
 	}
 
@@ -282,68 +282,68 @@ private:
 
 
 	Element *_insert(const T& p_value, bool& r_exists) {
-		
+
 		Element *new_parent=_data._root;
 		Element *node = _data._root->left;
-		C less;			
-		
+		C less;
+
 		while (node!=_data._nil) {
-			
+
 			new_parent=node;
-			
+
 			if (less(p_value,node->value))
 				node=node->left;
 			else if (less(node->value,p_value))
 				node=node->right;
-			else {				
+			else {
 				r_exists=true;
 				return node;
-			}						
+			}
 		}
-		
+
 		Element *new_node = memnew_allocator( Element,A );
-		
+
 		new_node->parent=new_parent;
 		new_node->right=_data._nil;
 		new_node->left=_data._nil;
 		new_node->value=p_value;
 //		new_node->data=_data;
 		if (new_parent==_data._root || less(p_value,new_parent->value)) {
-			
+
 			new_parent->left=new_node;
 		} else {
 			new_parent->right=new_node;
 		}
-		
+
 		r_exists=false;
-		
+
 		new_node->_next=_successor(new_node);
 		new_node->_prev=_predecessor(new_node);
 		if (new_node->_next)
 			new_node->_next->_prev=new_node;
 		if (new_node->_prev)
 			new_node->_prev->_next=new_node;
-		
+
 
 		return new_node;
 	}
-	
+
 	Element * _insert_rb(const T& p_value) {
-		
+
 		bool exists=false;
 		Element *new_node = _insert(p_value,exists);
 		if (exists)
 			return new_node;
-				                
+
 		Element *node=new_node;
 		_data.size_cache++;
 
-		while(node->parent->color==RED) { 
-			
+		while(node->parent->color==RED) {
+
 			if (node->parent == node->parent->parent->left) {
-				
+
 				Element *aux=node->parent->parent->right;
-				
+
 				if (aux->color==RED) {
 					_set_color(node->parent,BLACK);
 					_set_color(aux,BLACK);
@@ -357,10 +357,10 @@ private:
 					_set_color(node->parent,BLACK);
 					_set_color(node->parent->parent,RED);
 					_rotate_right(node->parent->parent);
-				} 
-			} else { 
+				}
+			} else {
 				Element *aux=node->parent->parent->left;
-				
+
 				if (aux->color==RED) {
 					_set_color(node->parent,BLACK);
 					_set_color(aux,BLACK);
@@ -374,19 +374,19 @@ private:
 					_set_color(node->parent,BLACK);
 					_set_color(node->parent->parent,RED);
 					_rotate_left(node->parent->parent);
-				} 
+				}
 			}
 		}
 		_set_color(_data._root->left,BLACK);
-		return new_node;		
-	}	
+		return new_node;
+	}
 
 	void _erase_fix(Element *p_node) {
-		
+
 		Element *root = _data._root->left;
 		Element *node=p_node;
-		
-		
+
+
 		while( (node->color==BLACK) && (root != node)) {
 			if (node == node->parent->left) {
 				Element *aux=node->parent->right;
@@ -396,7 +396,7 @@ private:
 					_rotate_left(node->parent);
 					aux=node->parent->right;
 				}
-				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) { 
+				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) {
 					_set_color(aux,RED);
 					node=node->parent;
 				} else {
@@ -420,7 +420,7 @@ private:
 					_rotate_right(node->parent);
 					aux=node->parent->left;
 				}
-				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) { 
+				if ( (aux->right->color==BLACK) && (aux->left->color==BLACK) ) {
 					_set_color(aux,RED);
 					node=node->parent;
 				} else {
@@ -434,24 +434,24 @@ private:
 					_set_color(node->parent,BLACK);
 					_set_color(aux->left,BLACK);
 					_rotate_right(node->parent);
-					node=root; 
+					node=root;
 				}
 			}
 		}
-		
+
 		_set_color(node,BLACK);
-		
+
 		ERR_FAIL_COND(_data._nil->color!=BLACK);
 	}
-	
+
 	void _erase(Element *p_node) {
-		
-		
+
+
 		Element *rp= ((p_node->left == _data._nil) || (p_node->right == _data._nil)) ? p_node : _successor(p_node);
 		if (!rp)
 			rp=_data._nil;
 		Element *node= (rp->left == _data._nil) ? rp->right : rp->left;
-				
+
 		if (_data._root == (node->parent=rp->parent) ) {
 			_data._root->left=node;
 		} else {
@@ -461,47 +461,47 @@ private:
 				rp->parent->right=node;
 			}
 		}
-		
-		if (rp != p_node) { 
-			
+
+		if (rp != p_node) {
+
 			ERR_FAIL_COND( rp == _data._nil );
-			
+
 			if (rp->color==BLACK)
 				_erase_fix(node);
-			
-			
+
+
 			rp->left=p_node->left;
 			rp->right=p_node->right;
 			rp->parent=p_node->parent;
 			rp->color=p_node->color;
 			p_node->left->parent=rp;
 			p_node->right->parent=rp;
-			
+
 			if (p_node == p_node->parent->left) {
-				p_node->parent->left=rp; 
+				p_node->parent->left=rp;
 			} else {
 				p_node->parent->right=rp;
 			}
 		} else {
-			if (p_node->color==BLACK) 
+			if (p_node->color==BLACK)
 				_erase_fix(node);
-		
+
 		}
-		
-		
+
+
 		if (p_node->_next)
 			p_node->_next->_prev=p_node->_prev;
 		if (p_node->_prev)
 			p_node->_prev->_next=p_node->_next;
-		
+
 		memdelete_allocator<Element,A>(p_node);
 		_data.size_cache--;
 		ERR_FAIL_COND( _data._nil->color==RED );
 	}
-	
-	
+
+
 	void _calculate_depth(Element *p_element,int &max_d,int d) const {
-		
+
 		if (p_element==_data._nil) {
 			return;
 		}
@@ -510,30 +510,30 @@ private:
 		if (d>max_d)
 			max_d=d;
 	}
-	
+
 	void _cleanup_tree(Element *p_element) {
-		
+
 		if (p_element==_data._nil)
 			return;
-		
+
 		_cleanup_tree(p_element->left);
 		_cleanup_tree(p_element->right);
 		memdelete_allocator<Element,A>( p_element );
 	}
-	
+
 	void _copy_from( const Set& p_set) {
-		
+
 		clear();
 		// not the fastest way, but safeset to write.
 		for(Element *I=p_set.front();I;I=I->next()) {
-			
+
 			insert(I->get());
 		}
 	}
 public:
 
 	const Element *find(const T& p_value) const {
-	
+
 		if (!_data._root)
 			return NULL;
 
@@ -542,30 +542,30 @@ public:
 	}
 
 	Element *find(const T& p_value) {
-		
+
 		if (!_data._root)
 			return NULL;
 		Element *res=_find(p_value);
 		return res;
 	}
-	
+
 	bool has(const T& p_value) const {
-	
+
 		if (!_data._root)
 			return false;
 		return find(p_value)!=NULL;
 	}
-	
+
 	Element *insert(const T& p_value) {
-	
+
 		if (!_data._root)
 			_data._create_root();
 		return _insert_rb(p_value);
-		
+
 	}
-	
+
 	void erase(Element* p_element) {
-	
+
 		if (!_data._root)
 			return;
 		_erase(p_element);
@@ -574,7 +574,7 @@ public:
 	}
 
 	bool erase(const T& p_value) {
-		
+
 		if (!_data._root)
 			return false;
 		Element *e=find(p_value);
@@ -585,32 +585,32 @@ public:
 			_data._free_root();
 		return true;
 	}
-	
+
 	Element *front() const {
-		
+
 		if (!_data._root)
 			return NULL;
 		Element *e=_data._root->left;
 		if (e==_data._nil)
 			return NULL;
-		
+
 		while(e->left!=_data._nil)
 			e=e->left;
-		
+
 		return e;
 	}
-	
+
 	Element *back() const {
-		
+
 		if (!_data._root)
 			return NULL;
 		Element *e=_data._root->left;
 		if (e==_data._nil)
 			return NULL;
-		
+
 		while(e->right!=_data._nil)
 			e=e->right;
-		
+
 		return e;
 	}
 
@@ -619,7 +619,7 @@ public:
 		return _lower_bound(p_value);
 	}
 
-	
+
 	inline int size() const { return _data.size_cache; }
 	int calculate_depth() const {
 		// used for debug mostly
@@ -629,9 +629,9 @@ public:
 		_calculate_depth(_data._root->left,max_d,0);
 		return max_d;
 	}
-	
+
 	void clear() {
-		
+
 		if (!_data._root)
 			return;
 
@@ -641,25 +641,25 @@ public:
 		_data._nil->parent=_data._nil;
 		_data._free_root();
 	}
-	
+
 	void operator=(const Set& p_set) {
-		
+
 		_copy_from( p_set );
 	}
-	
+
 	Set(const Set& p_set) {
-		
+
 		_copy_from( p_set );
 	}
 	_FORCE_INLINE_ Set() {
-	
+
 
 	}
-		    
-		    
+
+
 	~Set() {
-		
-		clear();		
+
+		clear();
 	}
 
 };
diff --git a/core/simple_type.h b/core/simple_type.h
index 1cc597146e..1754deec71 100644
--- a/core/simple_type.h
+++ b/core/simple_type.h
@@ -33,61 +33,61 @@
 
 template<class T>
 struct GetSimpleType {
-	
+
 	T type;
 };
 
 template<class T>
 struct GetSimpleTypeT {
-	
+
 	typedef T type_t;
 };
 
 template<class T>
 struct GetSimpleType<T&> {
-	
+
 	T type;
-	
+
 };
 
 template<class T>
 struct GetSimpleTypeT<T&> {
-	
+
 	typedef T type_t;
 };
 
 template<class T>
 struct GetSimpleType<T const> {
-	
+
 	T type;
 	_FORCE_INLINE_ GetSimpleType() { }
-	
+
 };
 
 template<class T>
 struct GetSimpleTypeT<T const> {
-	
+
 	typedef T type_t;
 };
 
 template<class T>
 struct GetSimpleType<const T&> {
-	
+
 	T type;
 	_FORCE_INLINE_ GetSimpleType() { }
-	
+
 };
 
 template<class T>
 struct GetSimpleType<T*> {
-	
+
 	T *type;
 	_FORCE_INLINE_ GetSimpleType() { type=NULL; }
 };
 
 template<class T>
 struct GetSimpleType<const T*> {
-	
+
 	T *type;
 	_FORCE_INLINE_ GetSimpleType() { type=NULL; }
 };
diff --git a/core/sort.h b/core/sort.h
index bd61921c8a..2070065a0d 100644
--- a/core/sort.h
+++ b/core/sort.h
@@ -44,7 +44,7 @@ template<class T, class Comparator=_DefaultComparator<T> >
 class SortArray {
 
 	enum {
-	
+
 		INTROSORT_TRESHOLD=16
 	};
 
@@ -54,7 +54,7 @@ public:
 
 
 	inline const T& median_of_3(const T& a, const T& b, const T& c) const {
-  
+
 		if (compare(a, b))
 			if (compare(b, c))
 				return b;
@@ -69,90 +69,90 @@ public:
 		else
 			return b;
 	}
-	
-	
+
+
 
 	inline int bitlog(int n) const {
 		int k;
-		for (k = 0; n != 1; n >>= 1) 
+		for (k = 0; n != 1; n >>= 1)
 			++k;
 		return k;
 	}
-	
-	
+
+
 	/* Heap / Heapsort functions */
-	
+
 	inline void push_heap(int p_first,int p_hole_idx,int p_top_index,T p_value,T* p_array) const {
-  
+
 		int parent = (p_hole_idx - 1) / 2;
 		while (p_hole_idx > p_top_index && compare(p_array[p_first + parent], p_value)) {
-		
+
 			p_array[p_first + p_hole_idx] = p_array[p_first + parent];
 			p_hole_idx = parent;
 			parent = (p_hole_idx - 1) / 2;
 		}
-		p_array[p_first + p_hole_idx] = p_value;	
-	}  
-	
+		p_array[p_first + p_hole_idx] = p_value;
+	}
+
 	inline void pop_heap(int p_first, int p_last, int p_result, T p_value, T* p_array) const {
-	
+
 		p_array[p_result]=p_array[p_first];
 		adjust_heap(p_first,0,p_last-p_first,p_value,p_array);
 	}
 	inline void pop_heap(int p_first,int p_last,T* p_array) const {
-	
+
 	 	pop_heap(p_first,p_last-1,p_last-1,p_array[p_last-1],p_array);
 	}
-	
+
 	inline void adjust_heap(int p_first,int p_hole_idx,int p_len,T p_value,T* p_array) const {
-	
-	
+
+
 		int top_index = p_hole_idx;
 		int second_child = 2 * p_hole_idx + 2;
-		
+
 		while (second_child < p_len) {
-	
+
 			if (compare(p_array[p_first + second_child],p_array[p_first + (second_child - 1)]))
 				second_child--;
-				
+
 			p_array[p_first + p_hole_idx] = p_array[p_first + second_child];
 			p_hole_idx = second_child;
 			second_child = 2 * (second_child + 1);
 		}
-		
+
 		if (second_child == p_len) {
 			p_array[p_first + p_hole_idx] = p_array[p_first + (second_child - 1)];
 			p_hole_idx = second_child - 1;
 		}
 		push_heap(p_first, p_hole_idx, top_index, p_value,p_array);
 	}
-	
+
 	inline void sort_heap(int p_first,int p_last,T* p_array) const {
-	
+
 		while(p_last-p_first > 1) {
-		
+
 			pop_heap(p_first,p_last--,p_array);
 		}
 	}
-	
+
 	inline void make_heap(int p_first, int p_last,T* p_array) const {
-		if (p_last - p_first < 2) 
+		if (p_last - p_first < 2)
 			return;
 		int len = p_last - p_first;
 		int parent = (len - 2)/2;
-		
+
 		while (true) {
 			adjust_heap(p_first, parent, len, p_array[p_first + parent], p_array);
-			if (parent == 0) 
+			if (parent == 0)
 				return;
 			parent--;
 		}
 	}
-	
+
 	inline void partial_sort(int p_first,int p_last,int p_middle,T* p_array) const {
-	
+
 		make_heap(p_first,p_middle,p_array);
-		for(int i=p_middle;i<p_last;i++) 
+		for(int i=p_middle;i<p_last;i++)
 			if (compare( p_array[i],p_array[p_first]))
 				pop_heap(p_first,p_middle,i,p_array[i],p_array);
 		sort_heap(p_first,p_middle,p_array);
@@ -167,17 +167,17 @@ public:
 	}
 
 	inline int partitioner(int p_first, int p_last, T p_pivot, T* p_array) const {
-	
+
 		while (true) {
-			while (compare(p_array[p_first],p_pivot)) 
+			while (compare(p_array[p_first],p_pivot))
 				p_first++;
 			p_last--;
 			while (compare(p_pivot,p_array[p_last]))
 				p_last--;
-	
+
 			if (!(p_first < p_last))
 				return p_first;
-	
+
 			SWAP(p_array[p_first],p_array[p_last]);
 			p_first++;
 		}
@@ -186,28 +186,28 @@ public:
 	inline void introsort(int p_first, int p_last, T* p_array, int p_max_depth) const {
 
 		while( p_last - p_first > INTROSORT_TRESHOLD ) {
-		
+
 			if (p_max_depth == 0) {
 				partial_sort(p_first,p_last,p_last,p_array);
 				return;
 			}
-			
+
 			p_max_depth--;
-			
-			int cut = partitioner( 
-				p_first, 
-				p_last, 
-				median_of_3( 
-					p_array[p_first], 
-					p_array[p_first + (p_last-p_first)/2], 
+
+			int cut = partitioner(
+				p_first,
+				p_last,
+				median_of_3(
+					p_array[p_first],
+					p_array[p_first + (p_last-p_first)/2],
 					p_array[p_last-1]
 				),
 				p_array
 			);
-		
+
 			introsort(cut,p_last,p_array,p_max_depth);
 			p_last=cut;
-		
+
 		}
   	}
 
@@ -245,7 +245,7 @@ public:
 	}
 
 	inline void unguarded_linear_insert(int p_last,T p_value,T* p_array) const {
-	
+
 		int next = p_last-1;
 		while (compare(p_value,p_array[next])) {
 			p_array[p_last]=p_array[next];
@@ -254,48 +254,48 @@ public:
 		}
 		p_array[p_last] = p_value;
 	}
-	
+
 	inline void linear_insert(int p_first,int p_last,T*p_array) const {
-	
+
 		T val = p_array[p_last];
 		if (compare(val, p_array[p_first])) {
-		
+
 			for (int i=p_last; i>p_first; i--)
 				p_array[i]=p_array[i-1];
-				
+
 			p_array[p_first] = val;
 		} else
-			unguarded_linear_insert(p_last, val, p_array);  	
+			unguarded_linear_insert(p_last, val, p_array);
 	}
-	
+
   	inline void insertion_sort(int p_first,int p_last,T* p_array) const {
-  	
+
 		if (p_first==p_last)
 			return;
 		for (int i=p_first+1; i!=p_last ; i++)
 			linear_insert(p_first,i,p_array);
 	}
-	
+
   	inline void unguarded_insertion_sort(int p_first,int p_last,T* p_array) const {
-  	
+
 		for (int i=p_first; i!=p_last ; i++)
 			unguarded_linear_insert(i,p_array[i],p_array);
 	}
-	
+
 	inline void final_insertion_sort(int p_first,int p_last,T* p_array) const {
-	
+
 		if (p_last - p_first > INTROSORT_TRESHOLD) {
 			insertion_sort(p_first,p_first+INTROSORT_TRESHOLD,p_array);
 			unguarded_insertion_sort(p_first+INTROSORT_TRESHOLD,p_last,p_array);
 		} else {
-		
+
 			insertion_sort(p_first,p_last,p_array);
-		
-		}		
+
+		}
   	}
 
 	inline void sort_range(int p_first, int p_last,T* p_array) const {
-	
+
 		if (p_first != p_last) {
 			introsort(p_first, p_last,p_array,bitlog(p_last - p_first) * 2);
 			final_insertion_sort(p_first, p_last, p_array);
@@ -303,7 +303,7 @@ public:
 	}
 
 	inline void sort(T* p_array,int p_len) const {
-	
+
 		sort_range(0,p_len,p_array);
 	}
 
diff --git a/core/string_db.cpp b/core/string_db.cpp
index 0e953cc326..9a693f88e9 100644
--- a/core/string_db.cpp
+++ b/core/string_db.cpp
@@ -43,23 +43,23 @@ StringName _scs_create(const char *p_chr) {
 bool StringName::configured=false;
 
 void StringName::setup() {
-	
+
 	ERR_FAIL_COND(configured);
 	for(int i=0;i<STRING_TABLE_LEN;i++) {
-		
+
 		_table[i]=NULL;
 	}
 	configured=true;
 }
 
 void StringName::cleanup() {
-	
-	_global_lock();	
+
+	_global_lock();
 	int lost_strings=0;
 	for(int i=0;i<STRING_TABLE_LEN;i++) {
-		
+
 		while(_table[i]) {
-			
+
 			_Data*d=_table[i];
 			lost_strings++;
 			if (OS::get_singleton()->is_stdout_verbose()) {
@@ -71,23 +71,23 @@ void StringName::cleanup() {
 				}
 			}
 
-			_table[i]=_table[i]->next;			
+			_table[i]=_table[i]->next;
 			memdelete(d);
 		}
 	}
 	if (OS::get_singleton()->is_stdout_verbose() && lost_strings) {
 		print_line("StringName: "+itos(lost_strings)+" unclaimed string names at exit.");
 	}
-	_global_unlock();	
+	_global_unlock();
 }
 
 void StringName::unref() {
-	
+
 	ERR_FAIL_COND(!configured);
 
 	if (_data && _data->refcount.unref()) {
-		
-		_global_lock();	
+
+		_global_lock();
 
 		if (_data->prev) {
 			_data->prev->next=_data->next;
@@ -97,26 +97,26 @@ void StringName::unref() {
 			}
 			_table[_data->idx]=_data->next;
 		}
-		
+
 		if (_data->next) {
 			_data->next->prev=_data->prev;
 
 		}
 		memdelete(_data);
-		_global_unlock();		
+		_global_unlock();
 	}
-	
+
 	_data=NULL;
-	
+
 }
 
 bool StringName::operator==(const String& p_name) const {
-	
+
 	if (!_data) {
-		
+
 		return (p_name.length()==0);
 	}
-	
+
 	return (_data->get_name()==p_name);
 }
 
@@ -131,50 +131,50 @@ bool StringName::operator==(const char* p_name) const {
 }
 
 bool StringName::operator!=(const String& p_name) const {
-	
+
 	return !(operator==(p_name));
 }
 
 
 
 bool StringName::operator!=(const StringName& p_name) const {
-	
-	// the real magic of all this mess happens here. 
+
+	// the real magic of all this mess happens here.
 	// this is why path comparisons are very fast
 	return _data!=p_name._data;
-	
+
 }
 
 
 void StringName::operator=(const StringName& p_name) {
-	
+
 	if (this==&p_name)
 		return;
-	
+
 	unref();
-	
+
 	if (p_name._data && p_name._data->refcount.ref()) {
-		
-		_data = p_name._data;		
+
+		_data = p_name._data;
 	}
 }
 /* was inlined
 StringName::operator String() const {
-	
+
 	if (_data)
 		return _data->get_name();
-	
+
 	return "";
 }
 */
 StringName::StringName(const StringName& p_name) {
-	
+
 	ERR_FAIL_COND(!configured);
 	_data=NULL;
 	if (p_name._data && p_name._data->refcount.ref()) {
-		
-		_data = p_name._data;		
-	}	
+
+		_data = p_name._data;
+	}
 }
 
 StringName::StringName(const char *p_name) {
@@ -184,17 +184,17 @@ StringName::StringName(const char *p_name) {
 	ERR_FAIL_COND(!configured);
 
 	ERR_FAIL_COND( !p_name || !p_name[0]);
-	
-	_global_lock();	
-	
+
+	_global_lock();
+
 	uint32_t hash = String::hash(p_name);
-	
+
 	uint32_t idx=hash&STRING_TABLE_MASK;
-	
+
 	_data=_table[idx];
-	
+
 	while(_data) {
-		
+
 		// compare hash first
 		if (_data->hash==hash && _data->get_name()==p_name)
 			break;
@@ -226,7 +226,7 @@ StringName::StringName(const char *p_name) {
 
 
 	_global_unlock();
-	
+
 }
 
 StringName::StringName(const StaticCString& p_static_string) {
@@ -268,7 +268,7 @@ StringName::StringName(const StaticCString& p_static_string) {
 
 	_data->refcount.init();
 	_data->hash=hash;
-	_data->idx=idx;	
+	_data->idx=idx;
 	_data->cname=p_static_string.ptr;
 	_data->next=_table[idx];
 	_data->prev=NULL;
@@ -283,26 +283,26 @@ StringName::StringName(const StaticCString& p_static_string) {
 
 
 StringName::StringName(const String& p_name) {
-	
+
 	_data=NULL;
 
 	ERR_FAIL_COND(!configured);
 
-	_global_lock();	
-	
+	_global_lock();
+
 	uint32_t hash = p_name.hash();
-	
+
 	uint32_t idx=hash&STRING_TABLE_MASK;
 
 	_data=_table[idx];
-	
+
 	while(_data) {
-		
+
 		if (_data->hash==hash && _data->get_name()==p_name)
 			break;
 		_data=_data->next;
 	}
-		
+
 
 	if (_data) {
 		if (_data->refcount.ref()) {
@@ -329,7 +329,7 @@ StringName::StringName(const String& p_name) {
 	_table[idx]=_data;
 
 	_global_unlock();
-	
+
 }
 
 StringName StringName::search(const char *p_name) {
@@ -435,12 +435,12 @@ StringName StringName::search(const String &p_name) {
 
 
 StringName::StringName() {
-	
+
 	_data=NULL;
 }
 
 StringName::~StringName() {
-	
+
 	unref();
 }
 
diff --git a/core/string_db.h b/core/string_db.h
index f6c6ecefec..43bcccc902 100644
--- a/core/string_db.h
+++ b/core/string_db.h
@@ -46,16 +46,16 @@ struct StaticCString {
 
 
 class StringName {
-	
+
 
 	enum {
-		
+
 		STRING_TABLE_BITS=12,
 		STRING_TABLE_LEN=1<<STRING_TABLE_BITS,
 		STRING_TABLE_MASK=STRING_TABLE_LEN-1
 	};
-	
-	struct _Data {		
+
+	struct _Data {
 		SafeRefCount refcount;
 		const char* cname;
 		String name;
@@ -67,32 +67,32 @@ class StringName {
 		_Data *next;
 		_Data() { cname=NULL; next=prev=NULL; hash=0; }
 	};
-	
-	
+
+
 	static _Data *_table[STRING_TABLE_LEN];
-	
+
 	_Data *_data;
-	
+
 	union _HashUnion {
-		
+
 		_Data *ptr;
 		uint32_t hash;
 	};
-	
+
 	void unref();
 friend void register_core_types();
 friend void unregister_core_types();
-	
+
 	static void setup();
 	static void cleanup();
 	static bool configured;
-	
+
 	StringName(_Data *p_data) { _data=p_data; }
 public:
 
 
 	operator const void*() const { return (_data && (_data->cname || !_data->name.empty()))?(void*)1:0; }
-	
+
 	bool operator==(const String& p_name) const;
 	bool operator==(const char* p_name) const;
 	bool operator!=(const String& p_name) const;
@@ -101,19 +101,19 @@ public:
 		return _data<p_name._data;
 	}
 	_FORCE_INLINE_ bool operator==(const StringName& p_name) const {
-		// the real magic of all this mess happens here. 
+		// the real magic of all this mess happens here.
 		// this is why path comparisons are very fast
 		return _data==p_name._data;
-	}	
+	}
 	_FORCE_INLINE_ uint32_t hash() const {
-		
+
 		if (_data)
 			return _data->hash;
 		else
 			return 0;
 	}
 	bool operator!=(const StringName& p_name) const;
-	
+
 	_FORCE_INLINE_ operator String() const {
 
 		if (_data) {
@@ -148,7 +148,7 @@ public:
 };
 
 struct StringNameHasher {
-	
+
 	static _FORCE_INLINE_ uint32_t hash(const StringName &p_string) { return p_string.hash(); }
 };
 
diff --git a/core/typedefs.h b/core/typedefs.h
index eab0ebc545..5047644692 100644
--- a/core/typedefs.h
+++ b/core/typedefs.h
@@ -270,7 +270,7 @@ void _global_lock();
 void _global_unlock();
 
 struct _GlobalLock {
-	
+
 	_GlobalLock() { _global_lock(); }
 	~_GlobalLock() { _global_unlock(); }
 };
diff --git a/core/undo_redo.cpp b/core/undo_redo.cpp
index ecbda1d3fd..d6d32ccaef 100644
--- a/core/undo_redo.cpp
+++ b/core/undo_redo.cpp
@@ -239,7 +239,7 @@ void UndoRedo::_process_operation_list(List<Operation>::Element *E) {
 
 			case Operation::TYPE_METHOD: {
 
-				obj->call(op.name,VARIANT_ARGS_FROM_ARRAY(op.args));				
+				obj->call(op.name,VARIANT_ARGS_FROM_ARRAY(op.args));
 #ifdef TOOLS_ENABLED
 				Resource* res = obj->cast_to<Resource>();
 				if (res)
@@ -450,10 +450,10 @@ void UndoRedo::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("create_action","name","mergeable"),&UndoRedo::create_action, DEFVAL(false) );
 	ObjectTypeDB::bind_method(_MD("commit_action"),&UndoRedo::commit_action);
-	
+
 	//ObjectTypeDB::bind_method(_MD("add_do_method","p_object", "p_method", "VARIANT_ARG_LIST"),&UndoRedo::add_do_method);
 	//ObjectTypeDB::bind_method(_MD("add_undo_method","p_object", "p_method", "VARIANT_ARG_LIST"),&UndoRedo::add_undo_method);
-	
+
 	{
 		MethodInfo mi;
 		mi.name="add_do_method";
diff --git a/core/ustring.cpp b/core/ustring.cpp
index 1017fc0ca3..a9d0012ebe 100644
--- a/core/ustring.cpp
+++ b/core/ustring.cpp
@@ -67,14 +67,14 @@ void String::copy_from(const char *p_cstr) {
 		len++;
 
 	if (len==0) {
-	
+
 		resize(0);
 		return;
 	}
-	
+
 
 	resize(len+1); // include 0
-	
+
 	CharType *dst = this->ptr();
 
 	for (int i=0;i<len+1;i++) {
@@ -85,35 +85,35 @@ void String::copy_from(const char *p_cstr) {
 }
 
 void String::copy_from(const CharType* p_cstr, int p_clip_to) {
-				
+
 	int len=0;
 	const CharType *ptr=p_cstr;
 	while (*(ptr++)!=0)
 		len++;
-	
+
 	if (p_clip_to>=0 && len>p_clip_to)
 		len=p_clip_to;
-		
+
 	if (len==0) {
-	
+
 		resize(0);
 		return;
 	}
-	
+
 	resize(len+1);
 	set(len,0);
-	
+
 	CharType *dst = &operator[](0);
-	
-	
+
+
 	for (int i=0;i<len;i++) {
-	
+
 		dst[i]=p_cstr[i];
 	}
 }
 
 void String::copy_from(const CharType& p_char) {
-		
+
 	resize(2);
 	set(0,p_char);
 	set(1,0);
@@ -126,12 +126,12 @@ bool String::operator==(const String& p_str) const {
 		return false;
 	if (empty())
 		return true;
-		
+
 	int l=length();
-	
+
 	const CharType *src = c_str();
 	const CharType *dst = p_str.c_str();
-	
+
 	/* Compare char by char */
 	for (int i=0;i<l;i++) {
 
@@ -170,19 +170,19 @@ String& String::operator+=(const String &p_str) {
 		*this=p_str;
 		return *this;
 	}
-	
+
 	if (p_str.empty())
 		return *this;
-		
+
 	int from=length();
-	
+
 	resize( length() + p_str.size() );
-	
+
 	const CharType *src = p_str.c_str();
 	CharType *dst = &operator[](0);
 
 	set( length(), 0 );
-	
+
 	for (int i=0;i<p_str.length();i++)
 		dst[from+i]=src[i];
 
@@ -200,11 +200,11 @@ String& String::operator+=(const CharType *p_str) {
 
 String&  String::operator+=(CharType p_char) {
 
-	
+
 	resize( size() ? size() + 1 : 2);
 	set( length(), 0 );
 	set( length() -1, p_char );
-	
+
 	return *this;
 
 }
@@ -220,13 +220,13 @@ String& String::operator+=(const char * p_str) {
 		src_len++;
 
 	int from=length();
-	
+
 	resize( from + src_len + 1 );
-	
+
 	CharType *dst = &operator[](0);
-	
+
 	set( length(), 0 );
-	
+
 	for (int i=0;i<src_len;i++)
 		dst[from+i]=p_str[i];
 
@@ -283,11 +283,11 @@ bool String::operator==(const char *p_str) const {
 		return false;
 	if (empty())
 		return true;
-		
+
 	int l=length();
-	
+
 	const CharType *dst = c_str();
-	
+
 	/* Compare char by char */
 	for (int i=0;i<l;i++) {
 
@@ -312,11 +312,11 @@ bool String::operator==(const CharType *p_str) const {
 		return false;
 	if (empty())
 		return true;
-		
+
 	int l=length();
-	
+
 	const CharType *dst = c_str();
-	
+
 	/* Compare char by char */
 	for (int i=0;i<l;i++) {
 
@@ -347,8 +347,8 @@ bool String::operator<(const CharType *p_str) const {
 		return false;
 	if (empty())
 		return true;
-	
-	
+
+
 	const CharType *this_str=c_str();
 	while (true) {
 
@@ -382,7 +382,7 @@ bool String::operator<(const char *p_str) const {
 		return false;
 	if (empty())
 		return true;
-	
+
 	const CharType *this_str=c_str();
 	while (true) {
 
@@ -412,7 +412,7 @@ bool String::operator<(String p_str) const {
 	return operator<(p_str.c_str());
 }
 
-signed char String::nocasecmp_to(const String &p_str) const { 
+signed char String::nocasecmp_to(const String &p_str) const {
 
 	if (empty() && p_str.empty())
 		return 0;
@@ -423,7 +423,7 @@ signed char String::nocasecmp_to(const String &p_str) const {
 
 	const CharType *that_str=p_str.c_str();
 	const CharType *this_str=c_str();
-	
+
 	while (true) {
 
 		if (*that_str==0 && *this_str==0)
@@ -445,7 +445,7 @@ signed char String::nocasecmp_to(const String &p_str) const {
 
 }
 
-signed char String::casecmp_to(const String &p_str) const { 
+signed char String::casecmp_to(const String &p_str) const {
 
 	if (empty() && p_str.empty())
 		return 0;
@@ -456,7 +456,7 @@ signed char String::casecmp_to(const String &p_str) const {
 
 	const CharType *that_str=p_str.c_str();
 	const CharType *this_str=c_str();
-	
+
 	while (true) {
 
 		if (*that_str==0 && *this_str==0)
@@ -493,17 +493,17 @@ String String::capitalize() const {
 	String aux=this->replace("_"," ").to_lower();
 	String cap;
 	for (int i=0;i<aux.get_slice_count(" ");i++) {
-		
+
 		String slice=aux.get_slicec(' ',i);
 		if (slice.length()>0) {
-		
+
 			slice[0]=_find_upper(slice[0]);
 			if (i>0)
 				cap+=" ";
 			cap+=slice;
 		}
 	}
-	
+
 	return cap;
 }
 
@@ -542,7 +542,7 @@ int String::get_slice_count(String p_splitter) const{
 		return 0;
 	if (p_splitter.empty())
 		return 0;
-	
+
 	int pos=0;
 	int slices=1;
 
@@ -559,7 +559,7 @@ String String::get_slice(String p_splitter, int p_slice) const {
 
 	if (empty() || p_splitter.empty())
 		return "";
-		
+
 	int pos=0;
 	int prev_pos=0;
 //	int slices=1;
@@ -844,7 +844,7 @@ int String::length() const {
 const CharType * String::c_str() const {
 
 	static const CharType zero=0;
-	
+
 	return size()?&operator[](0):&zero;
 }
 
@@ -867,10 +867,10 @@ String String::md5(const uint8_t *p_md5) {
 }
 
 String String::chr(CharType p_char) {
-		
+
 	CharType c[2]={p_char,0};
 	return String(c);
-	
+
 }
 String String::num(double p_num,int p_decimals) {
 
@@ -1014,7 +1014,7 @@ String String::num(double p_num,int p_decimals) {
 
 		String decimal;
 		for (int i=0;i<digit;i++) {
-	
+
 			char num[2]={0,0};
 			num[0]='0'+dec_int%10;
 			decimal=num+decimal;
@@ -1200,10 +1200,10 @@ CharString String::ascii(bool p_allow_extended) const {
 
 	CharString cs;
 	cs.resize(size());
-	
+
 	for (int i=0;i<size();i++)
 		cs[i]=operator[](i);
-		
+
 	return cs;
 
 }
@@ -1608,7 +1608,7 @@ int String::to_int() const {
 			integer+=c-'0';
 
 		} else if (integer==0 && c=='-') {
-		
+
 			sign=-sign;
 		}
 
@@ -2207,14 +2207,14 @@ double String::to_double() const {
 	double exp=0;
 	double exp_sign=1.0;
 	int reading=READING_SIGN;
-	
+
 	const CharType *str=&operator[](0);
 
 	while(*str && reading!=READING_DONE) {
-	
+
 		CharType c=*(str++);
 		switch(reading) {
-			case READING_SIGN: {		
+			case READING_SIGN: {
 				if (c>='0' && c<='9')
 					reading=READING_INT;
 					// let it fallthrough
@@ -2228,26 +2228,26 @@ double String::to_double() const {
 				} else {
 					break;
 				}
-			} 
+			}
 			case READING_INT: {
-			
+
 				if (c>='0' && c<='9') {
-		
+
 					integer*=10;
-					integer+=c-'0';		
-				} else if (c=='.') {				
+					integer+=c-'0';
+				} else if (c=='.') {
 					reading=READING_DEC;
 				} else if (c=='e') {
 					reading=READING_EXP;
 				} else {
 					reading=READING_DONE;
 				}
-			
+
 			 } break;
 			case READING_DEC: {
-			
+
 				if (c>='0' && c<='9') {
-					
+
 					decimal+=(c-'0')*decimal_mult;
 					decimal_mult*=0.1;
 				} else if (c=='e') {
@@ -2255,12 +2255,12 @@ double String::to_double() const {
 				} else {
 					reading=READING_DONE;
 				}
-			
+
 			 } break;
 			case READING_EXP: {
-			
+
 				if (c>='0' && c<='9') {
-					
+
 					exp*=10.0;
 					exp+=(c-'0');
 				} else if (c=='-' && exp==0) {
@@ -2274,14 +2274,14 @@ double String::to_double() const {
 			 } break;
 		}
 	}
-	
+
 	return sign*(integer+decimal)*Math::pow(10,exp_sign*exp);
 #endif
 #if 0
 
 
 	double ret=sign*(integer+decimal)*Math::pow(10,exp_sign*exp);
-	
+
 	print_line(*this +" == "+rtos(ret));
 	return ret;
 #endif
@@ -2308,14 +2308,14 @@ String operator+(CharType p_chr, const String& p_str) {
 }
 
 uint32_t String::hash(const char* p_cstr) {
-		
+
 	uint32_t hashv = 5381;
 	uint32_t c;
-	
+
 	while ((c = *p_cstr++))
 		hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */
-	
-	return hashv;	
+
+	return hashv;
 }
 
 uint32_t String::hash(const char* p_cstr,int p_len) {
@@ -2348,19 +2348,19 @@ uint32_t String::hash(const CharType* p_cstr) {
 }
 
 uint32_t String::hash() const {
-	
+
 	/* simple djb2 hashing */
-		
+
 	const CharType * chr = c_str();
 	uint32_t hashv = 5381;
 	uint32_t c;
-	
+
 	while ((c = *chr++))
 		hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */
-	
+
 	return hashv;
-	
-	
+
+
 }
 
 uint64_t String::hash64() const {
@@ -2442,16 +2442,16 @@ String String::substr(int p_from,int p_chars) const{
 }
 
 int String::find_last(String p_str) const {
-	
+
 	int pos=-1;
 	int findfrom=0;
 	int findres=-1;
 	while((findres=find(p_str,findfrom))!=-1) {
-		
+
 		pos=findres;
 		findfrom=pos+1;
 	}
-	
+
 	return pos;
 }
 int String::find(String p_str,int p_from) const {
@@ -2708,48 +2708,48 @@ bool String::ends_with(const String& p_string) const {
 }
 
 bool String::begins_with(const String& p_string) const {
-	
+
 	if (p_string.length() > length())
 		return false;
-	
+
 	int l=p_string.length();
 	if (l==0)
 		return true;
-	
+
 	const CharType *src=&p_string[0];
 	const CharType *str=&operator[](0);
-	
+
 	int i = 0;
 	for (;i<l;i++) {
-		
+
 		if (src[i]!=str[i])
 			return false;
 	}
-		     
+
 	// only if i == l the p_string matches the beginning
 	return i == l;
-	
+
 }
 bool String::begins_with(const char* p_string) const {
-		
+
 	int l=length();
 	if (l==0||!p_string)
 		return false;
-	
+
 	const CharType *str=&operator[](0);
 	int i=0;
-	
+
 	while (*p_string && i<l) {
-		
+
 		if (*p_string != str[i])
 			return false;
 		i++;
 		p_string++;
-		
+
 	}
-	
+
 	return *p_string == 0;
-	
+
 }
 
 
@@ -2762,27 +2762,27 @@ static bool _wildcard_match(const CharType* p_pattern, const CharType* p_string,
 	case '?' :
 		return *p_string && (*p_string != '.') && _wildcard_match(p_pattern+1, p_string+1,p_case_sensitive);
 	default  :
-		
+
 		return (p_case_sensitive?(*p_string==*p_pattern):(_find_upper(*p_string)==_find_upper(*p_pattern))) && _wildcard_match(p_pattern+1, p_string+1,p_case_sensitive);
-	} 
+	}
 }
 
 
 bool String::match(const String& p_wildcard) const {
-	
+
 	if (!p_wildcard.length() || !length())
 		return false;
-	
+
 	return _wildcard_match(p_wildcard.c_str(),c_str(),true);
 
 }
 
 bool String::matchn(const String& p_wildcard) const {
-	
+
 	if (!p_wildcard.length() || !length())
 		return false;
 	return _wildcard_match(p_wildcard.c_str(),c_str(),false);
-	
+
 }
 
 String String::replace(String p_key,String p_with) const {
@@ -2854,7 +2854,7 @@ String String::right(int p_pos) const {
 
 	if (p_pos>=size())
 		return *this;
-	
+
 	if (p_pos<0)
 		return "";
 
@@ -2868,26 +2868,26 @@ CharType String::ord_at(int p_idx) const {
 }
 
 String String::strip_edges() const {
-	
+
 	int len=length();
 	int beg=0,end=len;
-	
+
 	for (int i=0;i<length();i++) {
-		
+
 		if (operator[](i)<=32)
 			beg++;
 		else
 			break;
 	}
-	
+
 	for (int i=(int)(length()-1);i>=0;i--) {
-		
+
 		if (operator[](i)<=32)
 			end--;
 		else
 			break;
 	}
-	
+
 	if (beg==0 && end==len)
 		return *this;
 
@@ -3012,7 +3012,7 @@ String String::humanize_size(size_t p_size) {
 
 	int digits=prefix_idx>0?_humanize_digits(p_size/_div):0;
 	double divisor = prefix_idx>0?_div:1;
-	
+
 	return String::num(p_size/divisor,digits)+prefix[prefix_idx];
 }
 bool String::is_abs_path() const {
@@ -3587,12 +3587,12 @@ String String::get_file() const {
 }
 
 String String::extension() const {
-	
+
 	int pos = find_last(".");
 	if (pos<0)
 		return *this;
-	
-	return substr( pos+1, length() );	
+
+	return substr( pos+1, length() );
 }
 
 String String::plus_file(const String& p_file) const {
@@ -3749,7 +3749,7 @@ String String::sprintf(const Array& values, bool* error) const {
 					if (!values[value_index].is_num()) {
 						return "a number is required";
 					}
-					
+
 					int64_t value = values[value_index];
 					int base;
 					bool capitalize = false;
@@ -3811,7 +3811,7 @@ String String::sprintf(const Array& values, bool* error) const {
 					formatted += str;
 					++value_index;
 					in_format = false;
-					
+
 					break;
 				}
 				case 's': { // String
diff --git a/core/ustring.h b/core/ustring.h
index e65103ff99..6310d0a854 100644
--- a/core/ustring.h
+++ b/core/ustring.h
@@ -40,7 +40,7 @@
 
 
 class CharString : public Vector<char> {
-public:	
+public:
 	int length() const { return size() ? size()-1 : 0; }
 	const char *get_data() const;
 	operator const char*() {return get_data();};
@@ -120,7 +120,7 @@ public:
 	bool match(const String& p_wildcard) const;
 	bool matchn(const String& p_wildcard) const;
 	bool begins_with(const String& p_string) const;
-	bool begins_with(const char* p_string) const;	
+	bool begins_with(const char* p_string) const;
 	bool ends_with(const String& p_string) const;
 	String replace_first(String p_key,String p_with) const;
 	String replace(String p_key,String p_with) const;
@@ -182,17 +182,17 @@ public:
 	CharString utf8() const;
 	bool parse_utf8(const char* p_utf8,int p_len=-1); //return true on error
 	static String utf8(const char* p_utf8,int p_len=-1);
-	
+
 	static uint32_t hash(const CharType* p_str,int p_len); /* hash the string */
 	static uint32_t hash(const CharType* p_str); /* hash the string */
 	static uint32_t hash(const char* p_cstr,int p_len); /* hash the string */
 	static uint32_t hash(const char* p_cstr); /* hash the string */
 	uint32_t hash() const; /* hash the string */
-	uint64_t hash64() const; /* hash the string */	
+	uint64_t hash64() const; /* hash the string */
 	String md5_text() const;
 	Vector<uint8_t> md5_buffer() const;
 
-	inline bool empty() const { return length() == 0; }	
+	inline bool empty() const { return length() == 0; }
 
 	// path functions
 	bool is_abs_path() const;
@@ -213,7 +213,7 @@ public:
 	String c_unescape() const;
 	String json_escape() const;
 	String world_wrap(int p_chars_per_line) const;
-	
+
 	String percent_encode() const;
 	String percent_decode() const;
 
@@ -247,9 +247,9 @@ String rtoss(double p_val); //scientific version
 
 
 struct NoCaseComparator {
-		
+
 	bool operator()(const String& p_a, const String& p_b) const {
-		
+
 		return p_a.nocasecmp_to(p_b)<0;
 	}
 };
diff --git a/core/variant.cpp b/core/variant.cpp
index 1fdbc9f753..527a0d238f 100644
--- a/core/variant.cpp
+++ b/core/variant.cpp
@@ -37,7 +37,7 @@
 
 
 String Variant::get_type_name(Variant::Type p_type) {
-	
+
 	switch( p_type ) {
 		case NIL: {
 
@@ -297,7 +297,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) {
 
 			valid_types=valid;
 
-		} break;		
+		} break;
 
 		case COLOR: {
 
@@ -948,52 +948,52 @@ bool Variant::is_one() const {
 
 void Variant::reference(const Variant& p_variant) {
 
-	
+
 	if (this == &p_variant)
 		return;
-		
+
 	clear();
-		
+
 	type=p_variant.type;
-		
+
 	switch( p_variant.type ) {
 		case NIL: {
-		
+
 			// none
 		} break;
-		
-		// atomic types 		
+
+		// atomic types
 		case BOOL: {
-		
+
 			_data._bool=p_variant._data._bool;
 		} break;
 		case INT: {
-		
+
 			_data._int=p_variant._data._int;
-		
+
 		} break;
 		case REAL: {
-		
+
 			_data._real=p_variant._data._real;
-		
+
 		} break;
 		case STRING: {
-		
+
 			memnew_placement( _data._mem, String( *reinterpret_cast<const String*>(p_variant._data._mem) ) );
-			
+
 		} break;
-		
+
 		// math types
-		
+
 		case VECTOR2: {
-		
+
 			memnew_placement( _data._mem, Vector2( *reinterpret_cast<const Vector2*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case RECT2: {
-		
+
 			memnew_placement( _data._mem, Rect2( *reinterpret_cast<const Rect2*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case MATRIX32: {
 
@@ -1001,100 +1001,100 @@ void Variant::reference(const Variant& p_variant) {
 
 		} break;
 		case VECTOR3: {
-		
+
 			memnew_placement( _data._mem, Vector3( *reinterpret_cast<const Vector3*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case PLANE: {
-		
+
 			memnew_placement( _data._mem, Plane( *reinterpret_cast<const Plane*>(p_variant._data._mem) ) );
-		
+
 		} break;
-/*		
+/*
 		case QUAT: {
-		
-		
+
+
 		} break;*/
 		case _AABB: {
-		
+
 			_data._aabb = memnew( AABB( *p_variant._data._aabb ) );
 		} break;
 		case QUAT: {
-		
+
 			memnew_placement( _data._mem, Quat( *reinterpret_cast<const Quat*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case MATRIX3: {
-		
+
 			_data._matrix3 = memnew( Matrix3( *p_variant._data._matrix3 ) );
-		
+
 		} break;
 		case TRANSFORM: {
-		
+
 			_data._transform = memnew( Transform( *p_variant._data._transform ) );
-		
+
 		} break;
-		
-		// misc types		
+
+		// misc types
 		case COLOR: {
-		
+
 			memnew_placement( _data._mem, Color( *reinterpret_cast<const Color*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case IMAGE: {
-		
+
 			_data._image = memnew( Image( *p_variant._data._image ) );
-		
+
 		} break;
 		case _RID: {
-		
+
 			memnew_placement( _data._mem, RID( *reinterpret_cast<const RID*>(p_variant._data._mem) ) );
 		} break;
 		case OBJECT: {
-		
+
 			memnew_placement( _data._mem, ObjData( p_variant._get_obj() ) );
 		} break;
 		case NODE_PATH: {
-		
+
 			memnew_placement( _data._mem, NodePath( *reinterpret_cast<const NodePath*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case INPUT_EVENT: {
-			
+
 			_data._input_event= memnew( InputEvent( *p_variant._data._input_event ) );
-			
+
 		} break;
 		case DICTIONARY: {
-			
+
 			memnew_placement( _data._mem, Dictionary( *reinterpret_cast<const Dictionary*>(p_variant._data._mem) ) );
-			
+
 		} break;
 		case ARRAY: {
-			
+
 			memnew_placement( _data._mem, Array ( *reinterpret_cast<const Array*>(p_variant._data._mem) ) );
-			
+
 		} break;
-		
+
 		// arrays
 		case RAW_ARRAY: {
-		
+
 			memnew_placement( _data._mem, DVector<uint8_t> ( *reinterpret_cast<const DVector<uint8_t>*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case INT_ARRAY: {
-		
+
 			memnew_placement( _data._mem, DVector<int> ( *reinterpret_cast<const DVector<int>*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case REAL_ARRAY: {
-		
+
 			memnew_placement( _data._mem, DVector<real_t> ( *reinterpret_cast<const DVector<real_t>*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case STRING_ARRAY: {
-		
+
 			memnew_placement( _data._mem, DVector<String> ( *reinterpret_cast<const DVector<String>*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case VECTOR2_ARRAY: {
 
@@ -1102,17 +1102,17 @@ void Variant::reference(const Variant& p_variant) {
 
 		} break;
 		case VECTOR3_ARRAY: {
-		
+
 			memnew_placement( _data._mem, DVector<Vector3> ( *reinterpret_cast<const DVector<Vector3>*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		case COLOR_ARRAY: {
-		
+
 			memnew_placement( _data._mem, DVector<Color> ( *reinterpret_cast<const DVector<Color>*>(p_variant._data._mem) ) );
-		
+
 		} break;
 		default: {}
-	}		
+	}
 
 
 }
@@ -1135,7 +1135,7 @@ void Variant::clear() {
 
 	switch(type) {
 		case STRING: {
-		
+
 			reinterpret_cast<String*>(_data._mem)->~String();
 		} break;
 	/*
@@ -1153,33 +1153,33 @@ void Variant::clear() {
 
 		} break;
 		case _AABB: {
-		
+
 			memdelete( _data._aabb );
-		
+
 		} break;
 		case MATRIX3: {
-		
+
 			memdelete( _data._matrix3 );
 		} break;
 		case TRANSFORM: {
-		
+
 			memdelete( _data._transform );
-		
+
 		} break;
-		
-		// misc types		
+
+		// misc types
 		case IMAGE: {
-		
+
 			memdelete( _data._image );
-		
+
 		} break;
 		case NODE_PATH: {
-		
+
 			reinterpret_cast<NodePath*>(_data._mem)->~NodePath();
-		
+
 		} break;
 		case OBJECT: {
-		
+
 			_get_obj().obj=NULL;
 			_get_obj().ref.unref();
 		} break;
@@ -1188,41 +1188,41 @@ void Variant::clear() {
 			reinterpret_cast<RID*>(_data._mem)->~RID();
 		} break;
 		case DICTIONARY: {
-			
+
 			reinterpret_cast<Dictionary*>(_data._mem)->~Dictionary();
-			
+
 		} break;
 		case ARRAY: {
-			
+
 			reinterpret_cast<Array*>(_data._mem)->~Array();
-			
+
 		} break;
 		case INPUT_EVENT: {
-			
+
 			memdelete( _data._input_event );
-			
+
 		} break;
-		
+
 		// arrays
 		case RAW_ARRAY: {
-		
+
 			reinterpret_cast< DVector<uint8_t>* >(_data._mem)->~DVector<uint8_t>();
-		
+
 		} break;
 		case INT_ARRAY: {
-		
+
 			reinterpret_cast< DVector<int>* >(_data._mem)->~DVector<int>();
-		
+
 		} break;
 		case REAL_ARRAY: {
-		
+
 			reinterpret_cast< DVector<real_t>* >(_data._mem)->~DVector<real_t>();
-		
+
 		} break;
 		case STRING_ARRAY: {
-		
+
 			reinterpret_cast< DVector<String>* >(_data._mem)->~DVector<String>();
-		
+
 		} break;
 		case VECTOR2_ARRAY: {
 
@@ -1230,55 +1230,55 @@ void Variant::clear() {
 
 		} break;
 		case VECTOR3_ARRAY: {
-		
+
 			reinterpret_cast< DVector<Vector3>* >(_data._mem)->~DVector<Vector3>();
-		
+
 		} break;
 		case COLOR_ARRAY: {
-		
+
 			reinterpret_cast< DVector<Color>* >(_data._mem)->~DVector<Color>();
-		
+
 		} break;
 		default: {} /* not needed */
 	}
-	
+
 	type=NIL;
 
 }
-	
+
 
 Variant::operator signed int() const {
 
 	switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1 : 0;
 		case INT: return _data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_int();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return 0;
 }
 Variant::operator unsigned int() const {
 
 		switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1 : 0;
 		case INT: return _data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_int();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return 0;
 }
 
@@ -1380,69 +1380,69 @@ Variant::operator unsigned long() const {
 Variant::operator signed short() const {
 
 	switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1 : 0;
 		case INT: return _data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_int();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return 0;
 }
 Variant::operator unsigned short() const {
 
 	switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1 : 0;
 		case INT: return _data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_int();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return 0;
 }
 Variant::operator signed char() const {
 
 	switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1 : 0;
 		case INT: return _data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_int();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return 0;
 }
 Variant::operator unsigned char() const {
 
 	switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1 : 0;
 		case INT: return _data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_int();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return 0;
 }
 #ifndef CHARTYPE_16BITS
@@ -1455,40 +1455,40 @@ Variant::operator CharType() const {
 Variant::operator float() const {
 
 	switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1.0 : 0.0;
 		case INT: return (float)_data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_double();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return 0;
 }
 Variant::operator double() const {
 
 	switch( type ) {
-	
-		case NIL: return 0; 
+
+		case NIL: return 0;
 		case BOOL: return _data._bool ? 1.0 : 0.0;
 		case INT: return (float)_data._int;
 		case REAL: return _data._real;
 		case STRING: return operator String().to_double();
 		default: {
-		
+
 			return 0;
-		}		
+		}
 	}
-	
+
 	return true;
 }
 
 Variant::operator StringName() const {
-	
+
 	if (type==NODE_PATH) {
 		return reinterpret_cast<const NodePath*>(_data._mem)->get_sname();
 	}
@@ -1509,8 +1509,8 @@ struct _VariantStrPair {
 Variant::operator String() const {
 
 	switch( type ) {
-	
-		case NIL: return ""; 
+
+		case NIL: return "";
 		case BOOL: return _data._bool ? "True" : "False";
 		case INT: return String::num(_data._int);
 		case REAL: return String::num(_data._real);
@@ -1520,7 +1520,7 @@ Variant::operator String() const {
 		case MATRIX32: return operator Matrix32();
 		case VECTOR3: return operator Vector3();
 		case PLANE: return operator Plane();
-		//case QUAT: 
+		//case QUAT:
 		case _AABB: return operator AABB();
 		case QUAT: return operator Quat();
 		case MATRIX3: return operator Matrix3();
@@ -1529,7 +1529,7 @@ Variant::operator String() const {
 		case INPUT_EVENT: return operator InputEvent();
 		case COLOR: return String::num( operator Color().r)+","+String::num( operator Color().g)+","+String::num( operator Color().b)+","+String::num( operator Color().a) ;
 		case DICTIONARY: {
-			
+
 			const Dictionary &d =*reinterpret_cast<const Dictionary*>(_data._mem);
 			//const String *K=NULL;
 			String str;
@@ -1553,15 +1553,15 @@ Variant::operator String() const {
 					str+=", ";
 				str+="("+pairs[i].key+":"+pairs[i].value+")";
 			}
-			
+
 			return str;
 		} break;
-		case VECTOR3_ARRAY: { 
-		
+		case VECTOR3_ARRAY: {
+
 			DVector<Vector3> vec = operator DVector<Vector3>();
 			String str;
 			for(int i=0;i<vec.size();i++) {
-			
+
 				if (i>0)
 					str+=", ";
 				str=str+Variant( vec[i] );
@@ -1634,9 +1634,9 @@ Variant::operator String() const {
 		} break;
 		default: {
 			return "["+get_type_name(type)+"]";
-		}		
+		}
 	}
-	
+
 	return "";
 }
 
@@ -1819,7 +1819,7 @@ Variant::operator Control*() const {
 }
 
 Variant::operator InputEvent() const {
-	
+
 	if (type==INPUT_EVENT)
 		return *reinterpret_cast<const InputEvent*>(_data._input_event);
 	else
@@ -1827,8 +1827,8 @@ Variant::operator InputEvent() const {
 }
 
 Variant::operator Dictionary() const {
-	
-	if (type==DICTIONARY) 
+
+	if (type==DICTIONARY)
 		return *reinterpret_cast<const Dictionary*>(_data._mem);
 	else
 		return Dictionary();
@@ -1869,10 +1869,10 @@ inline DA _convert_array_from_variant(const Variant& p_variant) {
 }
 
 Variant::operator Array() const {
-	
-	if (type==ARRAY) 
+
+	if (type==ARRAY)
 		return *reinterpret_cast<const Array*>(_data._mem);
-	else 
+	else
 		return _convert_array_from_variant<Array >(*this);
 }
 
@@ -2019,17 +2019,17 @@ Variant::operator Vector<Plane>() const {
 }
 
 Variant::operator Vector<Variant>() const {
-	
+
 	Array from=operator Array();
 	Vector<Variant> to;
 	int len=from.size();
 	to.resize(len);
 	for (int i=0;i<len;i++) {
-	
+
 		to[i]=from[i];
 	}
 	return to;
-	
+
 }
 
 Variant::operator Vector<uint8_t>() const {
@@ -2039,7 +2039,7 @@ Variant::operator Vector<uint8_t>() const {
 	int len=from.size();
 	to.resize(len);
 	for (int i=0;i<len;i++) {
-	
+
 		to[i]=from[i];
 	}
 	return to;
@@ -2051,7 +2051,7 @@ Variant::operator Vector<int>() const {
 	int len=from.size();
 	to.resize(len);
 	for (int i=0;i<len;i++) {
-	
+
 		to[i]=from[i];
 	}
 	return to;
@@ -2063,7 +2063,7 @@ Variant::operator Vector<real_t>() const {
 	int len=from.size();
 	to.resize(len);
 	for (int i=0;i<len;i++) {
-	
+
 		to[i]=from[i];
 	}
 	return to;
@@ -2076,7 +2076,7 @@ Variant::operator Vector<String>() const {
 	int len=from.size();
 	to.resize(len);
 	for (int i=0;i<len;i++) {
-	
+
 		to[i]=from[i];
 	}
 	return to;
@@ -2093,7 +2093,7 @@ Variant::operator Vector<Vector3>() const {
 	DVector<Vector3>::Read r = from.read();
 	Vector3 *w = &to[0];
 	for (int i=0;i<len;i++) {
-	
+
 		w[i]=r[i];
 	}
 	return to;
@@ -2168,16 +2168,16 @@ Variant::Variant(unsigned int p_int) {
 #ifdef NEED_LONG_INT
 
 Variant::Variant(signed long p_int) {
-	
+
 	type=INT;
 	_data._int=p_int;
-	
+
 }
 Variant::Variant(unsigned long p_int) {
-	
+
 	type=INT;
 	_data._int=p_int;
-	
+
 }
 #endif
 
@@ -2232,10 +2232,10 @@ Variant::Variant(double p_double) {
 }
 
 Variant::Variant(const StringName& p_string) {
-	
+
 	type=STRING;
 	memnew_placement( _data._mem, String( p_string.operator String() ) );
-	
+
 }
 Variant::Variant(const String& p_string) {
 
@@ -2335,9 +2335,9 @@ Variant::Variant(const NodePath& p_node_path) {
 }
 
 Variant::Variant(const InputEvent& p_input_event) {
-	
+
 	type=INPUT_EVENT;
-	_data._input_event = memnew( InputEvent(p_input_event) );	
+	_data._input_event = memnew( InputEvent(p_input_event) );
 
 }
 
@@ -2367,10 +2367,10 @@ Variant::Variant(const Object* p_object) {
 }
 
 Variant::Variant(const Dictionary& p_dictionary) {
-	
+
 	type=DICTIONARY;
 	memnew_placement( _data._mem, (Dictionary)( p_dictionary) );
-	
+
 }
 
 Variant::Variant(const Array& p_array) {
@@ -2382,15 +2382,15 @@ Variant::Variant(const Array& p_array) {
 
 Variant::Variant(const DVector<Plane>& p_array) {
 
-	
+
 	type=ARRAY;
 
 	Array *plane_array=memnew_placement( _data._mem, Array );
-	
+
 	plane_array->resize( p_array.size() );
-	
+
 	for (int i=0;i<p_array.size();i++) {
-	
+
 		plane_array->operator [](i)=Variant(p_array[i]);
 	}
 }
diff --git a/core/variant.h b/core/variant.h
index d8813c4937..ed33de6660 100644
--- a/core/variant.h
+++ b/core/variant.h
@@ -75,17 +75,17 @@ class Variant {
 public:
 
 	enum Type {
-	
-		NIL,		
-		
-		// atomic types 		
+
+		NIL,
+
+		// atomic types
 		BOOL,
 		INT,
 		REAL,
 		STRING,
-		
+
 		// math types
-		
+
 		VECTOR2,		// 5
 		RECT2,
 		VECTOR3,
@@ -95,17 +95,17 @@ public:
 		_AABB, //sorry naming convention fail :( not like it's used often
 		MATRIX3,
 		TRANSFORM,
-		
-		// misc types		
+
+		// misc types
 		COLOR,
 		IMAGE,			// 15
 		NODE_PATH,
 		_RID,
-		OBJECT,		
+		OBJECT,
 		INPUT_EVENT,
 		DICTIONARY,		// 20
 		ARRAY,
-			
+
 		// arrays
 		RAW_ARRAY,
 		INT_ARRAY,
@@ -114,10 +114,10 @@ public:
 		VECTOR2_ARRAY,
 		VECTOR3_ARRAY,
 		COLOR_ARRAY,
-			
+
 		VARIANT_MAX
-		
-	};	
+
+	};
 
 private:
 
@@ -125,7 +125,7 @@ private:
 	friend class _VariantCall;
 	// Variant takes 20 bytes when real_t is float, and 36 if double
 	// it only allocates extra memory for aabb/matrix.
-	
+
 	Type type;
 
 	struct ObjData {
@@ -133,25 +133,25 @@ private:
 		Object *obj;
 		RefPtr ref;
 	};
-	
+
 
 	_FORCE_INLINE_ ObjData& _get_obj();
 	_FORCE_INLINE_ const ObjData& _get_obj() const;
 
 	union {
-	
+
 		bool _bool;
 		int _int;
 		double _real;
 		Matrix32 *_matrix32;
 		AABB* _aabb;
 		Matrix3 *_matrix3;
-		Transform *_transform;	
+		Transform *_transform;
 		RefPtr *_resource;
 		InputEvent *_input_event;
 		Image *_image;
 		void *_ptr; //generic pointer
-#ifdef USE_QUAD_VECTORS		
+#ifdef USE_QUAD_VECTORS
 		uint8_t _mem[sizeof(ObjData) > (sizeof(real_t)*5) ? sizeof(ObjData) : (sizeof(real_t)*5)]; // plane uses an extra real
 #else
 		uint8_t _mem[sizeof(ObjData) > (sizeof(real_t)*4) ? sizeof(ObjData) : (sizeof(real_t)*4)];
@@ -172,7 +172,7 @@ public:
 
 	template<class T>
 	static Type get_type_for() {
-		
+
 		GetSimpleType<T> t;
 		Variant v(t.type);
 		Type r = v.get_type();
@@ -231,7 +231,7 @@ public:
 
 	operator Dictionary() const;
 	operator Array() const;
-	
+
 	operator DVector<uint8_t>() const;
 	operator DVector<int>() const;
 	operator DVector<real_t>() const;
@@ -260,7 +260,7 @@ public:
 
 	operator IP_Address() const;
 
-	
+
 	Variant(bool p_bool);
 	Variant(signed int p_int); // real one
 	Variant(unsigned int p_int);
@@ -286,8 +286,8 @@ public:
 	Variant(const Vector3& p_vector3);
 	Variant(const Plane& p_plane);
 	Variant(const AABB& p_aabb);
-	Variant(const Quat& p_quat);	
-	Variant(const Matrix3& p_transform);	
+	Variant(const Quat& p_quat);
+	Variant(const Matrix3& p_transform);
 	Variant(const Matrix32& p_transform);
 	Variant(const Transform& p_transform);
 	Variant(const Color& p_color);
@@ -295,10 +295,10 @@ public:
 	Variant(const NodePath& p_path);
 	Variant(const RefPtr& p_resource);
 	Variant(const RID& p_rid);
-	Variant(const Object* p_object);	
+	Variant(const Object* p_object);
 	Variant(const InputEvent& p_input_event);
 	Variant(const Dictionary& p_dictionary);
-	
+
 	Variant(const Array& p_array);
 	Variant(const DVector<Plane>& p_array); // helper
 	Variant(const DVector<uint8_t>& p_raw_array);
@@ -309,7 +309,7 @@ public:
 	Variant(const DVector<Color>& p_color_array);
 	Variant(const DVector<Face3>& p_face_array);
 
-	
+
 	Variant(const Vector<Variant>& p_array);
 	Variant(const Vector<uint8_t>& p_raw_array);
 	Variant(const Vector<int>& p_int_array);
diff --git a/core/variant_op.cpp b/core/variant_op.cpp
index 9887c50dd8..f03ab43fce 100644
--- a/core/variant_op.cpp
+++ b/core/variant_op.cpp
@@ -662,7 +662,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant&
 		case OP_DIVIDE: {
 			switch(p_a.type) {
 
-				DEFAULT_OP_FAIL(NIL);				
+				DEFAULT_OP_FAIL(NIL);
 				DEFAULT_OP_NUM(/,BOOL,_bool);
 				case INT: {
 					switch(p_b.type) {
@@ -779,7 +779,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant&
 				}
 #endif
 				_RETURN( p_a._data._int % p_b._data._int );
-				
+
 			} else if (p_a.type==STRING) {
 				const String* format=reinterpret_cast<const String*>(p_a._data._mem);
 
@@ -2409,7 +2409,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const {
 				} if (str=="value") {
 					valid=true;
 					return ie.joy_motion.axis_value;
-				}				
+				}
 			}
 
 			if (ie.type==InputEvent::SCREEN_TOUCH) {
diff --git a/core/variant_parser.cpp b/core/variant_parser.cpp
index a3775156ac..8bd1fddfad 100644
--- a/core/variant_parser.cpp
+++ b/core/variant_parser.cpp
@@ -451,7 +451,7 @@ Error VariantParser::_parse_construct(Stream *p_stream,Vector<T>& r_construct,in
 		if (!first) {
 			get_token(p_stream,token,line,r_err_str);
 			if (token.type==TK_COMMA) {
-				//do none				
+				//do none
 			} else if (token.type==TK_PARENTHESIS_CLOSE) {
 				break;
 			} else {
@@ -1206,7 +1206,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in
 				get_token(p_stream,token,line,r_err_str);
 
 				if (token.type!=TK_STRING) {
-					r_err_str="Expected string";					
+					r_err_str="Expected string";
 					return ERR_PARSE_ERROR;
 				}
 
@@ -1676,7 +1676,7 @@ Error VariantParser::_parse_tag(Token& token, Stream *p_stream, int &line, Strin
 		if (err)
 			return err;
 
-		r_tag.fields[id]=value;		
+		r_tag.fields[id]=value;
 
 	}
 
diff --git a/core/vector.h b/core/vector.h
index 398d7f1bd5..16a09c1ddd 100644
--- a/core/vector.h
+++ b/core/vector.h
@@ -43,30 +43,30 @@ template<class T>
 class Vector {
 
 	mutable T* _ptr;
- 
+
  	// internal helpers
- 
+
  	_FORCE_INLINE_ SafeRefCount* _get_refcount() const  {
- 	
+
 		if (!_ptr)
  			return NULL;
- 			
+
 		return reinterpret_cast<SafeRefCount*>((uint8_t*)_ptr-sizeof(int)-sizeof(SafeRefCount));
  	}
- 	
+
 	_FORCE_INLINE_ int* _get_size() const  {
- 	
+
 		if (!_ptr)
  			return NULL;
 		return reinterpret_cast<int*>((uint8_t*)_ptr-sizeof(int));
- 		
+
  	}
 	_FORCE_INLINE_ T* _get_data() const {
- 	
+
 		if (!_ptr)
  			return NULL;
 		return reinterpret_cast<T*>(_ptr);
- 		
+
  	}
 
 	_FORCE_INLINE_ size_t _get_alloc_size(size_t p_elements) const {
@@ -88,9 +88,9 @@ class Vector {
 		return true;
 #endif
 	}
- 	
+
 	void _unref(void *p_data);
-	
+
 	void _copy_from(const Vector& p_from);
 	void _copy_on_write();
 public:
@@ -101,18 +101,18 @@ public:
 
 
 	_FORCE_INLINE_ void clear() { resize(0); }
-	
+
 	_FORCE_INLINE_ int size() const {
 		int* size = _get_size();
 		if (size)
 			return *size;
-		else		
+		else
 			return 0;
 	}
 	_FORCE_INLINE_ bool empty() const { return _ptr == 0; }
 	Error resize(int p_size);
 	bool push_back(T p_elem);
-	
+
 	void remove(int p_index);
 	void erase(const T& p_val) { int idx = find(p_val); if (idx>=0) remove(idx); };
 	void invert();
@@ -132,7 +132,7 @@ public:
 		}
 
 		_copy_on_write(); // wants to write, so copy on write.
-		
+
 		return _get_data()[p_index];
 	}
 
@@ -145,7 +145,7 @@ public:
 		// no cow needed, since it's reading
 		return _get_data()[p_index];
 	}
-	
+
 	Error insert(int p_pos,const T& p_val);
 
 	template<class C>
@@ -188,21 +188,21 @@ void Vector<T>::_unref(void *p_data) {
 
 	if (!p_data)
 		return;
-		
+
 	SafeRefCount *src = reinterpret_cast<SafeRefCount*>((uint8_t*)p_data-sizeof(int)-sizeof(SafeRefCount));
-	
+
 	if (!src->unref())
 		return; // still in use
 	// clean up
-		
+
 	int *count = (int*)(src+1);
 	T *data = (T*)(count+1);
-	
+
 	for (int i=0;i<*count;i++) {
-		// call destructors	
+		// call destructors
 		data[i].~T();
 	}
-	
+
 	// free mem
 	memfree((uint8_t*)p_data-sizeof(int)-sizeof(SafeRefCount));
 
@@ -213,7 +213,7 @@ void Vector<T>::_copy_on_write() {
 
 	if (!_ptr)
 		return;
-	
+
 	if (_get_refcount()->get() > 1 ) {
 		/* in use by more than me */
 		void* mem_new = memalloc(_get_alloc_size(*_get_size()));
@@ -221,15 +221,15 @@ void Vector<T>::_copy_on_write() {
 		src_new->init();
 		int * _size = (int*)(src_new+1);
 		*_size=*_get_size();
-		
+
 		T*_data=(T*)(_size+1);
-		
+
 		// initialize new elements
 		for (int i=0;i<*_size;i++) {
-		
+
 			memnew_placement(&_data[i], T( _get_data()[i] ) );
 		}
-		
+
 		_unref(_ptr);
 		_ptr=_data;
 	}
@@ -240,11 +240,11 @@ template<class T> template<class T_val>
 int Vector<T>::find(const T_val &p_val) const {
 
 	int ret = -1;
-	if (size() == 0) 
+	if (size() == 0)
 		return ret;
-		
+
 	for (int i=0; i<size(); i++) {
-	
+
 		if (operator[](i) == p_val) {
 			ret = i;
 			break;
@@ -261,17 +261,17 @@ Error Vector<T>::resize(int p_size) {
 
 	if (p_size==size())
 		return OK;
-		
+
 	if (p_size==0) {
-		// wants to clean up 
+		// wants to clean up
 		_unref(_ptr);
 		_ptr=NULL;
 		return OK;
 	}
-	
+
 	// possibly changing size, copy on write
 	_copy_on_write();
-	
+
 	size_t alloc_size;
 	ERR_FAIL_COND_V(!_get_alloc_size_checked(p_size, &alloc_size), ERR_OUT_OF_MEMORY);
 
@@ -293,16 +293,16 @@ Error Vector<T>::resize(int p_size) {
 
 		// construct the newly created elements
 		T*elems = _get_data();
-		
+
 		for (int i=*_get_size();i<p_size;i++) {
-			
+
 			memnew_placement(&elems[i], T) ;
 		}
 
 		*_get_size()=p_size;
 
 	} else if (p_size<size()) {
-		
+
 		// deinitialize no longer needed elements
 		for (int i=p_size;i<*_get_size();i++) {
 
@@ -312,11 +312,11 @@ Error Vector<T>::resize(int p_size) {
 
 		void *_ptrnew = (T*)memrealloc((uint8_t*)_ptr-sizeof(int)-sizeof(SafeRefCount), alloc_size);
 		ERR_FAIL_COND_V( !_ptrnew ,ERR_OUT_OF_MEMORY);
-		
+
 		_ptr=(T*)((uint8_t*)_ptrnew+sizeof(int)+sizeof(SafeRefCount));
-		
+
 		*_get_size()=p_size;
-				
+
 	}
 
 	return OK;
@@ -325,9 +325,9 @@ Error Vector<T>::resize(int p_size) {
 
 template<class T>
 void Vector<T>::invert() {
-	
+
 	for(int i=0;i<size()/2;i++) {
-		
+
 		SWAP( operator[](i), operator[](size()-i-1) );
 	}
 }
@@ -374,13 +374,13 @@ void Vector<T>::_copy_from(const Vector& p_from) {
 
 	if (_ptr == p_from._ptr)
 		return; // self assign, do nothing.
-		
+
 	_unref(_ptr);
 	_ptr=NULL;
-	
+
 	if (!p_from._ptr)
 		return; //nothing to do
-		
+
 	if (p_from._get_refcount()->ref()) // could reference
 		_ptr=p_from._ptr;
 
@@ -395,13 +395,13 @@ void Vector<T>::operator=(const Vector& p_from) {
 
 template<class T>
 Error Vector<T>::insert(int p_pos,const T& p_val) {
-	
+
 	ERR_FAIL_INDEX_V(p_pos,size()+1,ERR_INVALID_PARAMETER);
 	resize(size()+1);
 	for (int i=(size()-1);i>p_pos;i--)
 		set( i, get(i-1) );
 	set( p_pos, p_val );
-	
+
 	return OK;
 }