Bring that Whole New World to the Old Continent too

Applies the clang-format style to the 2.1 branch as done for master in
5dbf1809c6e3e905b94b8764e99491e608122261.

12 files changed, 5787 insertions, 6862 deletions

diff --git a/servers/visual/particle_system_sw.cpp b/servers/visual/particle_system_sw.cpp
index 9f26589ff..15809f51a 100644
--- a/servers/visual/particle_system_sw.cpp
+++ b/servers/visual/particle_system_sw.cpp
@@ -29,53 +29,48 @@
 #include "particle_system_sw.h"
 #include "sort.h"
 
-
 ParticleSystemSW::ParticleSystemSW() {
 
-	amount=8;
-	emitting=true;
+	amount = 8;
+	emitting = true;
 
-	for (int i=0;i<VS::PARTICLE_VAR_MAX;i++) {
-		particle_randomness[i]=0.0;
+	for (int i = 0; i < VS::PARTICLE_VAR_MAX; i++) {
+		particle_randomness[i] = 0.0;
 	}
 
-	particle_vars[VS::PARTICLE_LIFETIME]=2.0;//
-	particle_vars[VS::PARTICLE_SPREAD]=0.2;//
-	particle_vars[VS::PARTICLE_GRAVITY]=9.8;//
-	particle_vars[VS::PARTICLE_LINEAR_VELOCITY]=0.2;//
-	particle_vars[VS::PARTICLE_ANGULAR_VELOCITY]=0.0;//
-	particle_vars[VS::PARTICLE_LINEAR_ACCELERATION]=0.0;//
-	particle_vars[VS::PARTICLE_RADIAL_ACCELERATION]=0.0;//
-	particle_vars[VS::PARTICLE_TANGENTIAL_ACCELERATION]=1.0;//
-	particle_vars[VS::PARTICLE_DAMPING]=0.0;//
-	particle_vars[VS::PARTICLE_INITIAL_SIZE]=1.0;
-	particle_vars[VS::PARTICLE_FINAL_SIZE]=0.8;
-	particle_vars[VS::PARTICLE_HEIGHT]=1;
-	particle_vars[VS::PARTICLE_HEIGHT_SPEED_SCALE]=1;
+	particle_vars[VS::PARTICLE_LIFETIME] = 2.0; //
+	particle_vars[VS::PARTICLE_SPREAD] = 0.2; //
+	particle_vars[VS::PARTICLE_GRAVITY] = 9.8; //
+	particle_vars[VS::PARTICLE_LINEAR_VELOCITY] = 0.2; //
+	particle_vars[VS::PARTICLE_ANGULAR_VELOCITY] = 0.0; //
+	particle_vars[VS::PARTICLE_LINEAR_ACCELERATION] = 0.0; //
+	particle_vars[VS::PARTICLE_RADIAL_ACCELERATION] = 0.0; //
+	particle_vars[VS::PARTICLE_TANGENTIAL_ACCELERATION] = 1.0; //
+	particle_vars[VS::PARTICLE_DAMPING] = 0.0; //
+	particle_vars[VS::PARTICLE_INITIAL_SIZE] = 1.0;
+	particle_vars[VS::PARTICLE_FINAL_SIZE] = 0.8;
+	particle_vars[VS::PARTICLE_HEIGHT] = 1;
+	particle_vars[VS::PARTICLE_HEIGHT_SPEED_SCALE] = 1;
 
-	height_from_velocity=false;
-	local_coordinates=false;
+	height_from_velocity = false;
+	local_coordinates = false;
 
-	particle_vars[VS::PARTICLE_INITIAL_ANGLE]=0.0;//
+	particle_vars[VS::PARTICLE_INITIAL_ANGLE] = 0.0; //
 
-	gravity_normal=Vector3(0,-1.0,0);
+	gravity_normal = Vector3(0, -1.0, 0);
 	//emission_half_extents=Vector3(0.1,0.1,0.1);
-	emission_half_extents=Vector3(1,1,1);
-	color_phase_count=0;
-	color_phases[0].pos=0.0;
-	color_phases[0].color=Color(1.0,0.0,0.0);
-	visibility_aabb=AABB(Vector3(-64,-64,-64),Vector3(128,128,128));
-
-	attractor_count=0;
+	emission_half_extents = Vector3(1, 1, 1);
+	color_phase_count = 0;
+	color_phases[0].pos = 0.0;
+	color_phases[0].color = Color(1.0, 0.0, 0.0);
+	visibility_aabb = AABB(Vector3(-64, -64, -64), Vector3(128, 128, 128));
 
+	attractor_count = 0;
 }
 
-
-ParticleSystemSW::~ParticleSystemSW()
-{
+ParticleSystemSW::~ParticleSystemSW() {
 }
 
-
 #define DEFAULT_SEED 1234567
 
 _FORCE_INLINE_ static float _rand_from_seed(uint32_t *seed) {
@@ -90,8 +85,8 @@ _FORCE_INLINE_ static float _rand_from_seed(uint32_t *seed) {
 		s += 2147483647;
 	(*seed) = s;
 
-	float v=((float)((*seed) & 0xFFFFF))/(float)0xFFFFF;
-	v=v*2.0-1.0;
+	float v = ((float)((*seed) & 0xFFFFF)) / (float)0xFFFFF;
+	v = v * 2.0 - 1.0;
 	return v;
 }
 
@@ -110,112 +105,108 @@ _FORCE_INLINE_ static uint32_t _irand_from_seed(uint32_t *seed) {
 	return s;
 }
 
-void ParticleSystemProcessSW::process(const ParticleSystemSW *p_system,const Transform& p_transform,float p_time) {
+void ParticleSystemProcessSW::process(const ParticleSystemSW *p_system, const Transform &p_transform, float p_time) {
 
-	valid=false;
-	if (p_system->amount<=0) {
-		ERR_EXPLAIN("Invalid amount of particles: "+itos(p_system->amount));
-		ERR_FAIL_COND(p_system->amount<=0);
+	valid = false;
+	if (p_system->amount <= 0) {
+		ERR_EXPLAIN("Invalid amount of particles: " + itos(p_system->amount));
+		ERR_FAIL_COND(p_system->amount <= 0);
 	}
-	if (p_system->attractor_count<0 || p_system->attractor_count>VS::MAX_PARTICLE_ATTRACTORS) {
+	if (p_system->attractor_count < 0 || p_system->attractor_count > VS::MAX_PARTICLE_ATTRACTORS) {
 		ERR_EXPLAIN("Invalid amount of particle attractors.");
-		ERR_FAIL_COND(p_system->attractor_count<0 || p_system->attractor_count>VS::MAX_PARTICLE_ATTRACTORS);
+		ERR_FAIL_COND(p_system->attractor_count < 0 || p_system->attractor_count > VS::MAX_PARTICLE_ATTRACTORS);
 	}
 	float lifetime = p_system->particle_vars[VS::PARTICLE_LIFETIME];
-	if (lifetime<CMP_EPSILON) {
+	if (lifetime < CMP_EPSILON) {
 		ERR_EXPLAIN("Particle system lifetime too small.");
-		ERR_FAIL_COND(lifetime<CMP_EPSILON);
+		ERR_FAIL_COND(lifetime < CMP_EPSILON);
 	}
-	valid=true;
-	int particle_count=MIN(p_system->amount,ParticleSystemSW::MAX_PARTICLES);;
-
+	valid = true;
+	int particle_count = MIN(p_system->amount, ParticleSystemSW::MAX_PARTICLES);
+	;
 
 	int emission_point_count = p_system->emission_points.size();
 	DVector<Vector3>::Read r;
 	if (emission_point_count)
-		r=p_system->emission_points.read();
+		r = p_system->emission_points.read();
 
-	if (particle_count!=particle_data.size()) {
+	if (particle_count != particle_data.size()) {
 
 		//clear the whole system if particle amount changed
 		particle_data.clear();
 		particle_data.resize(p_system->amount);
-		particle_system_time=0;
+		particle_system_time = 0;
 	}
 
-	float next_time = particle_system_time+p_time;
+	float next_time = particle_system_time + p_time;
 
 	if (next_time > lifetime)
-		next_time=Math::fmod(next_time,lifetime);
-
+		next_time = Math::fmod(next_time, lifetime);
 
-	ParticleData *pdata=&particle_data[0];
+	ParticleData *pdata = &particle_data[0];
 	Vector3 attractor_positions[VS::MAX_PARTICLE_ATTRACTORS];
 
-	for(int i=0;i<p_system->attractor_count;i++) {
+	for (int i = 0; i < p_system->attractor_count; i++) {
 
-		attractor_positions[i]=p_transform.xform(p_system->attractors[i].pos);
+		attractor_positions[i] = p_transform.xform(p_system->attractors[i].pos);
 	}
 
+	for (int i = 0; i < particle_count; i++) {
 
-	for(int i=0;i<particle_count;i++) {
-
-		ParticleData &p=pdata[i];
+		ParticleData &p = pdata[i];
 
 		float restart_time = (i * lifetime / p_system->amount);
 
-		bool restart=false;
+		bool restart = false;
 
-		if ( next_time < particle_system_time ) {
+		if (next_time < particle_system_time) {
 
-			if (restart_time > particle_system_time || restart_time < next_time )
-				restart=true;
+			if (restart_time > particle_system_time || restart_time < next_time)
+				restart = true;
 
-		} else if (restart_time > particle_system_time && restart_time < next_time ) {
-			restart=true;
+		} else if (restart_time > particle_system_time && restart_time < next_time) {
+			restart = true;
 		}
 
 		if (restart) {
 
-
 			if (p_system->emitting) {
-				if (emission_point_count==0) { //use AABB
+				if (emission_point_count == 0) { //use AABB
 					if (p_system->local_coordinates)
-						p.pos = p_system->emission_half_extents * Vector3( _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed) );
+						p.pos = p_system->emission_half_extents * Vector3(_rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed));
 					else
-						p.pos = p_transform.xform( p_system->emission_half_extents * Vector3( _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed) ) );
+						p.pos = p_transform.xform(p_system->emission_half_extents * Vector3(_rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed)));
 				} else {
 					//use preset positions
 					if (p_system->local_coordinates)
-						p.pos = r[_irand_from_seed(&rand_seed)%emission_point_count];
+						p.pos = r[_irand_from_seed(&rand_seed) % emission_point_count];
 					else
-						p.pos = p_transform.xform( r[_irand_from_seed(&rand_seed)%emission_point_count] );
+						p.pos = p_transform.xform(r[_irand_from_seed(&rand_seed) % emission_point_count]);
 				}
 
+				float angle1 = _rand_from_seed(&rand_seed) * p_system->particle_vars[VS::PARTICLE_SPREAD] * Math_PI;
+				float angle2 = _rand_from_seed(&rand_seed) * 20.0 * Math_PI; // make it more random like
 
-				float angle1 = _rand_from_seed(&rand_seed)*p_system->particle_vars[VS::PARTICLE_SPREAD]*Math_PI;
-				float angle2 = _rand_from_seed(&rand_seed)*20.0*Math_PI; // make it more random like
-
-				Vector3 rot_xz=Vector3( Math::sin(angle1), 0.0, Math::cos(angle1) );
-				Vector3 rot = Vector3( Math::cos(angle2)*rot_xz.x,Math::sin(angle2)*rot_xz.x, rot_xz.z);
+				Vector3 rot_xz = Vector3(Math::sin(angle1), 0.0, Math::cos(angle1));
+				Vector3 rot = Vector3(Math::cos(angle2) * rot_xz.x, Math::sin(angle2) * rot_xz.x, rot_xz.z);
 
-				p.vel=(rot*p_system->particle_vars[VS::PARTICLE_LINEAR_VELOCITY]+rot*p_system->particle_randomness[VS::PARTICLE_LINEAR_VELOCITY]*_rand_from_seed(&rand_seed));
+				p.vel = (rot * p_system->particle_vars[VS::PARTICLE_LINEAR_VELOCITY] + rot * p_system->particle_randomness[VS::PARTICLE_LINEAR_VELOCITY] * _rand_from_seed(&rand_seed));
 				if (!p_system->local_coordinates)
-					p.vel=p_transform.basis.xform( p.vel );
+					p.vel = p_transform.basis.xform(p.vel);
 
-				p.vel+=p_system->emission_base_velocity;
+				p.vel += p_system->emission_base_velocity;
 
-				p.rot=p_system->particle_vars[VS::PARTICLE_INITIAL_ANGLE]+p_system->particle_randomness[VS::PARTICLE_INITIAL_ANGLE]*_rand_from_seed(&rand_seed);
-				p.active=true;
-				for(int r=0;r<PARTICLE_RANDOM_NUMBERS;r++)
-					p.random[r]=_rand_from_seed(&rand_seed);
+				p.rot = p_system->particle_vars[VS::PARTICLE_INITIAL_ANGLE] + p_system->particle_randomness[VS::PARTICLE_INITIAL_ANGLE] * _rand_from_seed(&rand_seed);
+				p.active = true;
+				for (int r = 0; r < PARTICLE_RANDOM_NUMBERS; r++)
+					p.random[r] = _rand_from_seed(&rand_seed);
 
 			} else {
 
-				p.pos=Vector3();
-				p.rot=0;
-				p.vel=Vector3();
-				p.active=false;
+				p.pos = Vector3();
+				p.rot = 0;
+				p.vel = Vector3();
+				p.active = false;
 			}
 
 		} else {
@@ -225,110 +216,100 @@ void ParticleSystemProcessSW::process(const ParticleSystemSW *p_system,const Tra
 
 			Vector3 force;
 			//apply gravity
-			force=p_system->gravity_normal * (p_system->particle_vars[VS::PARTICLE_GRAVITY]+(p_system->particle_randomness[VS::PARTICLE_GRAVITY]*p.random[0]));
+			force = p_system->gravity_normal * (p_system->particle_vars[VS::PARTICLE_GRAVITY] + (p_system->particle_randomness[VS::PARTICLE_GRAVITY] * p.random[0]));
 			//apply linear acceleration
-			force+=p.vel.normalized() * (p_system->particle_vars[VS::PARTICLE_LINEAR_ACCELERATION]+p_system->particle_randomness[VS::PARTICLE_LINEAR_ACCELERATION]*p.random[1]);
+			force += p.vel.normalized() * (p_system->particle_vars[VS::PARTICLE_LINEAR_ACCELERATION] + p_system->particle_randomness[VS::PARTICLE_LINEAR_ACCELERATION] * p.random[1]);
 			//apply radial acceleration
 			Vector3 org;
 			if (!p_system->local_coordinates)
-				org=p_transform.origin;
-			force+=(p.pos-org).normalized() * (p_system->particle_vars[VS::PARTICLE_RADIAL_ACCELERATION]+p_system->particle_randomness[VS::PARTICLE_RADIAL_ACCELERATION]*p.random[2]);
+				org = p_transform.origin;
+			force += (p.pos - org).normalized() * (p_system->particle_vars[VS::PARTICLE_RADIAL_ACCELERATION] + p_system->particle_randomness[VS::PARTICLE_RADIAL_ACCELERATION] * p.random[2]);
 			//apply tangential acceleration
-			force+=(p.pos-org).cross(p_system->gravity_normal).normalized() * (p_system->particle_vars[VS::PARTICLE_TANGENTIAL_ACCELERATION]+p_system->particle_randomness[VS::PARTICLE_TANGENTIAL_ACCELERATION]*p.random[3]);
+			force += (p.pos - org).cross(p_system->gravity_normal).normalized() * (p_system->particle_vars[VS::PARTICLE_TANGENTIAL_ACCELERATION] + p_system->particle_randomness[VS::PARTICLE_TANGENTIAL_ACCELERATION] * p.random[3]);
 			//apply attractor forces
-			for(int a=0;a<p_system->attractor_count;a++) {
+			for (int a = 0; a < p_system->attractor_count; a++) {
 
-				force+=(p.pos-attractor_positions[a]).normalized() * p_system->attractors[a].force;
+				force += (p.pos - attractor_positions[a]).normalized() * p_system->attractors[a].force;
 			}
 
-
-			p.vel+=force * p_time;
+			p.vel += force * p_time;
 			if (p_system->particle_vars[VS::PARTICLE_DAMPING]) {
 
 				float v = p.vel.length();
 				float damp = p_system->particle_vars[VS::PARTICLE_DAMPING] + p_system->particle_vars[VS::PARTICLE_DAMPING] * p_system->particle_randomness[VS::PARTICLE_DAMPING];
 				v -= damp * p_time;
-				if (v<0) {
-					p.vel=Vector3();
+				if (v < 0) {
+					p.vel = Vector3();
 				} else {
-					p.vel=p.vel.normalized() * v;
+					p.vel = p.vel.normalized() * v;
 				}
-
 			}
-			p.rot+=(p_system->particle_vars[VS::PARTICLE_ANGULAR_VELOCITY]+p_system->particle_randomness[VS::PARTICLE_ANGULAR_VELOCITY]*p.random[4]) *p_time;
-			p.pos+=p.vel * p_time;
+			p.rot += (p_system->particle_vars[VS::PARTICLE_ANGULAR_VELOCITY] + p_system->particle_randomness[VS::PARTICLE_ANGULAR_VELOCITY] * p.random[4]) * p_time;
+			p.pos += p.vel * p_time;
 		}
 	}
 
-	particle_system_time=Math::fmod( particle_system_time+p_time, lifetime );
-
-
+	particle_system_time = Math::fmod(particle_system_time + p_time, lifetime);
 }
 
 ParticleSystemProcessSW::ParticleSystemProcessSW() {
 
-	particle_system_time=0;
-	rand_seed=1234567;
-	valid=false;
+	particle_system_time = 0;
+	rand_seed = 1234567;
+	valid = false;
 }
 
-
 struct _ParticleSorterSW {
 
-
-	_FORCE_INLINE_ bool operator()(const ParticleSystemDrawInfoSW::ParticleDrawInfo *p_a,const ParticleSystemDrawInfoSW::ParticleDrawInfo *p_b) const {
+	_FORCE_INLINE_ bool operator()(const ParticleSystemDrawInfoSW::ParticleDrawInfo *p_a, const ParticleSystemDrawInfoSW::ParticleDrawInfo *p_b) const {
 
 		return p_a->d > p_b->d; // draw from further away to closest
 	}
 };
 
-void ParticleSystemDrawInfoSW::prepare(const ParticleSystemSW *p_system,const ParticleSystemProcessSW *p_process,const Transform& p_system_transform,const Transform& p_camera_transform) {
+void ParticleSystemDrawInfoSW::prepare(const ParticleSystemSW *p_system, const ParticleSystemProcessSW *p_process, const Transform &p_system_transform, const Transform &p_camera_transform) {
 
 	ERR_FAIL_COND(p_process->particle_data.size() != p_system->amount);
-	ERR_FAIL_COND(p_system->amount<=0 || p_system->amount>=ParticleSystemSW::MAX_PARTICLES);
+	ERR_FAIL_COND(p_system->amount <= 0 || p_system->amount >= ParticleSystemSW::MAX_PARTICLES);
 
-	const ParticleSystemProcessSW::ParticleData *pdata=&p_process->particle_data[0];
-	float time_pos=p_process->particle_system_time/p_system->particle_vars[VS::PARTICLE_LIFETIME];
+	const ParticleSystemProcessSW::ParticleData *pdata = &p_process->particle_data[0];
+	float time_pos = p_process->particle_system_time / p_system->particle_vars[VS::PARTICLE_LIFETIME];
 
 	ParticleSystemSW::ColorPhase cphase[VS::MAX_PARTICLE_COLOR_PHASES];
 
-	float last=-1;
-	int col_count=0;
+	float last = -1;
+	int col_count = 0;
 
-	for(int i=0;i<p_system->color_phase_count;i++) {
+	for (int i = 0; i < p_system->color_phase_count; i++) {
 
-		if (p_system->color_phases[i].pos<=last)
+		if (p_system->color_phases[i].pos <= last)
 			break;
-		cphase[i]=p_system->color_phases[i];
+		cphase[i] = p_system->color_phases[i];
 		col_count++;
 	}
 
-
-
-
-
 	Vector3 camera_z_axis = p_camera_transform.basis.get_axis(2);
 
-	for(int i=0;i<p_system->amount;i++) {
+	for (int i = 0; i < p_system->amount; i++) {
 
-		ParticleDrawInfo &pdi=draw_info[i];
-		pdi.data=&pdata[i];
-		pdi.transform.origin=pdi.data->pos;
+		ParticleDrawInfo &pdi = draw_info[i];
+		pdi.data = &pdata[i];
+		pdi.transform.origin = pdi.data->pos;
 		if (p_system->local_coordinates)
-			pdi.transform.origin=p_system_transform.xform(pdi.transform.origin);
+			pdi.transform.origin = p_system_transform.xform(pdi.transform.origin);
 
-		pdi.d=-camera_z_axis.dot(pdi.transform.origin);
+		pdi.d = -camera_z_axis.dot(pdi.transform.origin);
 
 		// adjust particle size, color and rotation
 
 		float time = ((float)i / p_system->amount);
-		if (time<time_pos)
-			time=time_pos-time;
+		if (time < time_pos)
+			time = time_pos - time;
 		else
-			time=(1.0-time)+time_pos;
+			time = (1.0 - time) + time_pos;
 
-		Vector3 up=p_camera_transform.basis.get_axis(1); // up determines the rotation
-		float up_scale=1.0;
+		Vector3 up = p_camera_transform.basis.get_axis(1); // up determines the rotation
+		float up_scale = 1.0;
 
 		if (p_system->height_from_velocity) {
 
@@ -336,47 +317,43 @@ void ParticleSystemDrawInfoSW::prepare(const ParticleSystemSW *p_system,const Pa
 			Vector3 cam_z = camera_z_axis.normalized();
 			float vc = Math::abs(veld.normalized().dot(cam_z));
 
-			if (vc<(1.0-CMP_EPSILON)) {
-				up = Plane(cam_z,0).project(veld).normalized();
-				float h = p_system->particle_vars[VS::PARTICLE_HEIGHT]+p_system->particle_randomness[VS::PARTICLE_HEIGHT]*pdi.data->random[7];
+			if (vc < (1.0 - CMP_EPSILON)) {
+				up = Plane(cam_z, 0).project(veld).normalized();
+				float h = p_system->particle_vars[VS::PARTICLE_HEIGHT] + p_system->particle_randomness[VS::PARTICLE_HEIGHT] * pdi.data->random[7];
 				float velh = veld.length();
-				h+=velh*(p_system->particle_vars[VS::PARTICLE_HEIGHT_SPEED_SCALE]+p_system->particle_randomness[VS::PARTICLE_HEIGHT_SPEED_SCALE]*pdi.data->random[7]);
-
+				h += velh * (p_system->particle_vars[VS::PARTICLE_HEIGHT_SPEED_SCALE] + p_system->particle_randomness[VS::PARTICLE_HEIGHT_SPEED_SCALE] * pdi.data->random[7]);
 
-				up_scale=Math::lerp(1.0,h,(1.0-vc));
+				up_scale = Math::lerp(1.0, h, (1.0 - vc));
 			}
 
 		} else if (pdi.data->rot) {
 
-			up.rotate(camera_z_axis,pdi.data->rot);
+			up.rotate(camera_z_axis, pdi.data->rot);
 		}
 
 		{
 			// matrix
-			Vector3 v_z = (p_camera_transform.origin-pdi.transform.origin).normalized();
-//			Vector3 v_z = (p_camera_transform.origin-pdi.data->pos).normalized();
+			Vector3 v_z = (p_camera_transform.origin - pdi.transform.origin).normalized();
+			//			Vector3 v_z = (p_camera_transform.origin-pdi.data->pos).normalized();
 			Vector3 v_y = up;
 			Vector3 v_x = v_y.cross(v_z);
 			v_y = v_z.cross(v_x);
 			v_x.normalize();
 			v_y.normalize();
 
-
 			float initial_scale, final_scale;
-			initial_scale = p_system->particle_vars[VS::PARTICLE_INITIAL_SIZE]+p_system->particle_randomness[VS::PARTICLE_INITIAL_SIZE]*pdi.data->random[5];
-			final_scale = p_system->particle_vars[VS::PARTICLE_FINAL_SIZE]+p_system->particle_randomness[VS::PARTICLE_FINAL_SIZE]*pdi.data->random[6];
+			initial_scale = p_system->particle_vars[VS::PARTICLE_INITIAL_SIZE] + p_system->particle_randomness[VS::PARTICLE_INITIAL_SIZE] * pdi.data->random[5];
+			final_scale = p_system->particle_vars[VS::PARTICLE_FINAL_SIZE] + p_system->particle_randomness[VS::PARTICLE_FINAL_SIZE] * pdi.data->random[6];
 			float scale = initial_scale + time * (final_scale - initial_scale);
 
-			pdi.transform.basis.set_axis(0,v_x * scale);
-			pdi.transform.basis.set_axis(1,v_y * scale * up_scale);
-			pdi.transform.basis.set_axis(2,v_z * scale);
+			pdi.transform.basis.set_axis(0, v_x * scale);
+			pdi.transform.basis.set_axis(1, v_y * scale * up_scale);
+			pdi.transform.basis.set_axis(2, v_z * scale);
 		}
 
+		int cpos = 0;
 
-
-		int cpos=0;
-
-		while(cpos<col_count) {
+		while (cpos < col_count) {
 
 			if (cphase[cpos].pos > time)
 				break;
@@ -385,28 +362,23 @@ void ParticleSystemDrawInfoSW::prepare(const ParticleSystemSW *p_system,const Pa
 
 		cpos--;
 
-
-		if (cpos==-1)
-			pdi.color=Color(1,1,1,1);
+		if (cpos == -1)
+			pdi.color = Color(1, 1, 1, 1);
 		else {
-			if (cpos==col_count-1)
-				pdi.color=cphase[cpos].color;
+			if (cpos == col_count - 1)
+				pdi.color = cphase[cpos].color;
 			else {
-				float diff = (cphase[cpos+1].pos-cphase[cpos].pos);
-				if (diff>0)
-					pdi.color=cphase[cpos].color.linear_interpolate(cphase[cpos+1].color, (time - cphase[cpos].pos) / diff );
+				float diff = (cphase[cpos + 1].pos - cphase[cpos].pos);
+				if (diff > 0)
+					pdi.color = cphase[cpos].color.linear_interpolate(cphase[cpos + 1].color, (time - cphase[cpos].pos) / diff);
 				else
-					pdi.color=cphase[cpos+1].color;
+					pdi.color = cphase[cpos + 1].color;
 			}
 		}
 
-
-		draw_info_order[i]=&pdi;
-
+		draw_info_order[i] = &pdi;
 	}
 
-
-	SortArray<ParticleDrawInfo*,_ParticleSorterSW> particle_sort;
-	particle_sort.sort(&draw_info_order[0],p_system->amount);
-
+	SortArray<ParticleDrawInfo *, _ParticleSorterSW> particle_sort;
+	particle_sort.sort(&draw_info_order[0], p_system->amount);
 }
diff --git a/servers/visual/particle_system_sw.h b/servers/visual/particle_system_sw.h
index 8f4a5f8ec..a3878b83d 100644
--- a/servers/visual/particle_system_sw.h
+++ b/servers/visual/particle_system_sw.h
@@ -38,7 +38,7 @@
 struct ParticleSystemSW {
 	enum {
 
-		MAX_PARTICLES=1024
+		MAX_PARTICLES = 1024
 	};
 
 	float particle_vars[VS::PARTICLE_VAR_MAX];
@@ -59,13 +59,15 @@ struct ParticleSystemSW {
 
 		float pos;
 		Color color;
-		ColorPhase() { pos=1.0; color=Color(0.0,0.0,1.0,1.0); }
+		ColorPhase() {
+			pos = 1.0;
+			color = Color(0.0, 0.0, 1.0, 1.0);
+		}
 	};
 
 	int color_phase_count;
 	ColorPhase color_phases[VS::MAX_PARTICLE_COLOR_PHASES];
 
-
 	struct Attractor {
 
 		Vector3 pos;
@@ -75,13 +77,10 @@ struct ParticleSystemSW {
 	int attractor_count;
 	Attractor attractors[VS::MAX_PARTICLE_ATTRACTORS];
 
-
 	ParticleSystemSW();
 	~ParticleSystemSW();
-
 };
 
-
 struct ParticleSystemProcessSW {
 
 	enum {
@@ -96,16 +95,18 @@ struct ParticleSystemProcessSW {
 		bool active;
 		float random[PARTICLE_RANDOM_NUMBERS];
 
-		ParticleData() { active=0; rot=0; }
+		ParticleData() {
+			active = 0;
+			rot = 0;
+		}
 	};
 
-
 	bool valid;
 	float particle_system_time;
 	uint32_t rand_seed;
 	Vector<ParticleData> particle_data;
 
-	void process(const ParticleSystemSW *p_system,const Transform& p_transform,float p_time);
+	void process(const ParticleSystemSW *p_system, const Transform &p_transform, float p_time);
 
 	ParticleSystemProcessSW();
 };
@@ -118,14 +119,12 @@ struct ParticleSystemDrawInfoSW {
 		float d;
 		Transform transform;
 		Color color;
-
 	};
 
 	ParticleDrawInfo draw_info[ParticleSystemSW::MAX_PARTICLES];
 	ParticleDrawInfo *draw_info_order[ParticleSystemSW::MAX_PARTICLES];
 
-	void prepare(const ParticleSystemSW *p_system,const ParticleSystemProcessSW *p_process,const Transform& p_system_transform,const Transform& p_camera_transform);
-
+	void prepare(const ParticleSystemSW *p_system, const ParticleSystemProcessSW *p_process, const Transform &p_system_transform, const Transform &p_camera_transform);
 };
 
 #endif
diff --git a/servers/visual/rasterizer.cpp b/servers/visual/rasterizer.cpp
index e5e135fd3..69a6030f5 100644
--- a/servers/visual/rasterizer.cpp
+++ b/servers/visual/rasterizer.cpp
@@ -27,21 +27,20 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "rasterizer.h"
-#include "print_string.h"
 #include "os/os.h"
+#include "print_string.h"
 
 RID Rasterizer::create_default_material() {
 
 	return material_create();
 }
 
-
 /* Fixed MAterial SHADER API */
 
-RID Rasterizer::_create_shader(const FixedMaterialShaderKey& p_key) {
+RID Rasterizer::_create_shader(const FixedMaterialShaderKey &p_key) {
 
-	ERR_FAIL_COND_V(!p_key.valid,RID());
-	Map<FixedMaterialShaderKey,FixedMaterialShader>::Element *E=fixed_material_shaders.find(p_key);
+	ERR_FAIL_COND_V(!p_key.valid, RID());
+	Map<FixedMaterialShaderKey, FixedMaterialShader>::Element *E = fixed_material_shaders.find(p_key);
 
 	if (E) {
 		E->get().refcount++;
@@ -51,200 +50,192 @@ RID Rasterizer::_create_shader(const FixedMaterialShaderKey& p_key) {
 	uint64_t t = OS::get_singleton()->get_ticks_usec();
 
 	FixedMaterialShader fms;
-	fms.refcount=1;
-	fms.shader=shader_create();
+	fms.refcount = 1;
+	fms.shader = shader_create();
 
 	//create shader code
 
-
-	int texcoords_used=0;
+	int texcoords_used = 0;
 	String code;
 
-	static const char* _uv_str[4]={"UV","uv_xform","UV2","uv_sphere"};
-#define _TEXUVSTR(m_idx) String( _uv_str[(p_key.texcoord_mask>>(m_idx*2))&0x3] )
-
+	static const char *_uv_str[4] = { "UV", "uv_xform", "UV2", "uv_sphere" };
+#define _TEXUVSTR(m_idx) String(_uv_str[(p_key.texcoord_mask >> (m_idx * 2)) & 0x3])
 
 	if (p_key.use_pointsize) {
 
-		code+="UV=POINT_COORD;\n";
+		code += "UV=POINT_COORD;\n";
 	}
 
+	for (int i = 0; i < VS::FIXED_MATERIAL_PARAM_MAX; i++) {
 
-	for(int i=0;i<VS::FIXED_MATERIAL_PARAM_MAX;i++) {
-
-		if (p_key.texture_mask&(1<<i))
-			texcoords_used|=(1<<((p_key.texcoord_mask>>(i*2))&0x3));
+		if (p_key.texture_mask & (1 << i))
+			texcoords_used |= (1 << ((p_key.texcoord_mask >> (i * 2)) & 0x3));
 	}
 
-	if (texcoords_used&(1<<VS::FIXED_MATERIAL_TEXCOORD_UV_TRANSFORM)) {
+	if (texcoords_used & (1 << VS::FIXED_MATERIAL_TEXCOORD_UV_TRANSFORM)) {
 
-		code+="uniform mat4 fmp_uv_xform;\n";
-		code+="vec2 uv_xform = (fmp_uv_xform * vec4(UV,0,1)).xy;\n";
+		code += "uniform mat4 fmp_uv_xform;\n";
+		code += "vec2 uv_xform = (fmp_uv_xform * vec4(UV,0,1)).xy;\n";
 	}
 
 	/* HANDLE NORMAL MAPPING */
 
-
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_NORMAL)) {
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_NORMAL)) {
 
 		String scode;
-		scode+="uniform float fmp_normal;\n";
-		scode+="uniform texture fmp_normal_tex;\n";
+		scode += "uniform float fmp_normal;\n";
+		scode += "uniform texture fmp_normal_tex;\n";
 		String uv_str;
-		if (((p_key.texcoord_mask>>(VS::FIXED_MATERIAL_PARAM_NORMAL*2))&0x3)==VS::FIXED_MATERIAL_TEXCOORD_SPHERE) {
-			uv_str="uv"; //sorry not supported
+		if (((p_key.texcoord_mask >> (VS::FIXED_MATERIAL_PARAM_NORMAL * 2)) & 0x3) == VS::FIXED_MATERIAL_TEXCOORD_SPHERE) {
+			uv_str = "uv"; //sorry not supported
 		} else {
-			uv_str=_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_NORMAL);
+			uv_str = _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_NORMAL);
 		}
 		if (p_key.use_xy_normalmap) {
-			scode+="vec2 ywnormal=tex( fmp_normal_tex,"+uv_str+").wy * vec2(2.0,2.0) - vec2(1.0,1.0);\n";
-			scode+="NORMALMAP=vec3(ywnormal,sqrt(1 - (ywnormal.x * ywnormal.x) - (ywnormal.y * ywnormal.y) ));\n";
+			scode += "vec2 ywnormal=tex( fmp_normal_tex," + uv_str + ").wy * vec2(2.0,2.0) - vec2(1.0,1.0);\n";
+			scode += "NORMALMAP=vec3(ywnormal,sqrt(1 - (ywnormal.x * ywnormal.x) - (ywnormal.y * ywnormal.y) ));\n";
 		} else {
-			scode+="NORMALMAP=tex( fmp_normal_tex,"+uv_str+").xyz * vec3(2.0,2.0,1.0) - vec3(1.0,1.0,0.0);\n";
+			scode += "NORMALMAP=tex( fmp_normal_tex," + uv_str + ").xyz * vec3(2.0,2.0,1.0) - vec3(1.0,1.0,0.0);\n";
 		}
-		scode+="NORMALMAP_DEPTH=fmp_normal;\n";
+		scode += "NORMALMAP_DEPTH=fmp_normal;\n";
 
-		code+=scode;
+		code += scode;
 	}
 
 	//handle sphere uv if used, do it here because it needs the normal, which may be transformed by a normal map
 
-	if (texcoords_used&(1<<VS::FIXED_MATERIAL_TEXCOORD_SPHERE)) {
+	if (texcoords_used & (1 << VS::FIXED_MATERIAL_TEXCOORD_SPHERE)) {
 
 		String tcode;
-		tcode="vec3 eye_normal = normalize(VERTEX);\n";
-		tcode+="vec3 ref = (eye_normal - 2.0*dot(NORMAL, eye_normal)*NORMAL);\n";
-		tcode+="ref.z+=1.0;\n";
-		tcode+="vec2 uv_sphere = ref.xy*vec2(0.5,0.0-0.5)+vec2(0.5,0.0-0.5);\n";
-		code+=tcode;
+		tcode = "vec3 eye_normal = normalize(VERTEX);\n";
+		tcode += "vec3 ref = (eye_normal - 2.0*dot(NORMAL, eye_normal)*NORMAL);\n";
+		tcode += "ref.z+=1.0;\n";
+		tcode += "vec2 uv_sphere = ref.xy*vec2(0.5,0.0-0.5)+vec2(0.5,0.0-0.5);\n";
+		code += tcode;
 	}
 
 	/* HANDLE DIFFUSE LIGHTING */
 
-	code+="uniform color fmp_diffuse;\n";
-	code+="color diffuse=fmp_diffuse;\n";
+	code += "uniform color fmp_diffuse;\n";
+	code += "color diffuse=fmp_diffuse;\n";
 
 	if (p_key.use_color_array)
-		code+="diffuse*=COLOR;\n";
-
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_DIFFUSE)) {
+		code += "diffuse*=COLOR;\n";
 
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_DIFFUSE)) {
 
-		code+="uniform texture fmp_diffuse_tex;\n";
-		code+="diffuse*=tex( fmp_diffuse_tex,"+_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_DIFFUSE)+");\n";
+		code += "uniform texture fmp_diffuse_tex;\n";
+		code += "diffuse*=tex( fmp_diffuse_tex," + _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_DIFFUSE) + ");\n";
 	}
 
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_DETAIL)) {
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_DETAIL)) {
 
 		String dcode;
-		dcode+="uniform texture fmp_detail_tex;\n";
-		dcode+="uniform float fmp_detail;\n";
-		dcode+="color detail=tex( fmp_detail_tex,"+_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_DETAIL)+");\n";
+		dcode += "uniform texture fmp_detail_tex;\n";
+		dcode += "uniform float fmp_detail;\n";
+		dcode += "color detail=tex( fmp_detail_tex," + _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_DETAIL) + ");\n";
 		//aways mix
-		dcode+="diffuse=vec4(mix(diffuse.rgb,detail.rgb,detail.a*fmp_detail),diffuse.a);\n";
+		dcode += "diffuse=vec4(mix(diffuse.rgb,detail.rgb,detail.a*fmp_detail),diffuse.a);\n";
 
-		code+=dcode;
+		code += dcode;
 	}
 
 	if (p_key.use_alpha) {
-		code+="DIFFUSE_ALPHA=diffuse;\n";
+		code += "DIFFUSE_ALPHA=diffuse;\n";
 		if (p_key.discard_alpha) {
-			code+="DISCARD=diffuse.a<0.5;\n";
+			code += "DISCARD=diffuse.a<0.5;\n";
 		}
 	} else {
-		code+="DIFFUSE=diffuse.rgb;\n";
+		code += "DIFFUSE=diffuse.rgb;\n";
 	}
 
 	/* HANDLE SPECULAR LIGHTING */
 
-	code+="uniform color fmp_specular;\n";
-	code+="color specular=fmp_specular;\n";
+	code += "uniform color fmp_specular;\n";
+	code += "color specular=fmp_specular;\n";
 
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_SPECULAR)) {
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_SPECULAR)) {
 
 		String scode;
-		scode+="uniform texture fmp_specular_tex;\n";
-		scode+="specular*=tex( fmp_specular_tex,"+_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_SPECULAR)+");\n";
-		code+=scode;
+		scode += "uniform texture fmp_specular_tex;\n";
+		scode += "specular*=tex( fmp_specular_tex," + _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_SPECULAR) + ");\n";
+		code += scode;
 	}
 
-	code+="SPECULAR=specular.rgb;\n";
+	code += "SPECULAR=specular.rgb;\n";
 
-	code+="uniform float fmp_specular_exp;\n";
-	code+="float specular_exp=fmp_specular_exp;\n";
+	code += "uniform float fmp_specular_exp;\n";
+	code += "float specular_exp=fmp_specular_exp;\n";
 
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP)) {
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP)) {
 
 		String scode;
-		scode+="uniform texture fmp_specular_exp_tex;\n";
-		scode+="specular_exp*=tex( fmp_specular_exp_tex,"+_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP)+").r;\n";
-		code+=scode;
+		scode += "uniform texture fmp_specular_exp_tex;\n";
+		scode += "specular_exp*=tex( fmp_specular_exp_tex," + _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP) + ").r;\n";
+		code += scode;
 	}
 
-	code+="SPEC_EXP=specular_exp;\n";
+	code += "SPEC_EXP=specular_exp;\n";
 
 	/* HANDLE EMISSION LIGHTING */
 
-	code+="uniform color fmp_emission;\n";
-	code+="color emission=fmp_emission;\n";
+	code += "uniform color fmp_emission;\n";
+	code += "color emission=fmp_emission;\n";
 
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_EMISSION)) {
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_EMISSION)) {
 
 		String scode;
-		scode+="uniform texture fmp_emission_tex;\n";
-		scode+="emission*=tex( fmp_emission_tex,"+_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_EMISSION)+");\n";
-		code+=scode;
+		scode += "uniform texture fmp_emission_tex;\n";
+		scode += "emission*=tex( fmp_emission_tex," + _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_EMISSION) + ");\n";
+		code += scode;
 	}
 
-	code+="EMISSION=emission.rgb;\n";
-
+	code += "EMISSION=emission.rgb;\n";
 
 	/* HANDLE GLOW */
 
-	code+="uniform float fmp_glow;\n";
-	code+="float glow=fmp_glow;\n";
+	code += "uniform float fmp_glow;\n";
+	code += "float glow=fmp_glow;\n";
 
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_GLOW)) {
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_GLOW)) {
 
 		String scode;
-		scode+="uniform texture fmp_glow_tex;\n";
-		scode+="glow*=tex( fmp_glow_tex,"+_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_GLOW)+").r;\n";
-		code+=scode;
+		scode += "uniform texture fmp_glow_tex;\n";
+		scode += "glow*=tex( fmp_glow_tex," + _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_GLOW) + ").r;\n";
+		code += scode;
 	}
 
-	code+="GLOW=glow;\n";
+	code += "GLOW=glow;\n";
 
-	if (p_key.texture_mask&(1<<VS::FIXED_MATERIAL_PARAM_SHADE_PARAM)) {
+	if (p_key.texture_mask & (1 << VS::FIXED_MATERIAL_PARAM_SHADE_PARAM)) {
 
 		String scode;
-		scode+="uniform texture fmp_shade_param_tex;\n";
-		scode+="SHADE_PARAM=tex( fmp_shade_param_tex,"+_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_SHADE_PARAM)+").r;\n";
-		code+=scode;
+		scode += "uniform texture fmp_shade_param_tex;\n";
+		scode += "SHADE_PARAM=tex( fmp_shade_param_tex," + _TEXUVSTR(VS::FIXED_MATERIAL_PARAM_SHADE_PARAM) + ").r;\n";
+		code += scode;
 	} else {
 
 		String scode;
-		scode+="uniform float fmp_shade_param;\n";
-		scode+="SHADE_PARAM=fmp_shade_param;\n";
-		code+=scode;
-
+		scode += "uniform float fmp_shade_param;\n";
+		scode += "SHADE_PARAM=fmp_shade_param;\n";
+		code += scode;
 	}
 
-
 	//print_line("**FRAGMENT SHADER GENERATED code: \n"+code);
 
 	String vcode;
-	vcode="uniform float "+_fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP]+";\n";
-	vcode+="SPEC_EXP="+_fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP]+";\n";
+	vcode = "uniform float " + _fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP] + ";\n";
+	vcode += "SPEC_EXP=" + _fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP] + ";\n";
 	if (p_key.use_pointsize) {
 
-		vcode+="uniform float "+_fixed_material_point_size_name+";\n";
-		vcode+="POINT_SIZE="+_fixed_material_point_size_name+";\n";
-//		vcode+="POINT_SIZE=10.0;\n";
+		vcode += "uniform float " + _fixed_material_point_size_name + ";\n";
+		vcode += "POINT_SIZE=" + _fixed_material_point_size_name + ";\n";
+		//		vcode+="POINT_SIZE=10.0;\n";
 	}
 
 	String lcode;
 
-	switch(p_key.light_shader) {
+	switch (p_key.light_shader) {
 
 		case VS::FIXED_MATERIAL_LIGHT_SHADER_LAMBERT: {
 			//do nothing
@@ -252,324 +243,310 @@ RID Rasterizer::_create_shader(const FixedMaterialShaderKey& p_key) {
 		} break;
 		case VS::FIXED_MATERIAL_LIGHT_SHADER_WRAP: {
 
-			lcode+="float NdotL = max(0.0,((dot( NORMAL, LIGHT_DIR )+SHADE_PARAM)/(1.0+SHADE_PARAM)));";
-			lcode+="vec3 half_vec = normalize(LIGHT_DIR + EYE_VEC);";
-			lcode+="float eye_light = max(dot(NORMAL, half_vec),0.0);";
-			lcode+="LIGHT = LIGHT_DIFFUSE * DIFFUSE * NdotL;";
-			lcode+="if (NdotL > 0.0) {";
-			lcode+="\tLIGHT+=LIGHT_SPECULAR * SPECULAR * pow( eye_light, SPECULAR_EXP );";
-			lcode+="};";
+			lcode += "float NdotL = max(0.0,((dot( NORMAL, LIGHT_DIR )+SHADE_PARAM)/(1.0+SHADE_PARAM)));";
+			lcode += "vec3 half_vec = normalize(LIGHT_DIR + EYE_VEC);";
+			lcode += "float eye_light = max(dot(NORMAL, half_vec),0.0);";
+			lcode += "LIGHT = LIGHT_DIFFUSE * DIFFUSE * NdotL;";
+			lcode += "if (NdotL > 0.0) {";
+			lcode += "\tLIGHT+=LIGHT_SPECULAR * SPECULAR * pow( eye_light, SPECULAR_EXP );";
+			lcode += "};";
 
 		} break;
 		case VS::FIXED_MATERIAL_LIGHT_SHADER_VELVET: {
-			lcode+="float NdotL = max(0.0,dot( NORMAL, LIGHT_DIR ));";
-			lcode+="vec3 half_vec = normalize(LIGHT_DIR + EYE_VEC);";
-			lcode+="float eye_light = max(dot(NORMAL, half_vec),0.0);";
-			lcode+="LIGHT = LIGHT_DIFFUSE * DIFFUSE * NdotL;";
-			lcode+="float rim = (1.0-abs(dot(NORMAL,vec3(0,0,1))))*SHADE_PARAM;";
-			lcode+="LIGHT += LIGHT_DIFFUSE * DIFFUSE * rim;";
-			lcode+="if (NdotL > 0.0) {";
-			lcode+="\tLIGHT+=LIGHT_SPECULAR * SPECULAR * pow( eye_light, SPECULAR_EXP );";
-			lcode+="};";
-
+			lcode += "float NdotL = max(0.0,dot( NORMAL, LIGHT_DIR ));";
+			lcode += "vec3 half_vec = normalize(LIGHT_DIR + EYE_VEC);";
+			lcode += "float eye_light = max(dot(NORMAL, half_vec),0.0);";
+			lcode += "LIGHT = LIGHT_DIFFUSE * DIFFUSE * NdotL;";
+			lcode += "float rim = (1.0-abs(dot(NORMAL,vec3(0,0,1))))*SHADE_PARAM;";
+			lcode += "LIGHT += LIGHT_DIFFUSE * DIFFUSE * rim;";
+			lcode += "if (NdotL > 0.0) {";
+			lcode += "\tLIGHT+=LIGHT_SPECULAR * SPECULAR * pow( eye_light, SPECULAR_EXP );";
+			lcode += "};";
 
 		} break;
 		case VS::FIXED_MATERIAL_LIGHT_SHADER_TOON: {
 
-			lcode+="float NdotL = dot( NORMAL, LIGHT_DIR );";
-			lcode+="vec3 light_ref = reflect( LIGHT_DIR, NORMAL );";
-			lcode+="float eye_light = clamp( dot( light_ref, vec3(0,0,0)-EYE_VEC), 0.0, 1.0 );";
-			lcode+="float NdotL_diffuse = smoothstep( max( SHADE_PARAM-0.05, 0.0-1.0), min( SHADE_PARAM+0.05, 1.0), NdotL );";
-			lcode+="float spec_radius=clamp((1.0-(SPECULAR_EXP/64.0)),0.0,1.0);";
-			lcode+="float NdotL_specular = smoothstep( max( spec_radius-0.05, 0.0), min( spec_radius+0.05, 1.0), eye_light )*max(NdotL,0);";
-			lcode+="LIGHT = NdotL_diffuse * LIGHT_DIFFUSE*DIFFUSE + NdotL_specular * LIGHT_SPECULAR*SPECULAR;";
+			lcode += "float NdotL = dot( NORMAL, LIGHT_DIR );";
+			lcode += "vec3 light_ref = reflect( LIGHT_DIR, NORMAL );";
+			lcode += "float eye_light = clamp( dot( light_ref, vec3(0,0,0)-EYE_VEC), 0.0, 1.0 );";
+			lcode += "float NdotL_diffuse = smoothstep( max( SHADE_PARAM-0.05, 0.0-1.0), min( SHADE_PARAM+0.05, 1.0), NdotL );";
+			lcode += "float spec_radius=clamp((1.0-(SPECULAR_EXP/64.0)),0.0,1.0);";
+			lcode += "float NdotL_specular = smoothstep( max( spec_radius-0.05, 0.0), min( spec_radius+0.05, 1.0), eye_light )*max(NdotL,0);";
+			lcode += "LIGHT = NdotL_diffuse * LIGHT_DIFFUSE*DIFFUSE + NdotL_specular * LIGHT_SPECULAR*SPECULAR;";
 
 		} break;
-
 	}
 
 	//print_line("**VERTEX SHADER GENERATED code: \n"+vcode);
 
-	double tf = (OS::get_singleton()->get_ticks_usec()-t)/1000.0;
-//	print_line("generate: "+rtos(tf));
+	double tf = (OS::get_singleton()->get_ticks_usec() - t) / 1000.0;
+	//	print_line("generate: "+rtos(tf));
 
-	shader_set_code(fms.shader,vcode,code,lcode,0,0);
+	shader_set_code(fms.shader, vcode, code, lcode, 0, 0);
 
-	fixed_material_shaders[p_key]=fms;
+	fixed_material_shaders[p_key] = fms;
 	return fms.shader;
 }
 
-void Rasterizer::_free_shader(const FixedMaterialShaderKey& p_key) {
+void Rasterizer::_free_shader(const FixedMaterialShaderKey &p_key) {
 
-	if (p_key.valid==0)
+	if (p_key.valid == 0)
 		return; //not a valid key
 
-	Map<FixedMaterialShaderKey,FixedMaterialShader>::Element *E=fixed_material_shaders.find(p_key);
+	Map<FixedMaterialShaderKey, FixedMaterialShader>::Element *E = fixed_material_shaders.find(p_key);
 
 	ERR_FAIL_COND(!E);
 	E->get().refcount--;
-	if (E->get().refcount==0) {
+	if (E->get().refcount == 0) {
 		free(E->get().shader);
 		fixed_material_shaders.erase(E);
 	}
-
 }
 
-
 void Rasterizer::fixed_material_set_flag(RID p_material, VS::FixedMaterialFlags p_flag, bool p_enabled) {
 
-
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 	ERR_FAIL_COND(!E);
-	FixedMaterial &fm=*E->get();
+	FixedMaterial &fm = *E->get();
 
-	switch(p_flag) {
+	switch (p_flag) {
 
-		case VS::FIXED_MATERIAL_FLAG_USE_ALPHA: fm.use_alpha=p_enabled; break;
-		case VS::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY: fm.use_color_array=p_enabled; break;
-		case VS::FIXED_MATERIAL_FLAG_USE_POINT_SIZE: fm.use_pointsize=p_enabled; break;
-		case VS::FIXED_MATERIAL_FLAG_DISCARD_ALPHA: fm.discard_alpha=p_enabled; break;
-		case VS::FIXED_MATERIAL_FLAG_USE_XY_NORMALMAP: fm.use_xy_normalmap=p_enabled; break;
+		case VS::FIXED_MATERIAL_FLAG_USE_ALPHA: fm.use_alpha = p_enabled; break;
+		case VS::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY: fm.use_color_array = p_enabled; break;
+		case VS::FIXED_MATERIAL_FLAG_USE_POINT_SIZE: fm.use_pointsize = p_enabled; break;
+		case VS::FIXED_MATERIAL_FLAG_DISCARD_ALPHA: fm.discard_alpha = p_enabled; break;
+		case VS::FIXED_MATERIAL_FLAG_USE_XY_NORMALMAP: fm.use_xy_normalmap = p_enabled; break;
 	}
 
 	if (!fm.dirty_list.in_list())
-		fixed_material_dirty_list.add( &fm.dirty_list );
-
+		fixed_material_dirty_list.add(&fm.dirty_list);
 }
 
-bool Rasterizer::fixed_material_get_flag(RID p_material, VS::FixedMaterialFlags p_flag) const{
-
-	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
-	ERR_FAIL_COND_V(!E,false);
-	const FixedMaterial &fm=*E->get();
-	switch(p_flag) {
+bool Rasterizer::fixed_material_get_flag(RID p_material, VS::FixedMaterialFlags p_flag) const {
 
-		case VS::FIXED_MATERIAL_FLAG_USE_ALPHA: return fm.use_alpha;; break;
-		case VS::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY: return fm.use_color_array;; break;
-		case VS::FIXED_MATERIAL_FLAG_USE_POINT_SIZE: return fm.use_pointsize;; break;
-		case VS::FIXED_MATERIAL_FLAG_DISCARD_ALPHA: return fm.discard_alpha;; break;
-		case VS::FIXED_MATERIAL_FLAG_USE_XY_NORMALMAP: return fm.use_xy_normalmap;; break;
+	const Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E, false);
+	const FixedMaterial &fm = *E->get();
+	switch (p_flag) {
 
+		case VS::FIXED_MATERIAL_FLAG_USE_ALPHA:
+			return fm.use_alpha;
+			;
+			break;
+		case VS::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY:
+			return fm.use_color_array;
+			;
+			break;
+		case VS::FIXED_MATERIAL_FLAG_USE_POINT_SIZE:
+			return fm.use_pointsize;
+			;
+			break;
+		case VS::FIXED_MATERIAL_FLAG_DISCARD_ALPHA:
+			return fm.discard_alpha;
+			;
+			break;
+		case VS::FIXED_MATERIAL_FLAG_USE_XY_NORMALMAP:
+			return fm.use_xy_normalmap;
+			;
+			break;
 	}
 
-
 	return false;
 }
 
-
 RID Rasterizer::fixed_material_create() {
 
 	RID mat = material_create();
-	fixed_materials[mat]=memnew( FixedMaterial() );
-	FixedMaterial &fm=*fixed_materials[mat];
-	fm.self=mat;
+	fixed_materials[mat] = memnew(FixedMaterial());
+	FixedMaterial &fm = *fixed_materials[mat];
+	fm.self = mat;
 	fm.get_key();
-	material_set_flag(mat,VS::MATERIAL_FLAG_COLOR_ARRAY_SRGB,true);
-	for(int i=0;i<VS::FIXED_MATERIAL_PARAM_MAX;i++) {
+	material_set_flag(mat, VS::MATERIAL_FLAG_COLOR_ARRAY_SRGB, true);
+	for (int i = 0; i < VS::FIXED_MATERIAL_PARAM_MAX; i++) {
 
-		material_set_param(mat,_fixed_material_param_names[i],fm.param[i]); //must be there
+		material_set_param(mat, _fixed_material_param_names[i], fm.param[i]); //must be there
 	}
 	fixed_material_dirty_list.add(&fm.dirty_list);
 	//print_line("FMC: "+itos(mat.get_id()));
 	return mat;
 }
 
+void Rasterizer::fixed_material_set_parameter(RID p_material, VS::FixedMaterialParam p_parameter, const Variant &p_value) {
 
-
-
-void Rasterizer::fixed_material_set_parameter(RID p_material, VS::FixedMaterialParam p_parameter, const Variant& p_value){
-
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 	ERR_FAIL_COND(!E);
-	FixedMaterial &fm=*E->get();
-	RID material=E->key();
-	ERR_FAIL_INDEX(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX);
+	FixedMaterial &fm = *E->get();
+	RID material = E->key();
+	ERR_FAIL_INDEX(p_parameter, VS::FIXED_MATERIAL_PARAM_MAX);
 
-	if ((p_parameter==VS::FIXED_MATERIAL_PARAM_DIFFUSE || p_parameter==VS::FIXED_MATERIAL_PARAM_SPECULAR || p_parameter==VS::FIXED_MATERIAL_PARAM_EMISSION)) {
+	if ((p_parameter == VS::FIXED_MATERIAL_PARAM_DIFFUSE || p_parameter == VS::FIXED_MATERIAL_PARAM_SPECULAR || p_parameter == VS::FIXED_MATERIAL_PARAM_EMISSION)) {
 
-		if (p_value.get_type()!=Variant::COLOR) {
-			ERR_EXPLAIN(String(_fixed_material_param_names[p_parameter])+" expects Color");
+		if (p_value.get_type() != Variant::COLOR) {
+			ERR_EXPLAIN(String(_fixed_material_param_names[p_parameter]) + " expects Color");
 			ERR_FAIL();
 		}
 	} else {
 
 		if (!p_value.is_num()) {
-			ERR_EXPLAIN(String(_fixed_material_param_names[p_parameter])+" expects scalar");
+			ERR_EXPLAIN(String(_fixed_material_param_names[p_parameter]) + " expects scalar");
 			ERR_FAIL();
 		}
 	}
 
-	fm.param[p_parameter]=p_value;
-	VS::get_singleton()->material_set_param(material,_fixed_material_param_names[p_parameter],p_value);
-
-
+	fm.param[p_parameter] = p_value;
+	VS::get_singleton()->material_set_param(material, _fixed_material_param_names[p_parameter], p_value);
 }
-Variant Rasterizer::fixed_material_get_parameter(RID p_material,VS::FixedMaterialParam p_parameter) const{
+Variant Rasterizer::fixed_material_get_parameter(RID p_material, VS::FixedMaterialParam p_parameter) const {
 
-	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
-	ERR_FAIL_COND_V(!E,Variant());
-	const FixedMaterial &fm=*E->get();
-	ERR_FAIL_INDEX_V(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX,Variant());
+	const Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E, Variant());
+	const FixedMaterial &fm = *E->get();
+	ERR_FAIL_INDEX_V(p_parameter, VS::FIXED_MATERIAL_PARAM_MAX, Variant());
 	return fm.param[p_parameter];
 }
 
-void Rasterizer::fixed_material_set_texture(RID p_material,VS::FixedMaterialParam p_parameter, RID p_texture){
+void Rasterizer::fixed_material_set_texture(RID p_material, VS::FixedMaterialParam p_parameter, RID p_texture) {
 
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 	if (!E) {
 
-		print_line("Not found: "+itos(p_material.get_id()));
+		print_line("Not found: " + itos(p_material.get_id()));
 	}
 	ERR_FAIL_COND(!E);
-	FixedMaterial &fm=*E->get();
-
+	FixedMaterial &fm = *E->get();
 
-	ERR_FAIL_INDEX(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX);
-	RID material=E->key();
-	fm.texture[p_parameter]=p_texture;
-	VS::get_singleton()->material_set_param(material,_fixed_material_tex_names[p_parameter],p_texture);
+	ERR_FAIL_INDEX(p_parameter, VS::FIXED_MATERIAL_PARAM_MAX);
+	RID material = E->key();
+	fm.texture[p_parameter] = p_texture;
+	VS::get_singleton()->material_set_param(material, _fixed_material_tex_names[p_parameter], p_texture);
 
 	if (!fm.dirty_list.in_list())
-		fixed_material_dirty_list.add( &fm.dirty_list );
-
-
-
-
+		fixed_material_dirty_list.add(&fm.dirty_list);
 }
-RID Rasterizer::fixed_material_get_texture(RID p_material,VS::FixedMaterialParam p_parameter) const{
+RID Rasterizer::fixed_material_get_texture(RID p_material, VS::FixedMaterialParam p_parameter) const {
 
-	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
-	ERR_FAIL_COND_V(!E,RID());
-	const FixedMaterial &fm=*E->get();
-	ERR_FAIL_INDEX_V(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX,RID());
+	const Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E, RID());
+	const FixedMaterial &fm = *E->get();
+	ERR_FAIL_INDEX_V(p_parameter, VS::FIXED_MATERIAL_PARAM_MAX, RID());
 
 	return fm.texture[p_parameter];
 }
 
+void Rasterizer::fixed_material_set_texcoord_mode(RID p_material, VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode) {
 
-void Rasterizer::fixed_material_set_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode) {
-
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 	ERR_FAIL_COND(!E);
-	FixedMaterial &fm=*E->get();
-	ERR_FAIL_INDEX(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX);
+	FixedMaterial &fm = *E->get();
+	ERR_FAIL_INDEX(p_parameter, VS::FIXED_MATERIAL_PARAM_MAX);
 
 	fm.get_key();
 
-	fm.texture_tc[p_parameter]=p_mode;
+	fm.texture_tc[p_parameter] = p_mode;
 
 	if (!fm.dirty_list.in_list())
-		fixed_material_dirty_list.add( &fm.dirty_list );
-
+		fixed_material_dirty_list.add(&fm.dirty_list);
 }
 
-VS::FixedMaterialTexCoordMode Rasterizer::fixed_material_get_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter) const {
+VS::FixedMaterialTexCoordMode Rasterizer::fixed_material_get_texcoord_mode(RID p_material, VS::FixedMaterialParam p_parameter) const {
 
-	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
-	ERR_FAIL_COND_V(!E,VS::FIXED_MATERIAL_TEXCOORD_UV);
-	const FixedMaterial &fm=*E->get();
-	ERR_FAIL_INDEX_V(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX,VS::FIXED_MATERIAL_TEXCOORD_UV);
+	const Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E, VS::FIXED_MATERIAL_TEXCOORD_UV);
+	const FixedMaterial &fm = *E->get();
+	ERR_FAIL_INDEX_V(p_parameter, VS::FIXED_MATERIAL_PARAM_MAX, VS::FIXED_MATERIAL_TEXCOORD_UV);
 
 	return fm.texture_tc[p_parameter];
 }
 
-void Rasterizer::fixed_material_set_uv_transform(RID p_material,const Transform& p_transform) {
+void Rasterizer::fixed_material_set_uv_transform(RID p_material, const Transform &p_transform) {
 
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 	ERR_FAIL_COND(!E);
-	FixedMaterial &fm=*E->get();
-	RID material=E->key();
+	FixedMaterial &fm = *E->get();
+	RID material = E->key();
 
-	VS::get_singleton()->material_set_param(material,_fixed_material_uv_xform_name,p_transform);
-
-	fm.uv_xform=p_transform;
+	VS::get_singleton()->material_set_param(material, _fixed_material_uv_xform_name, p_transform);
 
+	fm.uv_xform = p_transform;
 }
 
-
-
 Transform Rasterizer::fixed_material_get_uv_transform(RID p_material) const {
 
-	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
-	ERR_FAIL_COND_V(!E,Transform());
-	const FixedMaterial &fm=*E->get();
+	const Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E, Transform());
+	const FixedMaterial &fm = *E->get();
 
 	return fm.uv_xform;
 }
 
-void Rasterizer::fixed_material_set_light_shader(RID p_material,VS::FixedMaterialLightShader p_shader) {
+void Rasterizer::fixed_material_set_light_shader(RID p_material, VS::FixedMaterialLightShader p_shader) {
 
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 	ERR_FAIL_COND(!E);
-	FixedMaterial &fm=*E->get();
+	FixedMaterial &fm = *E->get();
 
-	fm.light_shader=p_shader;
+	fm.light_shader = p_shader;
 
 	if (!fm.dirty_list.in_list())
-		fixed_material_dirty_list.add( &fm.dirty_list );
-
+		fixed_material_dirty_list.add(&fm.dirty_list);
 }
 
 VS::FixedMaterialLightShader Rasterizer::fixed_material_get_light_shader(RID p_material) const {
 
-	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
-	ERR_FAIL_COND_V(!E,VS::FIXED_MATERIAL_LIGHT_SHADER_LAMBERT);
-	const FixedMaterial &fm=*E->get();
+	const Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E, VS::FIXED_MATERIAL_LIGHT_SHADER_LAMBERT);
+	const FixedMaterial &fm = *E->get();
 
 	return fm.light_shader;
 }
 
-void Rasterizer::fixed_material_set_point_size(RID p_material,float p_size) {
+void Rasterizer::fixed_material_set_point_size(RID p_material, float p_size) {
 
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 	ERR_FAIL_COND(!E);
-	FixedMaterial &fm=*E->get();
-	RID material=E->key();
-
-	VS::get_singleton()->material_set_param(material,_fixed_material_point_size_name,p_size);
-
-	fm.point_size=p_size;
+	FixedMaterial &fm = *E->get();
+	RID material = E->key();
 
+	VS::get_singleton()->material_set_param(material, _fixed_material_point_size_name, p_size);
 
+	fm.point_size = p_size;
 }
 
-float Rasterizer::fixed_material_get_point_size(RID p_material) const{
+float Rasterizer::fixed_material_get_point_size(RID p_material) const {
 
-	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
-	ERR_FAIL_COND_V(!E,1.0);
-	const FixedMaterial &fm=*E->get();
+	const Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E, 1.0);
+	const FixedMaterial &fm = *E->get();
 
 	return fm.point_size;
-
 }
 
 void Rasterizer::_update_fixed_materials() {
 
+	while (fixed_material_dirty_list.first()) {
 
-	while(fixed_material_dirty_list.first()) {
-
-		FixedMaterial &fm=*fixed_material_dirty_list.first()->self();
+		FixedMaterial &fm = *fixed_material_dirty_list.first()->self();
 
 		FixedMaterialShaderKey new_key = fm.get_key();
-		if (new_key.key!=fm.current_key.key) {
+		if (new_key.key != fm.current_key.key) {
 
 			_free_shader(fm.current_key);
 			RID new_rid = _create_shader(new_key);
-			fm.current_key=new_key;
-			material_set_shader(fm.self,new_rid);
+			fm.current_key = new_key;
+			material_set_shader(fm.self, new_rid);
 
 			if (fm.texture[VS::FIXED_MATERIAL_PARAM_DETAIL].is_valid()) {
 				//send these again just in case.
-				material_set_param(fm.self,_fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_DETAIL],fm.param[VS::FIXED_MATERIAL_PARAM_DETAIL]);
+				material_set_param(fm.self, _fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_DETAIL], fm.param[VS::FIXED_MATERIAL_PARAM_DETAIL]);
 			}
 			if (fm.texture[VS::FIXED_MATERIAL_PARAM_NORMAL].is_valid()) {
 				//send these again just in case.
-				material_set_param(fm.self,_fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_NORMAL],fm.param[VS::FIXED_MATERIAL_PARAM_NORMAL]);
+				material_set_param(fm.self, _fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_NORMAL], fm.param[VS::FIXED_MATERIAL_PARAM_NORMAL]);
 			}
 
-			material_set_param(fm.self,_fixed_material_uv_xform_name,fm.uv_xform);
+			material_set_param(fm.self, _fixed_material_uv_xform_name, fm.uv_xform);
 			if (fm.use_pointsize) {
-				material_set_param(fm.self,_fixed_material_point_size_name,fm.point_size);
+				material_set_param(fm.self, _fixed_material_point_size_name, fm.point_size);
 			}
 		}
 
@@ -577,24 +554,20 @@ void Rasterizer::_update_fixed_materials() {
 	}
 }
 
+void Rasterizer::_free_fixed_material(const RID &p_material) {
 
-void Rasterizer::_free_fixed_material(const RID& p_material) {
-
-	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	Map<RID, FixedMaterial *>::Element *E = fixed_materials.find(p_material);
 
 	if (E) {
 
 		_free_shader(E->get()->current_key); //free shader
 		if (E->get()->dirty_list.in_list())
-			fixed_material_dirty_list.remove( &E->get()->dirty_list);
+			fixed_material_dirty_list.remove(&E->get()->dirty_list);
 		memdelete(E->get());
 		fixed_materials.erase(E); //free material
 	}
-
-
 }
 
-
 void Rasterizer::flush_frame() {
 
 	//not really necesary to implement
@@ -602,40 +575,39 @@ void Rasterizer::flush_frame() {
 
 Rasterizer::Rasterizer() {
 
-	static const char* fm_names[VS::FIXED_MATERIAL_PARAM_MAX]={
-	"diffuse",
-	"detail",
-	"specular",
-	"emission",
-	"specular_exp",
-	"glow",
-	"normal",
-	"shade_param"};
+	static const char *fm_names[VS::FIXED_MATERIAL_PARAM_MAX] = {
+		"diffuse",
+		"detail",
+		"specular",
+		"emission",
+		"specular_exp",
+		"glow",
+		"normal",
+		"shade_param"
+	};
 
-	for(int i=0;i<VS::FIXED_MATERIAL_PARAM_MAX;i++) {
+	for (int i = 0; i < VS::FIXED_MATERIAL_PARAM_MAX; i++) {
 
-		_fixed_material_param_names[i]=String("fmp_")+fm_names[i];
-		_fixed_material_tex_names[i]=String("fmp_")+fm_names[i]+"_tex";
+		_fixed_material_param_names[i] = String("fmp_") + fm_names[i];
+		_fixed_material_tex_names[i] = String("fmp_") + fm_names[i] + "_tex";
 	}
 
-	_fixed_material_uv_xform_name="fmp_uv_xform";
-	_fixed_material_point_size_name="fmp_point_size";
+	_fixed_material_uv_xform_name = "fmp_uv_xform";
+	_fixed_material_point_size_name = "fmp_point_size";
 
-	draw_viewport_func=NULL;
-
-	ERR_FAIL_COND( sizeof(FixedMaterialShaderKey)!=4);
+	draw_viewport_func = NULL;
 
+	ERR_FAIL_COND(sizeof(FixedMaterialShaderKey) != 4);
 }
 
 RID Rasterizer::create_overdraw_debug_material() {
 	RID mat = fixed_material_create();
-	fixed_material_set_parameter( mat,VisualServer::FIXED_MATERIAL_PARAM_SPECULAR,Color(0,0,0) );
-	fixed_material_set_parameter( mat,VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE,Color(0.1,0.1,0.2) );
-	fixed_material_set_parameter( mat,VisualServer::FIXED_MATERIAL_PARAM_EMISSION,Color(0,0,0) );
-	fixed_material_set_flag( mat, VS::FIXED_MATERIAL_FLAG_USE_ALPHA, true);
-	material_set_flag( mat, VisualServer::MATERIAL_FLAG_UNSHADED, true );
-	material_set_blend_mode( mat,VisualServer::MATERIAL_BLEND_MODE_ADD );
-
+	fixed_material_set_parameter(mat, VisualServer::FIXED_MATERIAL_PARAM_SPECULAR, Color(0, 0, 0));
+	fixed_material_set_parameter(mat, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(0.1, 0.1, 0.2));
+	fixed_material_set_parameter(mat, VisualServer::FIXED_MATERIAL_PARAM_EMISSION, Color(0, 0, 0));
+	fixed_material_set_flag(mat, VS::FIXED_MATERIAL_FLAG_USE_ALPHA, true);
+	material_set_flag(mat, VisualServer::MATERIAL_FLAG_UNSHADED, true);
+	material_set_blend_mode(mat, VisualServer::MATERIAL_BLEND_MODE_ADD);
 
 	return mat;
 }
diff --git a/servers/visual/rasterizer.h b/servers/visual/rasterizer.h
index 0fe0bd663..51bc4d0f9 100644
--- a/servers/visual/rasterizer.h
+++ b/servers/visual/rasterizer.h
@@ -32,21 +32,18 @@
 /**
 	@author Juan Linietsky <reduzio@gmail.com>
 */
-#include "servers/visual_server.h"
 #include "camera_matrix.h"
 #include "map.h"
 #include "self_list.h"
+#include "servers/visual_server.h"
 
 class Rasterizer {
 protected:
-
-
-	typedef void (*CanvasItemDrawViewportFunc)(VisualServer*owner,void*ud,const Rect2& p_rect);
+	typedef void (*CanvasItemDrawViewportFunc)(VisualServer *owner, void *ud, const Rect2 &p_rect);
 
 	RID create_default_material();
 	RID create_overdraw_debug_material();
 
-
 	/* Fixed Material Shader API */
 
 	union FixedMaterialShaderKey {
@@ -54,18 +51,18 @@ protected:
 		struct {
 			uint16_t texcoord_mask;
 			uint8_t texture_mask;
-			uint8_t light_shader:2;
-			bool use_alpha:1;
-			bool use_color_array:1;
-			bool use_pointsize:1;
-			bool discard_alpha:1;
-			bool use_xy_normalmap:1;
-			bool valid:1;
+			uint8_t light_shader : 2;
+			bool use_alpha : 1;
+			bool use_color_array : 1;
+			bool use_pointsize : 1;
+			bool discard_alpha : 1;
+			bool use_xy_normalmap : 1;
+			bool valid : 1;
 		};
 
 		uint32_t key;
 
-		_FORCE_INLINE_ bool operator<(const FixedMaterialShaderKey& p_key) const { return key<p_key.key; }
+		_FORCE_INLINE_ bool operator<(const FixedMaterialShaderKey &p_key) const { return key < p_key.key; }
 	};
 
 	struct FixedMaterialShader {
@@ -74,14 +71,13 @@ protected:
 		RID shader;
 	};
 
-	Map<FixedMaterialShaderKey,FixedMaterialShader> fixed_material_shaders;
+	Map<FixedMaterialShaderKey, FixedMaterialShader> fixed_material_shaders;
 
-	RID _create_shader(const FixedMaterialShaderKey& p_key);
-	void _free_shader(const FixedMaterialShaderKey& p_key);
+	RID _create_shader(const FixedMaterialShaderKey &p_key);
+	void _free_shader(const FixedMaterialShaderKey &p_key);
 
 	struct FixedMaterial {
 
-
 		RID self;
 		bool use_alpha;
 		bool use_color_array;
@@ -101,52 +97,49 @@ protected:
 
 		_FORCE_INLINE_ FixedMaterialShaderKey get_key() const {
 
-
 			FixedMaterialShaderKey k;
-			k.key=0;
-			k.use_alpha=use_alpha;
-			k.use_color_array=use_color_array;
-			k.use_pointsize=use_pointsize;
-			k.use_xy_normalmap=use_xy_normalmap;
-			k.discard_alpha=discard_alpha;
-			k.light_shader=light_shader;
-			k.valid=true;
-			for(int i=0;i<VS::FIXED_MATERIAL_PARAM_MAX;i++) {
+			k.key = 0;
+			k.use_alpha = use_alpha;
+			k.use_color_array = use_color_array;
+			k.use_pointsize = use_pointsize;
+			k.use_xy_normalmap = use_xy_normalmap;
+			k.discard_alpha = discard_alpha;
+			k.light_shader = light_shader;
+			k.valid = true;
+			for (int i = 0; i < VS::FIXED_MATERIAL_PARAM_MAX; i++) {
 				if (texture[i].is_valid()) {
 					//print_line("valid: "+itos(i));
-					k.texture_mask|=(1<<i);
-					k.texcoord_mask|=(texture_tc[i])<<(i*2);
+					k.texture_mask |= (1 << i);
+					k.texcoord_mask |= (texture_tc[i]) << (i * 2);
 				}
 			}
 
 			return k;
 		}
 
+		FixedMaterial()
+			: dirty_list(this) {
 
-		FixedMaterial() : dirty_list(this) {
-
-			use_alpha=false;
-			use_color_array=false;
-			use_pointsize=false;
-			discard_alpha=false;
-			use_xy_normalmap=false;
-			point_size=1.0;
-			light_shader=VS::FIXED_MATERIAL_LIGHT_SHADER_LAMBERT;
-			for(int i=0;i<VS::FIXED_MATERIAL_PARAM_MAX;i++) {
-				texture_tc[i]=VS::FIXED_MATERIAL_TEXCOORD_UV;
+			use_alpha = false;
+			use_color_array = false;
+			use_pointsize = false;
+			discard_alpha = false;
+			use_xy_normalmap = false;
+			point_size = 1.0;
+			light_shader = VS::FIXED_MATERIAL_LIGHT_SHADER_LAMBERT;
+			for (int i = 0; i < VS::FIXED_MATERIAL_PARAM_MAX; i++) {
+				texture_tc[i] = VS::FIXED_MATERIAL_TEXCOORD_UV;
 			}
-			param[VS::FIXED_MATERIAL_PARAM_DIFFUSE]=Color(1,1,1);
-			param[VS::FIXED_MATERIAL_PARAM_DETAIL]=1.0;
-			param[VS::FIXED_MATERIAL_PARAM_EMISSION]=Color(0,0,0);
-			param[VS::FIXED_MATERIAL_PARAM_GLOW]=0;
-			param[VS::FIXED_MATERIAL_PARAM_SHADE_PARAM]=0;
-			param[VS::FIXED_MATERIAL_PARAM_SPECULAR]=Color(0.0,0.0,0.0);
-			param[VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP]=40;
-			param[VS::FIXED_MATERIAL_PARAM_NORMAL]=1;
-
-			current_key.key=0;
-
+			param[VS::FIXED_MATERIAL_PARAM_DIFFUSE] = Color(1, 1, 1);
+			param[VS::FIXED_MATERIAL_PARAM_DETAIL] = 1.0;
+			param[VS::FIXED_MATERIAL_PARAM_EMISSION] = Color(0, 0, 0);
+			param[VS::FIXED_MATERIAL_PARAM_GLOW] = 0;
+			param[VS::FIXED_MATERIAL_PARAM_SHADE_PARAM] = 0;
+			param[VS::FIXED_MATERIAL_PARAM_SPECULAR] = Color(0.0, 0.0, 0.0);
+			param[VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP] = 40;
+			param[VS::FIXED_MATERIAL_PARAM_NORMAL] = 1;
 
+			current_key.key = 0;
 		}
 	};
 
@@ -155,16 +148,15 @@ protected:
 	StringName _fixed_material_uv_xform_name;
 	StringName _fixed_material_point_size_name;
 
-	Map<RID,FixedMaterial*> fixed_materials;
+	Map<RID, FixedMaterial *> fixed_materials;
 
 	SelfList<FixedMaterial>::List fixed_material_dirty_list;
 
 protected:
 	void _update_fixed_materials();
-	void _free_fixed_material(const RID& p_material);
+	void _free_fixed_material(const RID &p_material);
 
 public:
-
 	enum ShadowFilterTechnique {
 		SHADOW_FILTER_NONE,
 		SHADOW_FILTER_PCF5,
@@ -173,72 +165,69 @@ public:
 		SHADOW_FILTER_VSM,
 	};
 
-
-
 	/* TEXTURE API */
 
-	virtual RID texture_create()=0;
-	RID texture_create_from_image(const Image& p_image,uint32_t p_flags=VS::TEXTURE_FLAGS_DEFAULT); // helper
-	virtual void texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags=VS::TEXTURE_FLAGS_DEFAULT)=0;
-	virtual void texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT)=0;
-	virtual Image texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT) const=0;
-	virtual void texture_set_flags(RID p_texture,uint32_t p_flags)=0;
-	virtual uint32_t texture_get_flags(RID p_texture) const=0;
-	virtual Image::Format texture_get_format(RID p_texture) const=0;
-	virtual uint32_t texture_get_width(RID p_texture) const=0;
-	virtual uint32_t texture_get_height(RID p_texture) const=0;
-	virtual bool texture_has_alpha(RID p_texture) const=0;
-	virtual void texture_set_size_override(RID p_texture,int p_width, int p_height)=0;
+	virtual RID texture_create() = 0;
+	RID texture_create_from_image(const Image &p_image, uint32_t p_flags = VS::TEXTURE_FLAGS_DEFAULT); // helper
+	virtual void texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags = VS::TEXTURE_FLAGS_DEFAULT) = 0;
+	virtual void texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT) = 0;
+	virtual Image texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT) const = 0;
+	virtual void texture_set_flags(RID p_texture, uint32_t p_flags) = 0;
+	virtual uint32_t texture_get_flags(RID p_texture) const = 0;
+	virtual Image::Format texture_get_format(RID p_texture) const = 0;
+	virtual uint32_t texture_get_width(RID p_texture) const = 0;
+	virtual uint32_t texture_get_height(RID p_texture) const = 0;
+	virtual bool texture_has_alpha(RID p_texture) const = 0;
+	virtual void texture_set_size_override(RID p_texture, int p_width, int p_height) = 0;
 
-	virtual void texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName& p_function) const=0;
+	virtual void texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function) const = 0;
 
-	virtual void texture_set_path(RID p_texture,const String& p_path)=0;
-	virtual String texture_get_path(RID p_texture) const=0;
-	virtual void texture_debug_usage(List<VS::TextureInfo> *r_info)=0;
+	virtual void texture_set_path(RID p_texture, const String &p_path) = 0;
+	virtual String texture_get_path(RID p_texture) const = 0;
+	virtual void texture_debug_usage(List<VS::TextureInfo> *r_info) = 0;
 
-	virtual void texture_set_shrink_all_x2_on_set_data(bool p_enable)=0;
+	virtual void texture_set_shrink_all_x2_on_set_data(bool p_enable) = 0;
 
 	/* SHADER API */
 
-	virtual RID shader_create(VS::ShaderMode p_mode=VS::SHADER_MATERIAL)=0;
+	virtual RID shader_create(VS::ShaderMode p_mode = VS::SHADER_MATERIAL) = 0;
 
-	virtual void shader_set_mode(RID p_shader,VS::ShaderMode p_mode)=0;
-	virtual VS::ShaderMode shader_get_mode(RID p_shader) const=0;
+	virtual void shader_set_mode(RID p_shader, VS::ShaderMode p_mode) = 0;
+	virtual VS::ShaderMode shader_get_mode(RID p_shader) const = 0;
 
-	virtual void shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs=0,int p_fragment_ofs=0,int p_light_ofs=0)=0;
-	virtual String shader_get_fragment_code(RID p_shader) const=0;
-	virtual String shader_get_vertex_code(RID p_shader) const=0;
-	virtual String shader_get_light_code(RID p_shader) const=0;
+	virtual void shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs = 0, int p_fragment_ofs = 0, int p_light_ofs = 0) = 0;
+	virtual String shader_get_fragment_code(RID p_shader) const = 0;
+	virtual String shader_get_vertex_code(RID p_shader) const = 0;
+	virtual String shader_get_light_code(RID p_shader) const = 0;
 
-	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const=0;
+	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const = 0;
 
-	virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture)=0;
-	virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const=0;
+	virtual void shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) = 0;
+	virtual RID shader_get_default_texture_param(RID p_shader, const StringName &p_name) const = 0;
 
-	virtual Variant shader_get_default_param(RID p_shader, const StringName& p_name)=0;
+	virtual Variant shader_get_default_param(RID p_shader, const StringName &p_name) = 0;
 
 	/* COMMON MATERIAL API */
 
-	virtual RID material_create()=0;
-
-	virtual void material_set_shader(RID p_shader_material, RID p_shader)=0;
-	virtual RID material_get_shader(RID p_shader_material) const=0;
+	virtual RID material_create() = 0;
 
-	virtual void material_set_param(RID p_material, const StringName& p_param, const Variant& p_value)=0;
-	virtual Variant material_get_param(RID p_material, const StringName& p_param) const=0;
+	virtual void material_set_shader(RID p_shader_material, RID p_shader) = 0;
+	virtual RID material_get_shader(RID p_shader_material) const = 0;
 
-	virtual void material_set_flag(RID p_material, VS::MaterialFlag p_flag,bool p_enabled)=0;
-	virtual bool material_get_flag(RID p_material,VS::MaterialFlag p_flag) const=0;
+	virtual void material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) = 0;
+	virtual Variant material_get_param(RID p_material, const StringName &p_param) const = 0;
 
-	virtual void material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode)=0;
-	virtual VS::MaterialDepthDrawMode material_get_depth_draw_mode(RID p_material) const=0;
+	virtual void material_set_flag(RID p_material, VS::MaterialFlag p_flag, bool p_enabled) = 0;
+	virtual bool material_get_flag(RID p_material, VS::MaterialFlag p_flag) const = 0;
 
-	virtual void material_set_blend_mode(RID p_material,VS::MaterialBlendMode p_mode)=0;
-	virtual VS::MaterialBlendMode material_get_blend_mode(RID p_material) const=0;
+	virtual void material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode) = 0;
+	virtual VS::MaterialDepthDrawMode material_get_depth_draw_mode(RID p_material) const = 0;
 
-	virtual void material_set_line_width(RID p_material,float p_line_width)=0;
-	virtual float material_get_line_width(RID p_material) const=0;
+	virtual void material_set_blend_mode(RID p_material, VS::MaterialBlendMode p_mode) = 0;
+	virtual VS::MaterialBlendMode material_get_blend_mode(RID p_material) const = 0;
 
+	virtual void material_set_line_width(RID p_material, float p_line_width) = 0;
+	virtual float material_get_line_width(RID p_material) const = 0;
 
 	/* FIXED MATERIAL */
 
@@ -247,205 +236,198 @@ public:
 	virtual void fixed_material_set_flag(RID p_material, VS::FixedMaterialFlags p_flag, bool p_enabled);
 	virtual bool fixed_material_get_flag(RID p_material, VS::FixedMaterialFlags p_flag) const;
 
-	virtual void fixed_material_set_parameter(RID p_material, VS::FixedMaterialParam p_parameter, const Variant& p_value);
-	virtual Variant fixed_material_get_parameter(RID p_material,VS::FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_parameter(RID p_material, VS::FixedMaterialParam p_parameter, const Variant &p_value);
+	virtual Variant fixed_material_get_parameter(RID p_material, VS::FixedMaterialParam p_parameter) const;
 
-	virtual void fixed_material_set_texture(RID p_material,VS::FixedMaterialParam p_parameter, RID p_texture);
-	virtual RID fixed_material_get_texture(RID p_material,VS::FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_texture(RID p_material, VS::FixedMaterialParam p_parameter, RID p_texture);
+	virtual RID fixed_material_get_texture(RID p_material, VS::FixedMaterialParam p_parameter) const;
 
-	virtual void fixed_material_set_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode);
-	virtual VS::FixedMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_texcoord_mode(RID p_material, VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode);
+	virtual VS::FixedMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material, VS::FixedMaterialParam p_parameter) const;
 
-	virtual void fixed_material_set_uv_transform(RID p_material,const Transform& p_transform);
+	virtual void fixed_material_set_uv_transform(RID p_material, const Transform &p_transform);
 	virtual Transform fixed_material_get_uv_transform(RID p_material) const;
 
-	virtual void fixed_material_set_light_shader(RID p_material,VS::FixedMaterialLightShader p_shader);
+	virtual void fixed_material_set_light_shader(RID p_material, VS::FixedMaterialLightShader p_shader);
 	virtual VS::FixedMaterialLightShader fixed_material_get_light_shader(RID p_material) const;
 
-	virtual void fixed_material_set_point_size(RID p_material,float p_size);
+	virtual void fixed_material_set_point_size(RID p_material, float p_size);
 	virtual float fixed_material_get_point_size(RID p_material) const;
 
 	/* MESH API */
 
-	virtual RID mesh_create()=0;
+	virtual RID mesh_create() = 0;
 
+	virtual void mesh_add_surface(RID p_mesh, VS::PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes = Array(), bool p_alpha_sort = false) = 0;
+	virtual Array mesh_get_surface_arrays(RID p_mesh, int p_surface) const = 0;
+	virtual Array mesh_get_surface_morph_arrays(RID p_mesh, int p_surface) const = 0;
 
-	virtual void mesh_add_surface(RID p_mesh,VS::PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes=Array(),bool p_alpha_sort=false)=0;
-	virtual Array mesh_get_surface_arrays(RID p_mesh,int p_surface) const=0;
-	virtual Array mesh_get_surface_morph_arrays(RID p_mesh,int p_surface) const=0;
+	virtual void mesh_add_custom_surface(RID p_mesh, const Variant &p_dat) = 0;
 
-	virtual void mesh_add_custom_surface(RID p_mesh,const Variant& p_dat)=0;
+	virtual void mesh_set_morph_target_count(RID p_mesh, int p_amount) = 0;
+	virtual int mesh_get_morph_target_count(RID p_mesh) const = 0;
 
-	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount)=0;
-	virtual int mesh_get_morph_target_count(RID p_mesh) const=0;
+	virtual void mesh_set_morph_target_mode(RID p_mesh, VS::MorphTargetMode p_mode) = 0;
+	virtual VS::MorphTargetMode mesh_get_morph_target_mode(RID p_mesh) const = 0;
 
-	virtual void mesh_set_morph_target_mode(RID p_mesh,VS::MorphTargetMode p_mode)=0;
-	virtual VS::MorphTargetMode mesh_get_morph_target_mode(RID p_mesh) const=0;
+	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned = false) = 0;
+	virtual RID mesh_surface_get_material(RID p_mesh, int p_surface) const = 0;
 
-	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material,bool p_owned=false)=0;
-	virtual RID mesh_surface_get_material(RID p_mesh, int p_surface) const=0;
+	virtual int mesh_surface_get_array_len(RID p_mesh, int p_surface) const = 0;
+	virtual int mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const = 0;
+	virtual uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const = 0;
+	virtual VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const = 0;
 
-	virtual int mesh_surface_get_array_len(RID p_mesh, int p_surface) const=0;
-	virtual int mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const=0;
-	virtual uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const=0;
-	virtual VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const=0;
+	virtual void mesh_remove_surface(RID p_mesh, int p_index) = 0;
+	virtual int mesh_get_surface_count(RID p_mesh) const = 0;
 
-	virtual void mesh_remove_surface(RID p_mesh,int p_index)=0;
-	virtual int mesh_get_surface_count(RID p_mesh) const=0;
+	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton = RID()) const = 0;
 
-	virtual AABB mesh_get_aabb(RID p_mesh,RID p_skeleton=RID()) const=0;
-
-	virtual void mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb)=0;
-	virtual AABB mesh_get_custom_aabb(RID p_mesh) const=0;
+	virtual void mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) = 0;
+	virtual AABB mesh_get_custom_aabb(RID p_mesh) const = 0;
 
 	/* MULTIMESH API */
 
-	virtual RID multimesh_create()=0;
+	virtual RID multimesh_create() = 0;
 
-	virtual void multimesh_set_instance_count(RID p_multimesh,int p_count)=0;
-	virtual int multimesh_get_instance_count(RID p_multimesh) const=0;
+	virtual void multimesh_set_instance_count(RID p_multimesh, int p_count) = 0;
+	virtual int multimesh_get_instance_count(RID p_multimesh) const = 0;
 
-	virtual void multimesh_set_mesh(RID p_multimesh,RID p_mesh)=0;
-	virtual void multimesh_set_aabb(RID p_multimesh,const AABB& p_aabb)=0;
-	virtual void multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform)=0;
-	virtual void multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color)=0;
+	virtual void multimesh_set_mesh(RID p_multimesh, RID p_mesh) = 0;
+	virtual void multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb) = 0;
+	virtual void multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) = 0;
+	virtual void multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) = 0;
 
-	virtual RID multimesh_get_mesh(RID p_multimesh) const=0;
-	virtual AABB multimesh_get_aabb(RID p_multimesh) const=0;
+	virtual RID multimesh_get_mesh(RID p_multimesh) const = 0;
+	virtual AABB multimesh_get_aabb(RID p_multimesh) const = 0;
 
-	virtual Transform multimesh_instance_get_transform(RID p_multimesh,int p_index) const=0;
-	virtual Color multimesh_instance_get_color(RID p_multimesh,int p_index) const=0;
+	virtual Transform multimesh_instance_get_transform(RID p_multimesh, int p_index) const = 0;
+	virtual Color multimesh_instance_get_color(RID p_multimesh, int p_index) const = 0;
 
-	virtual void multimesh_set_visible_instances(RID p_multimesh,int p_visible)=0;
-	virtual int multimesh_get_visible_instances(RID p_multimesh) const=0;
+	virtual void multimesh_set_visible_instances(RID p_multimesh, int p_visible) = 0;
+	virtual int multimesh_get_visible_instances(RID p_multimesh) const = 0;
 
 	/* BAKED LIGHT */
 
-
-
-
 	/* IMMEDIATE API */
 
-	virtual RID immediate_create()=0;
-	virtual void immediate_begin(RID p_immediate,VS::PrimitiveType p_rimitive,RID p_texture=RID())=0;
-	virtual void immediate_vertex(RID p_immediate,const Vector3& p_vertex)=0;
-	virtual void immediate_normal(RID p_immediate,const Vector3& p_normal)=0;
-	virtual void immediate_tangent(RID p_immediate,const Plane& p_tangent)=0;
-	virtual void immediate_color(RID p_immediate,const Color& p_color)=0;
-	virtual void immediate_uv(RID p_immediate,const Vector2& tex_uv)=0;
-	virtual void immediate_uv2(RID p_immediate,const Vector2& tex_uv)=0;
-	virtual void immediate_end(RID p_immediate)=0;
-	virtual void immediate_clear(RID p_immediate)=0;
-	virtual AABB immediate_get_aabb(RID p_immediate) const=0;
-	virtual void immediate_set_material(RID p_immediate,RID p_material)=0;
-	virtual RID immediate_get_material(RID p_immediate) const=0;
-
+	virtual RID immediate_create() = 0;
+	virtual void immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture = RID()) = 0;
+	virtual void immediate_vertex(RID p_immediate, const Vector3 &p_vertex) = 0;
+	virtual void immediate_normal(RID p_immediate, const Vector3 &p_normal) = 0;
+	virtual void immediate_tangent(RID p_immediate, const Plane &p_tangent) = 0;
+	virtual void immediate_color(RID p_immediate, const Color &p_color) = 0;
+	virtual void immediate_uv(RID p_immediate, const Vector2 &tex_uv) = 0;
+	virtual void immediate_uv2(RID p_immediate, const Vector2 &tex_uv) = 0;
+	virtual void immediate_end(RID p_immediate) = 0;
+	virtual void immediate_clear(RID p_immediate) = 0;
+	virtual AABB immediate_get_aabb(RID p_immediate) const = 0;
+	virtual void immediate_set_material(RID p_immediate, RID p_material) = 0;
+	virtual RID immediate_get_material(RID p_immediate) const = 0;
 
 	/* PARTICLES API */
 
-	virtual RID particles_create()=0;
+	virtual RID particles_create() = 0;
 
-	virtual void particles_set_amount(RID p_particles, int p_amount)=0;
-	virtual int particles_get_amount(RID p_particles) const=0;
+	virtual void particles_set_amount(RID p_particles, int p_amount) = 0;
+	virtual int particles_get_amount(RID p_particles) const = 0;
 
-	virtual void particles_set_emitting(RID p_particles, bool p_emitting)=0;
-	virtual bool particles_is_emitting(RID p_particles) const=0;
+	virtual void particles_set_emitting(RID p_particles, bool p_emitting) = 0;
+	virtual bool particles_is_emitting(RID p_particles) const = 0;
 
-	virtual void particles_set_visibility_aabb(RID p_particles, const AABB& p_visibility)=0;
-	virtual AABB particles_get_visibility_aabb(RID p_particles) const=0;
+	virtual void particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility) = 0;
+	virtual AABB particles_get_visibility_aabb(RID p_particles) const = 0;
 
-	virtual void particles_set_emission_half_extents(RID p_particles, const Vector3& p_half_extents)=0;
-	virtual Vector3 particles_get_emission_half_extents(RID p_particles) const=0;
+	virtual void particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents) = 0;
+	virtual Vector3 particles_get_emission_half_extents(RID p_particles) const = 0;
 
-	virtual void particles_set_emission_base_velocity(RID p_particles, const Vector3& p_base_velocity)=0;
-	virtual Vector3 particles_get_emission_base_velocity(RID p_particles) const=0;
+	virtual void particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity) = 0;
+	virtual Vector3 particles_get_emission_base_velocity(RID p_particles) const = 0;
 
-	virtual void particles_set_emission_points(RID p_particles, const DVector<Vector3>& p_points)=0;
-	virtual DVector<Vector3> particles_get_emission_points(RID p_particles) const=0;
+	virtual void particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points) = 0;
+	virtual DVector<Vector3> particles_get_emission_points(RID p_particles) const = 0;
 
-	virtual void particles_set_gravity_normal(RID p_particles, const Vector3& p_normal)=0;
-	virtual Vector3 particles_get_gravity_normal(RID p_particles) const=0;
+	virtual void particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal) = 0;
+	virtual Vector3 particles_get_gravity_normal(RID p_particles) const = 0;
 
-	virtual void particles_set_variable(RID p_particles, VS::ParticleVariable p_variable,float p_value)=0;
-	virtual float particles_get_variable(RID p_particles, VS::ParticleVariable p_variable) const=0;
+	virtual void particles_set_variable(RID p_particles, VS::ParticleVariable p_variable, float p_value) = 0;
+	virtual float particles_get_variable(RID p_particles, VS::ParticleVariable p_variable) const = 0;
 
-	virtual void particles_set_randomness(RID p_particles, VS::ParticleVariable p_variable,float p_randomness)=0;
-	virtual float particles_get_randomness(RID p_particles, VS::ParticleVariable p_variable) const=0;
+	virtual void particles_set_randomness(RID p_particles, VS::ParticleVariable p_variable, float p_randomness) = 0;
+	virtual float particles_get_randomness(RID p_particles, VS::ParticleVariable p_variable) const = 0;
 
-	virtual void particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos)=0;
-	virtual float particles_get_color_phase_pos(RID p_particles, int p_phase) const=0;
+	virtual void particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos) = 0;
+	virtual float particles_get_color_phase_pos(RID p_particles, int p_phase) const = 0;
 
-	virtual void particles_set_color_phases(RID p_particles, int p_phases)=0;
-	virtual int particles_get_color_phases(RID p_particles) const=0;
+	virtual void particles_set_color_phases(RID p_particles, int p_phases) = 0;
+	virtual int particles_get_color_phases(RID p_particles) const = 0;
 
-	virtual void particles_set_color_phase_color(RID p_particles, int p_phase, const Color& p_color)=0;
-	virtual Color particles_get_color_phase_color(RID p_particles, int p_phase) const=0;
+	virtual void particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color) = 0;
+	virtual Color particles_get_color_phase_color(RID p_particles, int p_phase) const = 0;
 
-	virtual void particles_set_attractors(RID p_particles, int p_attractors)=0;
-	virtual int particles_get_attractors(RID p_particles) const=0;
+	virtual void particles_set_attractors(RID p_particles, int p_attractors) = 0;
+	virtual int particles_get_attractors(RID p_particles) const = 0;
 
-	virtual void particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3& p_pos)=0;
-	virtual Vector3 particles_get_attractor_pos(RID p_particles,int p_attractor) const=0;
+	virtual void particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos) = 0;
+	virtual Vector3 particles_get_attractor_pos(RID p_particles, int p_attractor) const = 0;
 
-	virtual void particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force)=0;
-	virtual float particles_get_attractor_strength(RID p_particles,int p_attractor) const=0;
+	virtual void particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force) = 0;
+	virtual float particles_get_attractor_strength(RID p_particles, int p_attractor) const = 0;
 
-	virtual void particles_set_material(RID p_particles, RID p_material,bool p_owned=false)=0;
-	virtual RID particles_get_material(RID p_particles) const=0;
+	virtual void particles_set_material(RID p_particles, RID p_material, bool p_owned = false) = 0;
+	virtual RID particles_get_material(RID p_particles) const = 0;
 
-	virtual AABB particles_get_aabb(RID p_particles) const=0;
+	virtual AABB particles_get_aabb(RID p_particles) const = 0;
 
-	virtual void particles_set_height_from_velocity(RID p_particles, bool p_enable)=0;
-	virtual bool particles_has_height_from_velocity(RID p_particles) const=0;
+	virtual void particles_set_height_from_velocity(RID p_particles, bool p_enable) = 0;
+	virtual bool particles_has_height_from_velocity(RID p_particles) const = 0;
 
-	virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable)=0;
-	virtual bool particles_is_using_local_coordinates(RID p_particles) const=0;
+	virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable) = 0;
+	virtual bool particles_is_using_local_coordinates(RID p_particles) const = 0;
 
 	/* SKELETON API */
 
-	virtual RID skeleton_create()=0;
-	virtual void skeleton_resize(RID p_skeleton,int p_bones)=0;
-	virtual int skeleton_get_bone_count(RID p_skeleton) const=0;
-	virtual void skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform)=0;
-	virtual Transform skeleton_bone_get_transform(RID p_skeleton,int p_bone)=0;
-
+	virtual RID skeleton_create() = 0;
+	virtual void skeleton_resize(RID p_skeleton, int p_bones) = 0;
+	virtual int skeleton_get_bone_count(RID p_skeleton) const = 0;
+	virtual void skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) = 0;
+	virtual Transform skeleton_bone_get_transform(RID p_skeleton, int p_bone) = 0;
 
 	/* LIGHT API */
 
-	virtual RID light_create(VS::LightType p_type)=0;
-	virtual VS::LightType light_get_type(RID p_light) const=0;
-
-	virtual void light_set_color(RID p_light,VS::LightColor p_type, const Color& p_color)=0;
-	virtual Color light_get_color(RID p_light,VS::LightColor p_type) const=0;
+	virtual RID light_create(VS::LightType p_type) = 0;
+	virtual VS::LightType light_get_type(RID p_light) const = 0;
 
-	virtual void light_set_shadow(RID p_light,bool p_enabled)=0;
-	virtual bool light_has_shadow(RID p_light) const=0;
+	virtual void light_set_color(RID p_light, VS::LightColor p_type, const Color &p_color) = 0;
+	virtual Color light_get_color(RID p_light, VS::LightColor p_type) const = 0;
 
-	virtual void light_set_volumetric(RID p_light,bool p_enabled)=0;
-	virtual bool light_is_volumetric(RID p_light) const=0;
+	virtual void light_set_shadow(RID p_light, bool p_enabled) = 0;
+	virtual bool light_has_shadow(RID p_light) const = 0;
 
-	virtual void light_set_projector(RID p_light,RID p_texture)=0;
-	virtual RID light_get_projector(RID p_light) const=0;
+	virtual void light_set_volumetric(RID p_light, bool p_enabled) = 0;
+	virtual bool light_is_volumetric(RID p_light) const = 0;
 
-	virtual void light_set_var(RID p_light, VS::LightParam p_var, float p_value)=0;
-	virtual float light_get_var(RID p_light, VS::LightParam p_var) const=0;
+	virtual void light_set_projector(RID p_light, RID p_texture) = 0;
+	virtual RID light_get_projector(RID p_light) const = 0;
 
-	virtual void light_set_operator(RID p_light,VS::LightOp p_op)=0;
-	virtual VS::LightOp light_get_operator(RID p_light) const=0;
+	virtual void light_set_var(RID p_light, VS::LightParam p_var, float p_value) = 0;
+	virtual float light_get_var(RID p_light, VS::LightParam p_var) const = 0;
 
-	virtual void light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode)=0;
-	virtual VS::LightOmniShadowMode light_omni_get_shadow_mode(RID p_light) const=0;
+	virtual void light_set_operator(RID p_light, VS::LightOp p_op) = 0;
+	virtual VS::LightOp light_get_operator(RID p_light) const = 0;
 
-	virtual void light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode)=0;
-	virtual VS::LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light) const=0;
-	virtual void light_directional_set_shadow_param(RID p_light,VS::LightDirectionalShadowParam p_param, float p_value)=0;
-	virtual float light_directional_get_shadow_param(RID p_light,VS::LightDirectionalShadowParam p_param) const=0;
+	virtual void light_omni_set_shadow_mode(RID p_light, VS::LightOmniShadowMode p_mode) = 0;
+	virtual VS::LightOmniShadowMode light_omni_get_shadow_mode(RID p_light) const = 0;
 
-	virtual AABB light_get_aabb(RID p_poly) const=0;
+	virtual void light_directional_set_shadow_mode(RID p_light, VS::LightDirectionalShadowMode p_mode) = 0;
+	virtual VS::LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light) const = 0;
+	virtual void light_directional_set_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param, float p_value) = 0;
+	virtual float light_directional_get_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param) const = 0;
 
-	virtual RID light_instance_create(RID p_light)=0;
-	virtual void light_instance_set_transform(RID p_light_instance,const Transform& p_transform)=0;
+	virtual AABB light_get_aabb(RID p_poly) const = 0;
 
+	virtual RID light_instance_create(RID p_light) = 0;
+	virtual void light_instance_set_transform(RID p_light_instance, const Transform &p_transform) = 0;
 
 	enum ShadowType {
 		SHADOW_NONE,
@@ -458,60 +440,60 @@ public:
 	};
 
 	enum ShadowPass {
-		PASS_DUAL_PARABOLOID_FRONT=0,
-		PASS_DUAL_PARABOLOID_BACK=1,
-		PASS_CUBE_FRONT=0,
-		PASS_CUBE_BACK=1,
-		PASS_CUBE_TOP=2,
-		PASS_CUBE_BOTTOM=3,
-		PASS_CUBE_LEFT=4,
-		PASS_CUBE_RIGHT=5,
+		PASS_DUAL_PARABOLOID_FRONT = 0,
+		PASS_DUAL_PARABOLOID_BACK = 1,
+		PASS_CUBE_FRONT = 0,
+		PASS_CUBE_BACK = 1,
+		PASS_CUBE_TOP = 2,
+		PASS_CUBE_BOTTOM = 3,
+		PASS_CUBE_LEFT = 4,
+		PASS_CUBE_RIGHT = 5,
 	};
 
-	virtual ShadowType light_instance_get_shadow_type(RID p_light_instance,bool p_far=false) const=0;
-	virtual int light_instance_get_shadow_passes(RID p_light_instance) const=0;
-	virtual void light_instance_set_shadow_transform(RID p_light_instance, int p_index, const CameraMatrix& p_camera, const Transform& p_transform, float p_split_near=0,float p_split_far=0)=0;
-	virtual int light_instance_get_shadow_size(RID p_light_instance, int p_index=0) const=0;
-	virtual bool light_instance_get_pssm_shadow_overlap(RID p_light_instance) const=0;
+	virtual ShadowType light_instance_get_shadow_type(RID p_light_instance, bool p_far = false) const = 0;
+	virtual int light_instance_get_shadow_passes(RID p_light_instance) const = 0;
+	virtual void light_instance_set_shadow_transform(RID p_light_instance, int p_index, const CameraMatrix &p_camera, const Transform &p_transform, float p_split_near = 0, float p_split_far = 0) = 0;
+	virtual int light_instance_get_shadow_size(RID p_light_instance, int p_index = 0) const = 0;
+	virtual bool light_instance_get_pssm_shadow_overlap(RID p_light_instance) const = 0;
 
 	/* SHADOWS */
 
-	virtual void shadow_clear_near()=0;
-	virtual bool shadow_allocate_near(RID p_light)=0; //true on successful alloc
-	virtual bool shadow_allocate_far(RID p_light)=0; //true on successful alloc
+	virtual void shadow_clear_near() = 0;
+	virtual bool shadow_allocate_near(RID p_light) = 0; //true on successful alloc
+	virtual bool shadow_allocate_far(RID p_light) = 0; //true on successful alloc
 
 	/* PARTICLES INSTANCE */
 
-	virtual RID particles_instance_create(RID p_particles)=0;
-	virtual void particles_instance_set_transform(RID p_particles_instance,const Transform& p_transform)=0;
+	virtual RID particles_instance_create(RID p_particles) = 0;
+	virtual void particles_instance_set_transform(RID p_particles_instance, const Transform &p_transform) = 0;
 
 	/* RENDER API */
 	/* all calls (inside begin/end shadow) are always warranted to be in the following order: */
 
 	/* VIEWPORT API */
 
-	virtual RID viewport_data_create()=0;
+	virtual RID viewport_data_create() = 0;
 
-	virtual RID render_target_create()=0;
-	virtual void render_target_set_size(RID p_render_target, int p_width, int p_height)=0;
-	virtual RID render_target_get_texture(RID p_render_target) const=0;
-	virtual bool render_target_renedered_in_frame(RID p_render_target)=0;
+	virtual RID render_target_create() = 0;
+	virtual void render_target_set_size(RID p_render_target, int p_width, int p_height) = 0;
+	virtual RID render_target_get_texture(RID p_render_target) const = 0;
+	virtual bool render_target_renedered_in_frame(RID p_render_target) = 0;
 
-	virtual void begin_frame()=0;
+	virtual void begin_frame() = 0;
 
-	virtual void set_viewport(const VS::ViewportRect& p_viewport)=0;
-	virtual void set_render_target(RID p_render_target,bool p_transparent_bg=false,bool p_vflip=false)=0;
-	virtual void clear_viewport(const Color& p_color)=0;
-	virtual void capture_viewport(Image* r_capture)=0;
+	virtual void set_viewport(const VS::ViewportRect &p_viewport) = 0;
+	virtual void set_render_target(RID p_render_target, bool p_transparent_bg = false, bool p_vflip = false) = 0;
+	virtual void clear_viewport(const Color &p_color) = 0;
+	virtual void capture_viewport(Image *r_capture) = 0;
 
-	virtual void begin_scene(RID p_viewport_data,RID p_env,VS::ScenarioDebugMode p_debug)=0;
-	virtual void begin_shadow_map( RID p_light_instance, int p_shadow_pass )=0;
+	virtual void begin_scene(RID p_viewport_data, RID p_env, VS::ScenarioDebugMode p_debug) = 0;
+	virtual void begin_shadow_map(RID p_light_instance, int p_shadow_pass) = 0;
 
-	virtual void set_camera(const Transform& p_world,const CameraMatrix& p_projection,bool p_ortho_hint)=0;
+	virtual void set_camera(const Transform &p_world, const CameraMatrix &p_projection, bool p_ortho_hint) = 0;
 
-	virtual void add_light( RID p_light_instance )=0; ///< all "add_light" calls happen before add_geometry calls
+	virtual void add_light(RID p_light_instance) = 0; ///< all "add_light" calls happen before add_geometry calls
 
-	typedef Map<StringName,Variant> ParamOverrideMap;
+	typedef Map<StringName, Variant> ParamOverrideMap;
 
 	struct BakedLightData {
 
@@ -520,7 +502,7 @@ public:
 		RID light_texture;
 		float color_multiplier; //used for both lightmaps and octree
 		Transform octree_transform;
-		Map<int,RID> lightmaps;
+		Map<int, RID> lightmaps;
 		//cache
 
 		float octree_lattice_size;
@@ -549,42 +531,37 @@ public:
 		VS::ShadowCastingSetting cast_shadows;
 		Transform *baked_light_octree_xform;
 		int baked_lightmap_id;
-		bool mirror :8;
-		bool depth_scale :8;
-		bool billboard :8;
-		bool billboard_y :8;
+		bool mirror : 8;
+		bool depth_scale : 8;
+		bool billboard : 8;
+		bool billboard_y : 8;
 		bool receive_shadows : 8;
-
 	};
 
-	virtual void add_mesh( const RID& p_mesh, const InstanceData *p_data)=0;
-	virtual void add_multimesh( const RID& p_multimesh, const InstanceData *p_data)=0;
-	virtual void add_immediate( const RID& p_immediate, const InstanceData *p_data)=0;
-	virtual void add_particles( const RID& p_particle_instance, const InstanceData *p_data)=0;
-
+	virtual void add_mesh(const RID &p_mesh, const InstanceData *p_data) = 0;
+	virtual void add_multimesh(const RID &p_multimesh, const InstanceData *p_data) = 0;
+	virtual void add_immediate(const RID &p_immediate, const InstanceData *p_data) = 0;
+	virtual void add_particles(const RID &p_particle_instance, const InstanceData *p_data) = 0;
 
-	virtual void end_scene()=0;
-	virtual void end_shadow_map()=0;
+	virtual void end_scene() = 0;
+	virtual void end_shadow_map() = 0;
 
-	virtual void end_frame()=0;
+	virtual void end_frame() = 0;
 	virtual void flush_frame(); //not necesary in most cases
 
 	/* CANVAS API */
 
 	enum CanvasRectFlags {
 
-		CANVAS_RECT_REGION=1,
-		CANVAS_RECT_TILE=2,
-		CANVAS_RECT_FLIP_H=4,
-		CANVAS_RECT_FLIP_V=8,
-		CANVAS_RECT_TRANSPOSE=16
+		CANVAS_RECT_REGION = 1,
+		CANVAS_RECT_TILE = 2,
+		CANVAS_RECT_FLIP_H = 4,
+		CANVAS_RECT_FLIP_V = 8,
+		CANVAS_RECT_TRANSPOSE = 16
 	};
 
-
 	struct CanvasLight {
 
-
-
 		bool enabled;
 		Color color;
 		Matrix32 xform;
@@ -606,7 +583,6 @@ public:
 		float shadow_esm_mult;
 		Color shadow_color;
 
-
 		void *texture_cache; // implementation dependent
 		Rect2 rect_cache;
 		Matrix32 xform_cache;
@@ -622,40 +598,42 @@ public:
 		CanvasLight *mask_next_ptr;
 
 		CanvasLight() {
-			enabled=true;
-			color=Color(1,1,1);
-			shadow_color=Color(0,0,0,0);
-			height=0;
-			z_min=-1024;
-			z_max=1024;
-			layer_min=0;
-			layer_max=0;
-			item_mask=1;
-			scale=1.0;
-			energy=1.0;
-			item_shadow_mask=-1;
-			mode=VS::CANVAS_LIGHT_MODE_ADD;
-			texture_cache=NULL;
-			next_ptr=NULL;
-			mask_next_ptr=NULL;
-			filter_next_ptr=NULL;
-			shadow_buffer_size=2048;
-			shadow_esm_mult=80;
-
+			enabled = true;
+			color = Color(1, 1, 1);
+			shadow_color = Color(0, 0, 0, 0);
+			height = 0;
+			z_min = -1024;
+			z_max = 1024;
+			layer_min = 0;
+			layer_max = 0;
+			item_mask = 1;
+			scale = 1.0;
+			energy = 1.0;
+			item_shadow_mask = -1;
+			mode = VS::CANVAS_LIGHT_MODE_ADD;
+			texture_cache = NULL;
+			next_ptr = NULL;
+			mask_next_ptr = NULL;
+			filter_next_ptr = NULL;
+			shadow_buffer_size = 2048;
+			shadow_esm_mult = 80;
 		}
 	};
 
 	struct CanvasItem;
 
-	struct CanvasItemMaterial  {
+	struct CanvasItemMaterial {
 
 		RID shader;
-		Map<StringName,Variant> shader_param;
+		Map<StringName, Variant> shader_param;
 		uint32_t shader_version;
-		Set<CanvasItem*> owners;
+		Set<CanvasItem *> owners;
 		VS::CanvasItemShadingMode shading_mode;
 
-		CanvasItemMaterial() {shading_mode=VS::CANVAS_ITEM_SHADING_NORMAL; shader_version=0; }
+		CanvasItemMaterial() {
+			shading_mode = VS::CANVAS_ITEM_SHADING_NORMAL;
+			shader_version = 0;
+		}
 	};
 
 	struct CanvasItem {
@@ -677,12 +655,12 @@ public:
 			};
 
 			Type type;
-			virtual ~Command(){}
+			virtual ~Command() {}
 		};
 
 		struct CommandLine : public Command {
 
-			Point2 from,to;
+			Point2 from, to;
 			Color color;
 			float width;
 			CommandLine() { type = TYPE_LINE; }
@@ -696,7 +674,10 @@ public:
 			Rect2 source;
 			uint8_t flags;
 
-			CommandRect() { flags=0; type = TYPE_RECT; }
+			CommandRect() {
+				flags = 0;
+				type = TYPE_RECT;
+			}
 		};
 
 		struct CommandStyle : public Command {
@@ -707,7 +688,10 @@ public:
 			float margin[4];
 			bool draw_center;
 			Color color;
-			CommandStyle() { draw_center=true; type = TYPE_STYLE; }
+			CommandStyle() {
+				draw_center = true;
+				type = TYPE_STYLE;
+			}
 		};
 
 		struct CommandPrimitive : public Command {
@@ -718,7 +702,10 @@ public:
 			RID texture;
 			float width;
 
-			CommandPrimitive() { type = TYPE_PRIMITIVE; width=1;}
+			CommandPrimitive() {
+				type = TYPE_PRIMITIVE;
+				width = 1;
+			}
 		};
 
 		struct CommandPolygon : public Command {
@@ -730,19 +717,25 @@ public:
 			RID texture;
 			int count;
 
-			CommandPolygon() { type = TYPE_POLYGON; count = 0; }
+			CommandPolygon() {
+				type = TYPE_POLYGON;
+				count = 0;
+			}
 		};
 
 		struct CommandPolygonPtr : public Command {
 
-			const int* indices;
-			const Point2* points;
-			const Point2* uvs;
-			const Color* colors;
+			const int *indices;
+			const Point2 *points;
+			const Point2 *uvs;
+			const Color *colors;
 			RID texture;
 			int count;
 
-			CommandPolygonPtr() { type = TYPE_POLYGON_PTR; count = 0; }
+			CommandPolygonPtr() {
+				type = TYPE_POLYGON_PTR;
+				count = 0;
+			}
 		};
 
 		struct CommandCircle : public Command {
@@ -762,18 +755,23 @@ public:
 		struct CommandBlendMode : public Command {
 
 			VS::MaterialBlendMode blend_mode;
-			CommandBlendMode() { type = TYPE_BLEND_MODE; blend_mode = VS::MATERIAL_BLEND_MODE_MIX; }
+			CommandBlendMode() {
+				type = TYPE_BLEND_MODE;
+				blend_mode = VS::MATERIAL_BLEND_MODE_MIX;
+			}
 		};
 		struct CommandClipIgnore : public Command {
 
 			bool ignore;
-			CommandClipIgnore() { type = TYPE_CLIP_IGNORE; ignore=false; }
+			CommandClipIgnore() {
+				type = TYPE_CLIP_IGNORE;
+				ignore = false;
+			}
 		};
 
-
 		struct ViewportRender {
-			VisualServer*owner;
-			void* udata;
+			VisualServer *owner;
+			void *udata;
 			Rect2 rect;
 		};
 
@@ -783,12 +781,12 @@ public:
 		bool ontop;
 		VS::MaterialBlendMode blend_mode;
 		int light_mask;
-		Vector<Command*> commands;
+		Vector<Command *> commands;
 		mutable bool custom_rect;
 		mutable bool rect_dirty;
 		mutable Rect2 rect;
-		CanvasItem*next;
-		CanvasItemMaterial* material;
+		CanvasItem *next;
+		CanvasItemMaterial *material;
 		struct CopyBackBuffer {
 			Rect2 rect;
 			Rect2 screen_rect;
@@ -796,98 +794,94 @@ public:
 		};
 		CopyBackBuffer *copy_back_buffer;
 
-
 		float final_opacity;
 		Matrix32 final_transform;
 		Rect2 final_clip_rect;
-		CanvasItem* final_clip_owner;
-		CanvasItem* material_owner;
+		CanvasItem *final_clip_owner;
+		CanvasItem *material_owner;
 		ViewportRender *vp_render;
 		bool distance_field;
 		bool light_masked;
 
 		Rect2 global_rect_cache;
 
-		const Rect2& get_rect() const {
+		const Rect2 &get_rect() const {
 			if (custom_rect || !rect_dirty)
 				return rect;
 
 			//must update rect
-			int s=commands.size();
-			if (s==0) {
+			int s = commands.size();
+			if (s == 0) {
 
-				rect=Rect2();
-				rect_dirty=false;
+				rect = Rect2();
+				rect_dirty = false;
 				return rect;
 			}
 
 			Matrix32 xf;
-			bool found_xform=false;
-			bool first=true;
-
-			const CanvasItem::Command * const *cmd = &commands[0];
+			bool found_xform = false;
+			bool first = true;
 
+			const CanvasItem::Command *const *cmd = &commands[0];
 
-			for (int i=0;i<s;i++) {
+			for (int i = 0; i < s; i++) {
 
-				const  CanvasItem::Command *c=cmd[i];
+				const CanvasItem::Command *c = cmd[i];
 				Rect2 r;
 
-				switch(c->type) {
+				switch (c->type) {
 					case CanvasItem::Command::TYPE_LINE: {
 
-						const CanvasItem::CommandLine* line = static_cast< const CanvasItem::CommandLine*>(c);
-						r.pos=line->from;
+						const CanvasItem::CommandLine *line = static_cast<const CanvasItem::CommandLine *>(c);
+						r.pos = line->from;
 						r.expand_to(line->to);
 					} break;
 					case CanvasItem::Command::TYPE_RECT: {
 
-						const CanvasItem::CommandRect* crect = static_cast< const CanvasItem::CommandRect*>(c);
-						r=crect->rect;
+						const CanvasItem::CommandRect *crect = static_cast<const CanvasItem::CommandRect *>(c);
+						r = crect->rect;
 
 					} break;
 					case CanvasItem::Command::TYPE_STYLE: {
 
-						const CanvasItem::CommandStyle* style = static_cast< const CanvasItem::CommandStyle*>(c);
-						r=style->rect;
+						const CanvasItem::CommandStyle *style = static_cast<const CanvasItem::CommandStyle *>(c);
+						r = style->rect;
 					} break;
 					case CanvasItem::Command::TYPE_PRIMITIVE: {
 
-						const CanvasItem::CommandPrimitive* primitive = static_cast< const CanvasItem::CommandPrimitive*>(c);
-						r.pos=primitive->points[0];
-						for(int i=1;i<primitive->points.size();i++) {
+						const CanvasItem::CommandPrimitive *primitive = static_cast<const CanvasItem::CommandPrimitive *>(c);
+						r.pos = primitive->points[0];
+						for (int i = 1; i < primitive->points.size(); i++) {
 
 							r.expand_to(primitive->points[i]);
-
 						}
 					} break;
 					case CanvasItem::Command::TYPE_POLYGON: {
 
-						const CanvasItem::CommandPolygon* polygon = static_cast< const CanvasItem::CommandPolygon*>(c);
+						const CanvasItem::CommandPolygon *polygon = static_cast<const CanvasItem::CommandPolygon *>(c);
 						int l = polygon->points.size();
-						const Point2*pp=&polygon->points[0];
-						r.pos=pp[0];
-						for(int i=1;i<l;i++) {
+						const Point2 *pp = &polygon->points[0];
+						r.pos = pp[0];
+						for (int i = 1; i < l; i++) {
 
 							r.expand_to(pp[i]);
-
 						}
 					} break;
 
 					case CanvasItem::Command::TYPE_POLYGON_PTR: {
 
-						const CanvasItem::CommandPolygonPtr* polygon = static_cast< const CanvasItem::CommandPolygonPtr*>(c);
+						const CanvasItem::CommandPolygonPtr *polygon = static_cast<const CanvasItem::CommandPolygonPtr *>(c);
 						int l = polygon->count;
 						if (polygon->indices != NULL) {
 
-							r.pos=polygon->points[polygon->indices[0]];
-							for (int i=1; i<l; i++) {
+							r.pos = polygon->points[polygon->indices[0]];
+							for (int i = 1; i < l; i++) {
 
 								r.expand_to(polygon->points[polygon->indices[i]]);
 							}
 						} else {
-							r.pos=polygon->points[0];
-							for (int i=1; i<l; i++) {
+							r.pos = polygon->points[0];
+							for (int i = 1; i < l; i++) {
 
 								r.expand_to(polygon->points[i]);
 							}
@@ -895,15 +889,15 @@ public:
 					} break;
 					case CanvasItem::Command::TYPE_CIRCLE: {
 
-						const CanvasItem::CommandCircle* circle = static_cast< const CanvasItem::CommandCircle*>(c);
-						r.pos=Point2(-circle->radius,-circle->radius)+circle->pos;
-						r.size=Point2(circle->radius*2.0,circle->radius*2.0);
+						const CanvasItem::CommandCircle *circle = static_cast<const CanvasItem::CommandCircle *>(c);
+						r.pos = Point2(-circle->radius, -circle->radius) + circle->pos;
+						r.size = Point2(circle->radius * 2.0, circle->radius * 2.0);
 					} break;
 					case CanvasItem::Command::TYPE_TRANSFORM: {
 
-						const CanvasItem::CommandTransform* transform = static_cast<const CanvasItem::CommandTransform*>(c);
-						xf=transform->xform;
-						found_xform=true;
+						const CanvasItem::CommandTransform *transform = static_cast<const CanvasItem::CommandTransform *>(c);
+						xf = transform->xform;
+						found_xform = true;
 						continue;
 					} break;
 					case CanvasItem::Command::TYPE_BLEND_MODE: {
@@ -916,58 +910,82 @@ public:
 
 				if (found_xform) {
 					r = xf.xform(r);
-					found_xform=false;
+					found_xform = false;
 				}
 
-
 				if (first) {
-					rect=r;
-					first=false;
+					rect = r;
+					first = false;
 				} else
-					rect=rect.merge(r);
+					rect = rect.merge(r);
 			}
 
-			rect_dirty=false;
+			rect_dirty = false;
 			return rect;
 		}
 
-		void clear() { for (int i=0;i<commands.size();i++) memdelete( commands[i] ); commands.clear(); clip=false; rect_dirty=true; final_clip_owner=NULL;  material_owner=NULL; light_masked=false; }
-		CanvasItem() { light_mask=1; vp_render=NULL; next=NULL; final_clip_owner=NULL; clip=false; final_opacity=1;  blend_mode=VS::MATERIAL_BLEND_MODE_MIX; visible=true; rect_dirty=true; custom_rect=false; ontop=true; material_owner=NULL; material=NULL; copy_back_buffer=NULL; distance_field=false; light_masked=false; }
-		virtual ~CanvasItem() { clear(); if (copy_back_buffer) memdelete(copy_back_buffer); }
+		void clear() {
+			for (int i = 0; i < commands.size(); i++)
+				memdelete(commands[i]);
+			commands.clear();
+			clip = false;
+			rect_dirty = true;
+			final_clip_owner = NULL;
+			material_owner = NULL;
+			light_masked = false;
+		}
+		CanvasItem() {
+			light_mask = 1;
+			vp_render = NULL;
+			next = NULL;
+			final_clip_owner = NULL;
+			clip = false;
+			final_opacity = 1;
+			blend_mode = VS::MATERIAL_BLEND_MODE_MIX;
+			visible = true;
+			rect_dirty = true;
+			custom_rect = false;
+			ontop = true;
+			material_owner = NULL;
+			material = NULL;
+			copy_back_buffer = NULL;
+			distance_field = false;
+			light_masked = false;
+		}
+		virtual ~CanvasItem() {
+			clear();
+			if (copy_back_buffer) memdelete(copy_back_buffer);
+		}
 	};
 
-
 	CanvasItemDrawViewportFunc draw_viewport_func;
 
+	virtual void begin_canvas_bg() = 0;
+	virtual void canvas_begin() = 0;
+	virtual void canvas_disable_blending() = 0;
+	virtual void canvas_set_opacity(float p_opacity) = 0;
+	virtual void canvas_set_blend_mode(VS::MaterialBlendMode p_mode) = 0;
+	virtual void canvas_begin_rect(const Matrix32 &p_transform) = 0;
+	virtual void canvas_set_clip(bool p_clip, const Rect2 &p_rect) = 0;
+	virtual void canvas_end_rect() = 0;
+	virtual void canvas_draw_line(const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width) = 0;
+	virtual void canvas_draw_rect(const Rect2 &p_rect, int p_flags, const Rect2 &p_source, RID p_texture, const Color &p_modulate) = 0;
+	virtual void canvas_draw_style_box(const Rect2 &p_rect, const Rect2 &p_src_region, RID p_texture, const float *p_margins, bool p_draw_center = true, const Color &p_modulate = Color(1, 1, 1)) = 0;
+	virtual void canvas_draw_primitive(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width) = 0;
+	virtual void canvas_draw_polygon(int p_vertex_count, const int *p_indices, const Vector2 *p_vertices, const Vector2 *p_uvs, const Color *p_colors, const RID &p_texture, bool p_singlecolor) = 0;
+	virtual void canvas_set_transform(const Matrix32 &p_transform) = 0;
 
-	virtual void begin_canvas_bg()=0;
-	virtual void canvas_begin()=0;
-	virtual void canvas_disable_blending()=0;
-	virtual void canvas_set_opacity(float p_opacity)=0;
-	virtual void canvas_set_blend_mode(VS::MaterialBlendMode p_mode)=0;
-	virtual void canvas_begin_rect(const Matrix32& p_transform)=0;
-	virtual void canvas_set_clip(bool p_clip, const Rect2& p_rect)=0;
-	virtual void canvas_end_rect()=0;
-	virtual void canvas_draw_line(const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width)=0;
-	virtual void canvas_draw_rect(const Rect2& p_rect, int p_flags, const Rect2& p_source,RID p_texture,const Color& p_modulate)=0;
-	virtual void canvas_draw_style_box(const Rect2& p_rect, const Rect2& p_src_region, RID p_texture,const float *p_margins, bool p_draw_center=true,const Color& p_modulate=Color(1,1,1))=0;
-	virtual void canvas_draw_primitive(const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture,float p_width)=0;
-	virtual void canvas_draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor)=0;
-	virtual void canvas_set_transform(const Matrix32& p_transform)=0;
-
-	virtual void canvas_render_items(CanvasItem *p_item_list,int p_z,const Color& p_modulate,CanvasLight *p_light)=0;
-	virtual void canvas_debug_viewport_shadows(CanvasLight* p_lights_with_shadow)=0;
+	virtual void canvas_render_items(CanvasItem *p_item_list, int p_z, const Color &p_modulate, CanvasLight *p_light) = 0;
+	virtual void canvas_debug_viewport_shadows(CanvasLight *p_lights_with_shadow) = 0;
 	/* LIGHT SHADOW MAPPING */
 
-	virtual RID canvas_light_occluder_create()=0;
-	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines)=0;
-
+	virtual RID canvas_light_occluder_create() = 0;
+	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2> &p_lines) = 0;
 
-	virtual RID canvas_light_shadow_buffer_create(int p_width)=0;
+	virtual RID canvas_light_shadow_buffer_create(int p_width) = 0;
 
 	struct CanvasLightOccluderInstance {
 
-
 		bool enabled;
 		RID canvas;
 		RID polygon;
@@ -980,67 +998,68 @@ public:
 
 		CanvasLightOccluderInstance *next;
 
-		CanvasLightOccluderInstance() { enabled=true; next=NULL; light_mask=1; cull_cache=VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED; }
+		CanvasLightOccluderInstance() {
+			enabled = true;
+			next = NULL;
+			light_mask = 1;
+			cull_cache = VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+		}
 	};
 
-
-
-	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, CanvasLightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache)=0;
+	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32 &p_light_xform, int p_light_mask, float p_near, float p_far, CanvasLightOccluderInstance *p_occluders, CameraMatrix *p_xform_cache) = 0;
 
 	/* ENVIRONMENT */
 
+	virtual RID environment_create() = 0;
 
-	virtual RID environment_create()=0;
-
-	virtual void environment_set_background(RID p_env,VS::EnvironmentBG p_bg)=0;
-	virtual VS::EnvironmentBG environment_get_background(RID p_env) const=0;
+	virtual void environment_set_background(RID p_env, VS::EnvironmentBG p_bg) = 0;
+	virtual VS::EnvironmentBG environment_get_background(RID p_env) const = 0;
 
-	virtual void environment_set_background_param(RID p_env,VS::EnvironmentBGParam p_param, const Variant& p_value)=0;
-	virtual Variant environment_get_background_param(RID p_env,VS::EnvironmentBGParam p_param) const=0;
+	virtual void environment_set_background_param(RID p_env, VS::EnvironmentBGParam p_param, const Variant &p_value) = 0;
+	virtual Variant environment_get_background_param(RID p_env, VS::EnvironmentBGParam p_param) const = 0;
 
-	virtual void environment_set_enable_fx(RID p_env,VS::EnvironmentFx p_effect,bool p_enabled)=0;
-	virtual bool environment_is_fx_enabled(RID p_env,VS::EnvironmentFx p_effect) const=0;
+	virtual void environment_set_enable_fx(RID p_env, VS::EnvironmentFx p_effect, bool p_enabled) = 0;
+	virtual bool environment_is_fx_enabled(RID p_env, VS::EnvironmentFx p_effect) const = 0;
 
-	virtual void environment_fx_set_param(RID p_env,VS::EnvironmentFxParam p_param,const Variant& p_value)=0;
-	virtual Variant environment_fx_get_param(RID p_env,VS::EnvironmentFxParam p_param) const=0;
+	virtual void environment_fx_set_param(RID p_env, VS::EnvironmentFxParam p_param, const Variant &p_value) = 0;
+	virtual Variant environment_fx_get_param(RID p_env, VS::EnvironmentFxParam p_param) const = 0;
 
 	/* SAMPLED LIGHT */
-	virtual RID sampled_light_dp_create(int p_width,int p_height)=0;
-	virtual void sampled_light_dp_update(RID p_sampled_light,const Color *p_data,float p_multiplier)=0;
-
+	virtual RID sampled_light_dp_create(int p_width, int p_height) = 0;
+	virtual void sampled_light_dp_update(RID p_sampled_light, const Color *p_data, float p_multiplier) = 0;
 
 	/*MISC*/
 
-	virtual bool is_texture(const RID& p_rid) const=0;
-	virtual bool is_material(const RID& p_rid) const=0;
-	virtual bool is_mesh(const RID& p_rid) const=0;
-	virtual bool is_multimesh(const RID& p_rid) const=0;
-	virtual bool is_immediate(const RID& p_rid) const=0;
-	virtual bool is_particles(const RID &p_beam) const=0;
+	virtual bool is_texture(const RID &p_rid) const = 0;
+	virtual bool is_material(const RID &p_rid) const = 0;
+	virtual bool is_mesh(const RID &p_rid) const = 0;
+	virtual bool is_multimesh(const RID &p_rid) const = 0;
+	virtual bool is_immediate(const RID &p_rid) const = 0;
+	virtual bool is_particles(const RID &p_beam) const = 0;
 
-	virtual bool is_light(const RID& p_rid) const=0;
-	virtual bool is_light_instance(const RID& p_rid) const=0;
-	virtual bool is_particles_instance(const RID& p_rid) const=0;
-	virtual bool is_skeleton(const RID& p_rid) const=0;
-	virtual bool is_environment(const RID& p_rid) const=0;
-	virtual bool is_shader(const RID& p_rid) const=0;
+	virtual bool is_light(const RID &p_rid) const = 0;
+	virtual bool is_light_instance(const RID &p_rid) const = 0;
+	virtual bool is_particles_instance(const RID &p_rid) const = 0;
+	virtual bool is_skeleton(const RID &p_rid) const = 0;
+	virtual bool is_environment(const RID &p_rid) const = 0;
+	virtual bool is_shader(const RID &p_rid) const = 0;
 
-	virtual bool is_canvas_light_occluder(const RID& p_rid) const=0;
+	virtual bool is_canvas_light_occluder(const RID &p_rid) const = 0;
 
-	virtual void free(const RID& p_rid)=0;
+	virtual void free(const RID &p_rid) = 0;
 
-	virtual void init()=0;
-	virtual void finish()=0;
+	virtual void init() = 0;
+	virtual void finish() = 0;
 
-	virtual bool needs_to_draw_next_frame() const=0;
+	virtual bool needs_to_draw_next_frame() const = 0;
 
 	virtual void reload_vram() {}
 
-	virtual bool has_feature(VS::Features p_feature) const=0;
+	virtual bool has_feature(VS::Features p_feature) const = 0;
 
-	virtual void restore_framebuffer()=0;
+	virtual void restore_framebuffer() = 0;
 
-	virtual int get_render_info(VS::RenderInfo p_info)=0;
+	virtual int get_render_info(VS::RenderInfo p_info) = 0;
 
 	virtual void set_force_16_bits_fbo(bool p_force) {}
 
@@ -1048,6 +1067,4 @@ public:
 	virtual ~Rasterizer() {}
 };
 
-
-
 #endif
diff --git a/servers/visual/rasterizer_dummy.cpp b/servers/visual/rasterizer_dummy.cpp
index 611b4d186..be3a4e383 100644
--- a/servers/visual/rasterizer_dummy.cpp
+++ b/servers/visual/rasterizer_dummy.cpp
@@ -30,115 +30,105 @@
 
 /* TEXTURE API */
 
-
 RID RasterizerDummy::texture_create() {
 
 	Texture *texture = memnew(Texture);
-	ERR_FAIL_COND_V(!texture,RID());
-	return texture_owner.make_rid( texture );
-
+	ERR_FAIL_COND_V(!texture, RID());
+	return texture_owner.make_rid(texture);
 }
 
-void RasterizerDummy::texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags) {
-
+void RasterizerDummy::texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags) {
 
-	Texture *texture = texture_owner.get( p_texture );
+	Texture *texture = texture_owner.get(p_texture);
 	ERR_FAIL_COND(!texture);
-	texture->width=p_width;
-	texture->height=p_height;
-	texture->format=p_format;
-	texture->flags=p_flags;
+	texture->width = p_width;
+	texture->height = p_height;
+	texture->format = p_format;
+	texture->flags = p_flags;
 }
 
-void RasterizerDummy::texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side) {
+void RasterizerDummy::texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side) {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
 	ERR_FAIL_COND(!texture);
-	ERR_FAIL_COND(texture->format != p_image.get_format() );
-
-	texture->image[p_cube_side]=p_image;
+	ERR_FAIL_COND(texture->format != p_image.get_format());
 
+	texture->image[p_cube_side] = p_image;
 }
 
-Image RasterizerDummy::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side) const {
+Image RasterizerDummy::texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side) const {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,Image());
+	ERR_FAIL_COND_V(!texture, Image());
 
 	return texture->image[p_cube_side];
 }
 
-void RasterizerDummy::texture_set_flags(RID p_texture,uint32_t p_flags) {
+void RasterizerDummy::texture_set_flags(RID p_texture, uint32_t p_flags) {
 
-	Texture *texture = texture_owner.get( p_texture );
+	Texture *texture = texture_owner.get(p_texture);
 	ERR_FAIL_COND(!texture);
 	uint32_t cube = texture->flags & VS::TEXTURE_FLAG_CUBEMAP;
-	texture->flags=p_flags|cube; // can't remove a cube from being a cube
-
+	texture->flags = p_flags | cube; // can't remove a cube from being a cube
 }
 uint32_t RasterizerDummy::texture_get_flags(RID p_texture) const {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,0);
+	ERR_FAIL_COND_V(!texture, 0);
 
 	return texture->flags;
-
 }
 Image::Format RasterizerDummy::texture_get_format(RID p_texture) const {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,Image::FORMAT_GRAYSCALE);
+	ERR_FAIL_COND_V(!texture, Image::FORMAT_GRAYSCALE);
 
 	return texture->format;
 }
 uint32_t RasterizerDummy::texture_get_width(RID p_texture) const {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,0);
+	ERR_FAIL_COND_V(!texture, 0);
 
 	return texture->width;
 }
 uint32_t RasterizerDummy::texture_get_height(RID p_texture) const {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,0);
+	ERR_FAIL_COND_V(!texture, 0);
 
 	return texture->height;
 }
 
 bool RasterizerDummy::texture_has_alpha(RID p_texture) const {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,0);
+	ERR_FAIL_COND_V(!texture, 0);
 
 	return false;
-
 }
 
-void RasterizerDummy::texture_set_size_override(RID p_texture,int p_width, int p_height) {
+void RasterizerDummy::texture_set_size_override(RID p_texture, int p_width, int p_height) {
 
-	Texture * texture = texture_owner.get(p_texture);
+	Texture *texture = texture_owner.get(p_texture);
 
 	ERR_FAIL_COND(!texture);
 
-	ERR_FAIL_COND(p_width<=0 || p_width>4096);
-	ERR_FAIL_COND(p_height<=0 || p_height>4096);
+	ERR_FAIL_COND(p_width <= 0 || p_width > 4096);
+	ERR_FAIL_COND(p_height <= 0 || p_height > 4096);
 	//real texture size is in alloc width and height
-//	texture->width=p_width;
-//	texture->height=p_height;
-
+	//	texture->width=p_width;
+	//	texture->height=p_height;
 }
 
-void RasterizerDummy::texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName& p_function) const {
-
-
+void RasterizerDummy::texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function) const {
 }
 
 /* SHADER API */
@@ -147,132 +137,117 @@ void RasterizerDummy::texture_set_reload_hook(RID p_texture,ObjectID p_owner,con
 
 RID RasterizerDummy::shader_create(VS::ShaderMode p_mode) {
 
-	Shader *shader = memnew( Shader );
-	shader->mode=p_mode;
-	shader->fragment_line=0;
-	shader->vertex_line=0;
-	shader->light_line=0;
+	Shader *shader = memnew(Shader);
+	shader->mode = p_mode;
+	shader->fragment_line = 0;
+	shader->vertex_line = 0;
+	shader->light_line = 0;
 	RID rid = shader_owner.make_rid(shader);
 
 	return rid;
-
 }
 
+void RasterizerDummy::shader_set_mode(RID p_shader, VS::ShaderMode p_mode) {
 
-
-void RasterizerDummy::shader_set_mode(RID p_shader,VS::ShaderMode p_mode) {
-
-	ERR_FAIL_INDEX(p_mode,3);
-	Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_INDEX(p_mode, 3);
+	Shader *shader = shader_owner.get(p_shader);
 	ERR_FAIL_COND(!shader);
-	shader->mode=p_mode;
-
+	shader->mode = p_mode;
 }
 VS::ShaderMode RasterizerDummy::shader_get_mode(RID p_shader) const {
 
-	Shader *shader=shader_owner.get(p_shader);
-	ERR_FAIL_COND_V(!shader,VS::SHADER_MATERIAL);
+	Shader *shader = shader_owner.get(p_shader);
+	ERR_FAIL_COND_V(!shader, VS::SHADER_MATERIAL);
 	return shader->mode;
 }
 
-void RasterizerDummy::shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs,int p_fragment_ofs,int p_light_ofs) {
-
+void RasterizerDummy::shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs, int p_fragment_ofs, int p_light_ofs) {
 
-	Shader *shader=shader_owner.get(p_shader);
+	Shader *shader = shader_owner.get(p_shader);
 	ERR_FAIL_COND(!shader);
-	shader->fragment_code=p_fragment;
-	shader->vertex_code=p_vertex;
-	shader->light_code=p_light;
-	shader->fragment_line=p_fragment_ofs;
-	shader->vertex_line=p_vertex_ofs;
-	shader->light_line=p_vertex_ofs;
-
+	shader->fragment_code = p_fragment;
+	shader->vertex_code = p_vertex;
+	shader->light_code = p_light;
+	shader->fragment_line = p_fragment_ofs;
+	shader->vertex_line = p_vertex_ofs;
+	shader->light_line = p_vertex_ofs;
 }
 
-
 String RasterizerDummy::shader_get_vertex_code(RID p_shader) const {
 
-	Shader *shader=shader_owner.get(p_shader);
-	ERR_FAIL_COND_V(!shader,String());
+	Shader *shader = shader_owner.get(p_shader);
+	ERR_FAIL_COND_V(!shader, String());
 	return shader->vertex_code;
-
 }
 
 String RasterizerDummy::shader_get_fragment_code(RID p_shader) const {
 
-	Shader *shader=shader_owner.get(p_shader);
-	ERR_FAIL_COND_V(!shader,String());
+	Shader *shader = shader_owner.get(p_shader);
+	ERR_FAIL_COND_V(!shader, String());
 	return shader->fragment_code;
-
 }
 
 String RasterizerDummy::shader_get_light_code(RID p_shader) const {
 
-	Shader *shader=shader_owner.get(p_shader);
-	ERR_FAIL_COND_V(!shader,String());
+	Shader *shader = shader_owner.get(p_shader);
+	ERR_FAIL_COND_V(!shader, String());
 	return shader->light_code;
-
 }
 
 void RasterizerDummy::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
 
-	Shader *shader=shader_owner.get(p_shader);
+	Shader *shader = shader_owner.get(p_shader);
 	ERR_FAIL_COND(!shader);
-
 }
 
-
-void RasterizerDummy::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture) {
-
+void RasterizerDummy::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
 }
 
-RID RasterizerDummy::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const {
+RID RasterizerDummy::shader_get_default_texture_param(RID p_shader, const StringName &p_name) const {
 
 	return RID();
 }
 
-Variant RasterizerDummy::shader_get_default_param(RID p_shader, const StringName& p_name) {
+Variant RasterizerDummy::shader_get_default_param(RID p_shader, const StringName &p_name) {
 
 	return Variant();
 }
 
 /* COMMON MATERIAL API */
 
-
 RID RasterizerDummy::material_create() {
 
-	return material_owner.make_rid( memnew( Material ) );
+	return material_owner.make_rid(memnew(Material));
 }
 
 void RasterizerDummy::material_set_shader(RID p_material, RID p_shader) {
 
 	Material *material = material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	material->shader=p_shader;
-
+	material->shader = p_shader;
 }
 
 RID RasterizerDummy::material_get_shader(RID p_material) const {
 
 	Material *material = material_owner.get(p_material);
-	ERR_FAIL_COND_V(!material,RID());
+	ERR_FAIL_COND_V(!material, RID());
 	return material->shader;
 }
 
-void RasterizerDummy::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value) {
+void RasterizerDummy::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
 
 	Material *material = material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
 
-	if (p_value.get_type()==Variant::NIL)
+	if (p_value.get_type() == Variant::NIL)
 		material->shader_params.erase(p_param);
 	else
-		material->shader_params[p_param]=p_value;
+		material->shader_params[p_param] = p_value;
 }
-Variant RasterizerDummy::material_get_param(RID p_material, const StringName& p_param) const {
+Variant RasterizerDummy::material_get_param(RID p_material, const StringName &p_param) const {
 
 	Material *material = material_owner.get(p_material);
-	ERR_FAIL_COND_V(!material,Variant());
+	ERR_FAIL_COND_V(!material, Variant());
 
 	if (material->shader_params.has(p_param))
 		return material->shader_params[p_param];
@@ -280,313 +255,281 @@ Variant RasterizerDummy::material_get_param(RID p_material, const StringName& p_
 		return Variant();
 }
 
-
-void RasterizerDummy::material_set_flag(RID p_material, VS::MaterialFlag p_flag,bool p_enabled) {
+void RasterizerDummy::material_set_flag(RID p_material, VS::MaterialFlag p_flag, bool p_enabled) {
 
 	Material *material = material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	ERR_FAIL_INDEX(p_flag,VS::MATERIAL_FLAG_MAX);
-	material->flags[p_flag]=p_enabled;
-
+	ERR_FAIL_INDEX(p_flag, VS::MATERIAL_FLAG_MAX);
+	material->flags[p_flag] = p_enabled;
 }
-bool RasterizerDummy::material_get_flag(RID p_material,VS::MaterialFlag p_flag) const {
+bool RasterizerDummy::material_get_flag(RID p_material, VS::MaterialFlag p_flag) const {
 
 	Material *material = material_owner.get(p_material);
-	ERR_FAIL_COND_V(!material,false);
-	ERR_FAIL_INDEX_V(p_flag,VS::MATERIAL_FLAG_MAX,false);
+	ERR_FAIL_COND_V(!material, false);
+	ERR_FAIL_INDEX_V(p_flag, VS::MATERIAL_FLAG_MAX, false);
 	return material->flags[p_flag];
-
-
 }
 
 void RasterizerDummy::material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode) {
 
 	Material *material = material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	material->depth_draw_mode=p_mode;
+	material->depth_draw_mode = p_mode;
 }
 
-VS::MaterialDepthDrawMode RasterizerDummy::material_get_depth_draw_mode(RID p_material) const{
+VS::MaterialDepthDrawMode RasterizerDummy::material_get_depth_draw_mode(RID p_material) const {
 
 	Material *material = material_owner.get(p_material);
-	ERR_FAIL_COND_V(!material,VS::MATERIAL_DEPTH_DRAW_ALWAYS);
+	ERR_FAIL_COND_V(!material, VS::MATERIAL_DEPTH_DRAW_ALWAYS);
 	return material->depth_draw_mode;
-
 }
 
-
-void RasterizerDummy::material_set_blend_mode(RID p_material,VS::MaterialBlendMode p_mode) {
+void RasterizerDummy::material_set_blend_mode(RID p_material, VS::MaterialBlendMode p_mode) {
 
 	Material *material = material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	material->blend_mode=p_mode;
-
+	material->blend_mode = p_mode;
 }
 VS::MaterialBlendMode RasterizerDummy::material_get_blend_mode(RID p_material) const {
 
 	Material *material = material_owner.get(p_material);
-	ERR_FAIL_COND_V(!material,VS::MATERIAL_BLEND_MODE_ADD);
+	ERR_FAIL_COND_V(!material, VS::MATERIAL_BLEND_MODE_ADD);
 	return material->blend_mode;
 }
 
-void RasterizerDummy::material_set_line_width(RID p_material,float p_line_width) {
+void RasterizerDummy::material_set_line_width(RID p_material, float p_line_width) {
 
 	Material *material = material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	material->line_width=p_line_width;
-
+	material->line_width = p_line_width;
 }
 float RasterizerDummy::material_get_line_width(RID p_material) const {
 
 	Material *material = material_owner.get(p_material);
-	ERR_FAIL_COND_V(!material,0);
+	ERR_FAIL_COND_V(!material, 0);
 
 	return material->line_width;
 }
 
 /* MESH API */
 
-
 RID RasterizerDummy::mesh_create() {
 
-
-	return mesh_owner.make_rid( memnew( Mesh ) );
+	return mesh_owner.make_rid(memnew(Mesh));
 }
 
+void RasterizerDummy::mesh_add_surface(RID p_mesh, VS::PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes, bool p_alpha_sort) {
 
-void RasterizerDummy::mesh_add_surface(RID p_mesh,VS::PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes,bool p_alpha_sort) {
-
-	Mesh *mesh = mesh_owner.get( p_mesh );
+	Mesh *mesh = mesh_owner.get(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
-	ERR_FAIL_INDEX( p_primitive, VS::PRIMITIVE_MAX );
-	ERR_FAIL_COND(p_arrays.size()!=VS::ARRAY_MAX);
+	ERR_FAIL_INDEX(p_primitive, VS::PRIMITIVE_MAX);
+	ERR_FAIL_COND(p_arrays.size() != VS::ARRAY_MAX);
 
 	Surface s;
 
+	s.format = 0;
 
-	s.format=0;
-
-	for(int i=0;i<p_arrays.size();i++) {
+	for (int i = 0; i < p_arrays.size(); i++) {
 
-		if (p_arrays[i].get_type()==Variant::NIL)
+		if (p_arrays[i].get_type() == Variant::NIL)
 			continue;
 
-		s.format|=(1<<i);
+		s.format |= (1 << i);
 
-		if (i==VS::ARRAY_VERTEX) {
+		if (i == VS::ARRAY_VERTEX) {
 
 			Vector3Array v = p_arrays[i];
 			int len = v.size();
-			ERR_FAIL_COND(len==0);
+			ERR_FAIL_COND(len == 0);
 			Vector3Array::Read r = v.read();
 
+			for (int i = 0; i < len; i++) {
 
-			for(int i=0;i<len;i++) {
-
-				if (i==0)
-					s.aabb.pos=r[0];
+				if (i == 0)
+					s.aabb.pos = r[0];
 				else
 					s.aabb.expand_to(r[i]);
 			}
-
 		}
 	}
 
-	ERR_FAIL_COND((s.format&VS::ARRAY_FORMAT_VERTEX)==0); // mandatory
+	ERR_FAIL_COND((s.format & VS::ARRAY_FORMAT_VERTEX) == 0); // mandatory
 
-	s.data=p_arrays;
-	s.morph_data=p_blend_shapes;
-	s.primitive=p_primitive;
-	s.alpha_sort=p_alpha_sort;
-	s.morph_target_count=mesh->morph_target_count;
-	s.morph_format=s.format;
+	s.data = p_arrays;
+	s.morph_data = p_blend_shapes;
+	s.primitive = p_primitive;
+	s.alpha_sort = p_alpha_sort;
+	s.morph_target_count = mesh->morph_target_count;
+	s.morph_format = s.format;
 
-
-	Surface *surface = memnew( Surface );
-	*surface=s;
+	Surface *surface = memnew(Surface);
+	*surface = s;
 
 	mesh->surfaces.push_back(surface);
-
-
 }
 
-
-
-void RasterizerDummy::mesh_add_custom_surface(RID p_mesh,const Variant& p_dat) {
+void RasterizerDummy::mesh_add_custom_surface(RID p_mesh, const Variant &p_dat) {
 
 	ERR_EXPLAIN("Dummy Rasterizer does not support custom surfaces. Running on wrong platform?");
 	ERR_FAIL_V();
 }
 
-Array RasterizerDummy::mesh_get_surface_arrays(RID p_mesh,int p_surface) const {
+Array RasterizerDummy::mesh_get_surface_arrays(RID p_mesh, int p_surface) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,Array());
-	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Array() );
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, Array());
+	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Array());
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND_V( !surface, Array() );
+	ERR_FAIL_COND_V(!surface, Array());
 
 	return surface->data;
-
-
 }
-Array RasterizerDummy::mesh_get_surface_morph_arrays(RID p_mesh,int p_surface) const{
+Array RasterizerDummy::mesh_get_surface_morph_arrays(RID p_mesh, int p_surface) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,Array());
-	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Array() );
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, Array());
+	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Array());
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND_V( !surface, Array() );
+	ERR_FAIL_COND_V(!surface, Array());
 
 	return surface->morph_data;
-
 }
 
+void RasterizerDummy::mesh_set_morph_target_count(RID p_mesh, int p_amount) {
 
-void RasterizerDummy::mesh_set_morph_target_count(RID p_mesh,int p_amount) {
-
-	Mesh *mesh = mesh_owner.get( p_mesh );
+	Mesh *mesh = mesh_owner.get(p_mesh);
 	ERR_FAIL_COND(!mesh);
-	ERR_FAIL_COND( mesh->surfaces.size()!=0 );
-
-	mesh->morph_target_count=p_amount;
+	ERR_FAIL_COND(mesh->surfaces.size() != 0);
 
+	mesh->morph_target_count = p_amount;
 }
 
-int RasterizerDummy::mesh_get_morph_target_count(RID p_mesh) const{
+int RasterizerDummy::mesh_get_morph_target_count(RID p_mesh) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,-1);
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, -1);
 
 	return mesh->morph_target_count;
-
 }
 
-void RasterizerDummy::mesh_set_morph_target_mode(RID p_mesh,VS::MorphTargetMode p_mode) {
+void RasterizerDummy::mesh_set_morph_target_mode(RID p_mesh, VS::MorphTargetMode p_mode) {
 
-	ERR_FAIL_INDEX(p_mode,2);
-	Mesh *mesh = mesh_owner.get( p_mesh );
+	ERR_FAIL_INDEX(p_mode, 2);
+	Mesh *mesh = mesh_owner.get(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
-	mesh->morph_target_mode=p_mode;
-
+	mesh->morph_target_mode = p_mode;
 }
 
 VS::MorphTargetMode RasterizerDummy::mesh_get_morph_target_mode(RID p_mesh) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,VS::MORPH_MODE_NORMALIZED);
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, VS::MORPH_MODE_NORMALIZED);
 
 	return mesh->morph_target_mode;
-
 }
 
+void RasterizerDummy::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned) {
 
-
-void RasterizerDummy::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material,bool p_owned) {
-
-	Mesh *mesh = mesh_owner.get( p_mesh );
+	Mesh *mesh = mesh_owner.get(p_mesh);
 	ERR_FAIL_COND(!mesh);
-	ERR_FAIL_INDEX(p_surface, mesh->surfaces.size() );
+	ERR_FAIL_INDEX(p_surface, mesh->surfaces.size());
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND( !surface);
+	ERR_FAIL_COND(!surface);
 
 	if (surface->material_owned && surface->material.is_valid())
 		free(surface->material);
 
-	surface->material_owned=p_owned;
-	surface->material=p_material;
+	surface->material_owned = p_owned;
+	surface->material = p_material;
 }
 
 RID RasterizerDummy::mesh_surface_get_material(RID p_mesh, int p_surface) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,RID());
-	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), RID() );
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, RID());
+	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), RID());
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND_V( !surface, RID() );
+	ERR_FAIL_COND_V(!surface, RID());
 
 	return surface->material;
 }
 
 int RasterizerDummy::mesh_surface_get_array_len(RID p_mesh, int p_surface) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,-1);
-	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), -1 );
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, -1);
+	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), -1);
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND_V( !surface, -1 );
+	ERR_FAIL_COND_V(!surface, -1);
 
 	Vector3Array arr = surface->data[VS::ARRAY_VERTEX];
 	return arr.size();
-
 }
 
 int RasterizerDummy::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,-1);
-	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), -1 );
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, -1);
+	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), -1);
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND_V( !surface, -1 );
+	ERR_FAIL_COND_V(!surface, -1);
 
 	IntArray arr = surface->data[VS::ARRAY_INDEX];
 	return arr.size();
-
 }
 uint32_t RasterizerDummy::mesh_surface_get_format(RID p_mesh, int p_surface) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,0);
-	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), 0 );
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, 0);
+	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), 0);
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND_V( !surface, 0 );
+	ERR_FAIL_COND_V(!surface, 0);
 
 	return surface->format;
 }
 VS::PrimitiveType RasterizerDummy::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,VS::PRIMITIVE_POINTS);
-	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), VS::PRIMITIVE_POINTS );
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, VS::PRIMITIVE_POINTS);
+	ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), VS::PRIMITIVE_POINTS);
 	Surface *surface = mesh->surfaces[p_surface];
-	ERR_FAIL_COND_V( !surface, VS::PRIMITIVE_POINTS );
+	ERR_FAIL_COND_V(!surface, VS::PRIMITIVE_POINTS);
 
 	return surface->primitive;
 }
 
-void RasterizerDummy::mesh_remove_surface(RID p_mesh,int p_index) {
+void RasterizerDummy::mesh_remove_surface(RID p_mesh, int p_index) {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
+	Mesh *mesh = mesh_owner.get(p_mesh);
 	ERR_FAIL_COND(!mesh);
-	ERR_FAIL_INDEX(p_index, mesh->surfaces.size() );
+	ERR_FAIL_INDEX(p_index, mesh->surfaces.size());
 	Surface *surface = mesh->surfaces[p_index];
-	ERR_FAIL_COND( !surface);
+	ERR_FAIL_COND(!surface);
 
-	memdelete( mesh->surfaces[p_index] );
+	memdelete(mesh->surfaces[p_index]);
 	mesh->surfaces.remove(p_index);
-
 }
 int RasterizerDummy::mesh_get_surface_count(RID p_mesh) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,-1);
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, -1);
 
 	return mesh->surfaces.size();
 }
 
-AABB RasterizerDummy::mesh_get_aabb(RID p_mesh,RID p_skeleton) const {
+AABB RasterizerDummy::mesh_get_aabb(RID p_mesh, RID p_skeleton) const {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,AABB());
+	Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, AABB());
 
 	AABB aabb;
 
-	for (int i=0;i<mesh->surfaces.size();i++) {
+	for (int i = 0; i < mesh->surfaces.size(); i++) {
 
-		if (i==0)
-			aabb=mesh->surfaces[i]->aabb;
+		if (i == 0)
+			aabb = mesh->surfaces[i]->aabb;
 		else
 			aabb.merge_with(mesh->surfaces[i]->aabb);
 	}
@@ -594,515 +537,463 @@ AABB RasterizerDummy::mesh_get_aabb(RID p_mesh,RID p_skeleton) const {
 	return aabb;
 }
 
-void RasterizerDummy::mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb) {
+void RasterizerDummy::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) {
 
-	Mesh *mesh = mesh_owner.get( p_mesh );
+	Mesh *mesh = mesh_owner.get(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
-	mesh->custom_aabb=p_aabb;
+	mesh->custom_aabb = p_aabb;
 }
 
 AABB RasterizerDummy::mesh_get_custom_aabb(RID p_mesh) const {
 
-	const Mesh *mesh = mesh_owner.get( p_mesh );
-	ERR_FAIL_COND_V(!mesh,AABB());
+	const Mesh *mesh = mesh_owner.get(p_mesh);
+	ERR_FAIL_COND_V(!mesh, AABB());
 
 	return mesh->custom_aabb;
-
 }
 
 /* MULTIMESH API */
 
 RID RasterizerDummy::multimesh_create() {
 
-	return multimesh_owner.make_rid( memnew( MultiMesh ));
+	return multimesh_owner.make_rid(memnew(MultiMesh));
 }
 
-void RasterizerDummy::multimesh_set_instance_count(RID p_multimesh,int p_count) {
+void RasterizerDummy::multimesh_set_instance_count(RID p_multimesh, int p_count) {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 
 	multimesh->elements.clear(); // make sure to delete everything, so it "fails" in all implementations
 	multimesh->elements.resize(p_count);
-
 }
 int RasterizerDummy::multimesh_get_instance_count(RID p_multimesh) const {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,-1);
+	ERR_FAIL_COND_V(!multimesh, -1);
 
 	return multimesh->elements.size();
 }
 
-void RasterizerDummy::multimesh_set_mesh(RID p_multimesh,RID p_mesh) {
+void RasterizerDummy::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 
-	multimesh->mesh=p_mesh;
-
+	multimesh->mesh = p_mesh;
 }
-void RasterizerDummy::multimesh_set_aabb(RID p_multimesh,const AABB& p_aabb) {
+void RasterizerDummy::multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb) {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
-	multimesh->aabb=p_aabb;
+	multimesh->aabb = p_aabb;
 }
-void RasterizerDummy::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform) {
+void RasterizerDummy::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
-	ERR_FAIL_INDEX(p_index,multimesh->elements.size());
-	multimesh->elements[p_index].xform=p_transform;
-
+	ERR_FAIL_INDEX(p_index, multimesh->elements.size());
+	multimesh->elements[p_index].xform = p_transform;
 }
-void RasterizerDummy::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color) {
+void RasterizerDummy::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
 	ERR_FAIL_COND(!multimesh)
-	ERR_FAIL_INDEX(p_index,multimesh->elements.size());
-	multimesh->elements[p_index].color=p_color;
-
+	ERR_FAIL_INDEX(p_index, multimesh->elements.size());
+	multimesh->elements[p_index].color = p_color;
 }
 
 RID RasterizerDummy::multimesh_get_mesh(RID p_multimesh) const {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,RID());
+	ERR_FAIL_COND_V(!multimesh, RID());
 
 	return multimesh->mesh;
 }
 AABB RasterizerDummy::multimesh_get_aabb(RID p_multimesh) const {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,AABB());
+	ERR_FAIL_COND_V(!multimesh, AABB());
 
 	return multimesh->aabb;
 }
 
-Transform RasterizerDummy::multimesh_instance_get_transform(RID p_multimesh,int p_index) const {
+Transform RasterizerDummy::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,Transform());
+	ERR_FAIL_COND_V(!multimesh, Transform());
 
-	ERR_FAIL_INDEX_V(p_index,multimesh->elements.size(),Transform());
+	ERR_FAIL_INDEX_V(p_index, multimesh->elements.size(), Transform());
 
 	return multimesh->elements[p_index].xform;
-
 }
-Color RasterizerDummy::multimesh_instance_get_color(RID p_multimesh,int p_index) const {
+Color RasterizerDummy::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,Color());
-	ERR_FAIL_INDEX_V(p_index,multimesh->elements.size(),Color());
+	ERR_FAIL_COND_V(!multimesh, Color());
+	ERR_FAIL_INDEX_V(p_index, multimesh->elements.size(), Color());
 
 	return multimesh->elements[p_index].color;
 }
 
-void RasterizerDummy::multimesh_set_visible_instances(RID p_multimesh,int p_visible) {
+void RasterizerDummy::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
-	multimesh->visible=p_visible;
-
+	multimesh->visible = p_visible;
 }
 
 int RasterizerDummy::multimesh_get_visible_instances(RID p_multimesh) const {
 
 	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
-	ERR_FAIL_COND_V(!multimesh,-1);
+	ERR_FAIL_COND_V(!multimesh, -1);
 	return multimesh->visible;
-
 }
 
 /* IMMEDIATE API */
 
-
 RID RasterizerDummy::immediate_create() {
 
-	Immediate *im = memnew( Immediate );
+	Immediate *im = memnew(Immediate);
 	return immediate_owner.make_rid(im);
-
 }
 
-void RasterizerDummy::immediate_begin(RID p_immediate,VS::PrimitiveType p_rimitive,RID p_texture){
-
-
+void RasterizerDummy::immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture) {
 }
-void RasterizerDummy::immediate_vertex(RID p_immediate,const Vector3& p_vertex){
-
-
+void RasterizerDummy::immediate_vertex(RID p_immediate, const Vector3 &p_vertex) {
 }
-void RasterizerDummy::immediate_normal(RID p_immediate,const Vector3& p_normal){
-
-
+void RasterizerDummy::immediate_normal(RID p_immediate, const Vector3 &p_normal) {
 }
-void RasterizerDummy::immediate_tangent(RID p_immediate,const Plane& p_tangent){
-
-
+void RasterizerDummy::immediate_tangent(RID p_immediate, const Plane &p_tangent) {
 }
-void RasterizerDummy::immediate_color(RID p_immediate,const Color& p_color){
-
-
+void RasterizerDummy::immediate_color(RID p_immediate, const Color &p_color) {
 }
-void RasterizerDummy::immediate_uv(RID p_immediate,const Vector2& tex_uv){
-
-
+void RasterizerDummy::immediate_uv(RID p_immediate, const Vector2 &tex_uv) {
 }
-void RasterizerDummy::immediate_uv2(RID p_immediate,const Vector2& tex_uv){
-
-
+void RasterizerDummy::immediate_uv2(RID p_immediate, const Vector2 &tex_uv) {
 }
 
-void RasterizerDummy::immediate_end(RID p_immediate){
-
-
+void RasterizerDummy::immediate_end(RID p_immediate) {
 }
 void RasterizerDummy::immediate_clear(RID p_immediate) {
-
-
 }
 
 AABB RasterizerDummy::immediate_get_aabb(RID p_immediate) const {
 
-	return AABB(Vector3(-1,-1,-1),Vector3(2,2,2));
+	return AABB(Vector3(-1, -1, -1), Vector3(2, 2, 2));
 }
 
-void RasterizerDummy::immediate_set_material(RID p_immediate,RID p_material) {
+void RasterizerDummy::immediate_set_material(RID p_immediate, RID p_material) {
 
 	Immediate *im = immediate_owner.get(p_immediate);
 	ERR_FAIL_COND(!im);
-	im->material=p_material;
-
+	im->material = p_material;
 }
 
 RID RasterizerDummy::immediate_get_material(RID p_immediate) const {
 
 	const Immediate *im = immediate_owner.get(p_immediate);
-	ERR_FAIL_COND_V(!im,RID());
+	ERR_FAIL_COND_V(!im, RID());
 	return im->material;
-
 }
 
 /* PARTICLES API */
 
 RID RasterizerDummy::particles_create() {
 
-	Particles *particles = memnew( Particles );
-	ERR_FAIL_COND_V(!particles,RID());
+	Particles *particles = memnew(Particles);
+	ERR_FAIL_COND_V(!particles, RID());
 	return particles_owner.make_rid(particles);
 }
 
 void RasterizerDummy::particles_set_amount(RID p_particles, int p_amount) {
 
-	ERR_FAIL_COND(p_amount<1);
-	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(p_amount < 1);
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.amount=p_amount;
-
+	particles->data.amount = p_amount;
 }
 
 int RasterizerDummy::particles_get_amount(RID p_particles) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,-1);
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, -1);
 	return particles->data.amount;
-
 }
 
 void RasterizerDummy::particles_set_emitting(RID p_particles, bool p_emitting) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.emitting=p_emitting;;
-
+	particles->data.emitting = p_emitting;
+	;
 }
 bool RasterizerDummy::particles_is_emitting(RID p_particles) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,false);
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, false);
 	return particles->data.emitting;
-
 }
 
-void RasterizerDummy::particles_set_visibility_aabb(RID p_particles, const AABB& p_visibility) {
+void RasterizerDummy::particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.visibility_aabb=p_visibility;
-
+	particles->data.visibility_aabb = p_visibility;
 }
 
-void RasterizerDummy::particles_set_emission_half_extents(RID p_particles, const Vector3& p_half_extents) {
+void RasterizerDummy::particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
 
-	particles->data.emission_half_extents=p_half_extents;
+	particles->data.emission_half_extents = p_half_extents;
 }
 Vector3 RasterizerDummy::particles_get_emission_half_extents(RID p_particles) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,Vector3());
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, Vector3());
 
 	return particles->data.emission_half_extents;
 }
 
-void RasterizerDummy::particles_set_emission_base_velocity(RID p_particles, const Vector3& p_base_velocity) {
+void RasterizerDummy::particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
 
-	particles->data.emission_base_velocity=p_base_velocity;
+	particles->data.emission_base_velocity = p_base_velocity;
 }
 
 Vector3 RasterizerDummy::particles_get_emission_base_velocity(RID p_particles) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,Vector3());
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, Vector3());
 
 	return particles->data.emission_base_velocity;
 }
 
+void RasterizerDummy::particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points) {
 
-void RasterizerDummy::particles_set_emission_points(RID p_particles, const DVector<Vector3>& p_points) {
-
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
 
-	particles->data.emission_points=p_points;
+	particles->data.emission_points = p_points;
 }
 
 DVector<Vector3> RasterizerDummy::particles_get_emission_points(RID p_particles) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,DVector<Vector3>());
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, DVector<Vector3>());
 
 	return particles->data.emission_points;
-
 }
 
-void RasterizerDummy::particles_set_gravity_normal(RID p_particles, const Vector3& p_normal) {
+void RasterizerDummy::particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
 
-	particles->data.gravity_normal=p_normal;
-
+	particles->data.gravity_normal = p_normal;
 }
 Vector3 RasterizerDummy::particles_get_gravity_normal(RID p_particles) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,Vector3());
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, Vector3());
 
 	return particles->data.gravity_normal;
 }
 
-
 AABB RasterizerDummy::particles_get_visibility_aabb(RID p_particles) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,AABB());
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, AABB());
 	return particles->data.visibility_aabb;
-
 }
 
-void RasterizerDummy::particles_set_variable(RID p_particles, VS::ParticleVariable p_variable,float p_value) {
+void RasterizerDummy::particles_set_variable(RID p_particles, VS::ParticleVariable p_variable, float p_value) {
 
-	ERR_FAIL_INDEX(p_variable,VS::PARTICLE_VAR_MAX);
+	ERR_FAIL_INDEX(p_variable, VS::PARTICLE_VAR_MAX);
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.particle_vars[p_variable]=p_value;
-
+	particles->data.particle_vars[p_variable] = p_value;
 }
 float RasterizerDummy::particles_get_variable(RID p_particles, VS::ParticleVariable p_variable) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,-1);
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, -1);
 	return particles->data.particle_vars[p_variable];
 }
 
-void RasterizerDummy::particles_set_randomness(RID p_particles, VS::ParticleVariable p_variable,float p_randomness) {
+void RasterizerDummy::particles_set_randomness(RID p_particles, VS::ParticleVariable p_variable, float p_randomness) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.particle_randomness[p_variable]=p_randomness;
-
+	particles->data.particle_randomness[p_variable] = p_randomness;
 }
 float RasterizerDummy::particles_get_randomness(RID p_particles, VS::ParticleVariable p_variable) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,-1);
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, -1);
 	return particles->data.particle_randomness[p_variable];
-
 }
 
 void RasterizerDummy::particles_set_color_phases(RID p_particles, int p_phases) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	ERR_FAIL_COND( p_phases<0 || p_phases>VS::MAX_PARTICLE_COLOR_PHASES );
-	particles->data.color_phase_count=p_phases;
-
+	ERR_FAIL_COND(p_phases < 0 || p_phases > VS::MAX_PARTICLE_COLOR_PHASES);
+	particles->data.color_phase_count = p_phases;
 }
 int RasterizerDummy::particles_get_color_phases(RID p_particles) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,-1);
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, -1);
 	return particles->data.color_phase_count;
 }
 
-
 void RasterizerDummy::particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos) {
 
 	ERR_FAIL_INDEX(p_phase, VS::MAX_PARTICLE_COLOR_PHASES);
-	if (p_pos<0.0)
-		p_pos=0.0;
-	if (p_pos>1.0)
-		p_pos=1.0;
+	if (p_pos < 0.0)
+		p_pos = 0.0;
+	if (p_pos > 1.0)
+		p_pos = 1.0;
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.color_phases[p_phase].pos=p_pos;
-
+	particles->data.color_phases[p_phase].pos = p_pos;
 }
 float RasterizerDummy::particles_get_color_phase_pos(RID p_particles, int p_phase) const {
 
 	ERR_FAIL_INDEX_V(p_phase, VS::MAX_PARTICLE_COLOR_PHASES, -1.0);
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,-1);
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, -1);
 	return particles->data.color_phases[p_phase].pos;
-
 }
 
-void RasterizerDummy::particles_set_color_phase_color(RID p_particles, int p_phase, const Color& p_color) {
+void RasterizerDummy::particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color) {
 
 	ERR_FAIL_INDEX(p_phase, VS::MAX_PARTICLE_COLOR_PHASES);
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.color_phases[p_phase].color=p_color;
+	particles->data.color_phases[p_phase].color = p_color;
 
 	//update alpha
-	particles->has_alpha=false;
-	for(int i=0;i<VS::MAX_PARTICLE_COLOR_PHASES;i++) {
-		if (particles->data.color_phases[i].color.a<0.99)
-			particles->has_alpha=true;
+	particles->has_alpha = false;
+	for (int i = 0; i < VS::MAX_PARTICLE_COLOR_PHASES; i++) {
+		if (particles->data.color_phases[i].color.a < 0.99)
+			particles->has_alpha = true;
 	}
-
 }
 
 Color RasterizerDummy::particles_get_color_phase_color(RID p_particles, int p_phase) const {
 
 	ERR_FAIL_INDEX_V(p_phase, VS::MAX_PARTICLE_COLOR_PHASES, Color());
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,Color());
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, Color());
 	return particles->data.color_phases[p_phase].color;
-
 }
 
 void RasterizerDummy::particles_set_attractors(RID p_particles, int p_attractors) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	ERR_FAIL_COND( p_attractors<0 || p_attractors>VisualServer::MAX_PARTICLE_ATTRACTORS );
-	particles->data.attractor_count=p_attractors;
-
+	ERR_FAIL_COND(p_attractors < 0 || p_attractors > VisualServer::MAX_PARTICLE_ATTRACTORS);
+	particles->data.attractor_count = p_attractors;
 }
 int RasterizerDummy::particles_get_attractors(RID p_particles) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,-1);
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, -1);
 	return particles->data.attractor_count;
 }
 
-void RasterizerDummy::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3& p_pos) {
+void RasterizerDummy::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	ERR_FAIL_INDEX(p_attractor,particles->data.attractor_count);
-	particles->data.attractors[p_attractor].pos=p_pos;;
+	ERR_FAIL_INDEX(p_attractor, particles->data.attractor_count);
+	particles->data.attractors[p_attractor].pos = p_pos;
+	;
 }
-Vector3 RasterizerDummy::particles_get_attractor_pos(RID p_particles,int p_attractor) const {
+Vector3 RasterizerDummy::particles_get_attractor_pos(RID p_particles, int p_attractor) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,Vector3());
-	ERR_FAIL_INDEX_V(p_attractor,particles->data.attractor_count,Vector3());
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, Vector3());
+	ERR_FAIL_INDEX_V(p_attractor, particles->data.attractor_count, Vector3());
 	return particles->data.attractors[p_attractor].pos;
 }
 
 void RasterizerDummy::particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	ERR_FAIL_INDEX(p_attractor,particles->data.attractor_count);
-	particles->data.attractors[p_attractor].force=p_force;
+	ERR_FAIL_INDEX(p_attractor, particles->data.attractor_count);
+	particles->data.attractors[p_attractor].force = p_force;
 }
 
-float RasterizerDummy::particles_get_attractor_strength(RID p_particles,int p_attractor) const {
+float RasterizerDummy::particles_get_attractor_strength(RID p_particles, int p_attractor) const {
 
-	Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,0);
-	ERR_FAIL_INDEX_V(p_attractor,particles->data.attractor_count,0);
+	Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, 0);
+	ERR_FAIL_INDEX_V(p_attractor, particles->data.attractor_count, 0);
 	return particles->data.attractors[p_attractor].force;
 }
 
-void RasterizerDummy::particles_set_material(RID p_particles, RID p_material,bool p_owned) {
+void RasterizerDummy::particles_set_material(RID p_particles, RID p_material, bool p_owned) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
 	if (particles->material_owned && particles->material.is_valid())
 		free(particles->material);
 
-	particles->material_owned=p_owned;
-
-	particles->material=p_material;
+	particles->material_owned = p_owned;
 
+	particles->material = p_material;
 }
 RID RasterizerDummy::particles_get_material(RID p_particles) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,RID());
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, RID());
 	return particles->material;
-
 }
 
 void RasterizerDummy::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.local_coordinates=p_enable;
-
+	particles->data.local_coordinates = p_enable;
 }
 
 bool RasterizerDummy::particles_is_using_local_coordinates(RID p_particles) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,false);
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, false);
 	return particles->data.local_coordinates;
 }
 bool RasterizerDummy::particles_has_height_from_velocity(RID p_particles) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,false);
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, false);
 	return particles->data.height_from_velocity;
 }
 
 void RasterizerDummy::particles_set_height_from_velocity(RID p_particles, bool p_enable) {
 
-	Particles* particles = particles_owner.get( p_particles );
+	Particles *particles = particles_owner.get(p_particles);
 	ERR_FAIL_COND(!particles);
-	particles->data.height_from_velocity=p_enable;
-
+	particles->data.height_from_velocity = p_enable;
 }
 
 AABB RasterizerDummy::particles_get_aabb(RID p_particles) const {
 
-	const Particles* particles = particles_owner.get( p_particles );
-	ERR_FAIL_COND_V(!particles,AABB());
+	const Particles *particles = particles_owner.get(p_particles);
+	ERR_FAIL_COND_V(!particles, AABB());
 	return particles->data.visibility_aabb;
 }
 
@@ -1110,143 +1001,138 @@ AABB RasterizerDummy::particles_get_aabb(RID p_particles) const {
 
 RID RasterizerDummy::skeleton_create() {
 
-	Skeleton *skeleton = memnew( Skeleton );
-	ERR_FAIL_COND_V(!skeleton,RID());
-	return skeleton_owner.make_rid( skeleton );
+	Skeleton *skeleton = memnew(Skeleton);
+	ERR_FAIL_COND_V(!skeleton, RID());
+	return skeleton_owner.make_rid(skeleton);
 }
-void RasterizerDummy::skeleton_resize(RID p_skeleton,int p_bones) {
+void RasterizerDummy::skeleton_resize(RID p_skeleton, int p_bones) {
 
-	Skeleton *skeleton = skeleton_owner.get( p_skeleton );
+	Skeleton *skeleton = skeleton_owner.get(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
 	if (p_bones == skeleton->bones.size()) {
 		return;
 	};
 
 	skeleton->bones.resize(p_bones);
-
 }
 int RasterizerDummy::skeleton_get_bone_count(RID p_skeleton) const {
 
-	Skeleton *skeleton = skeleton_owner.get( p_skeleton );
+	Skeleton *skeleton = skeleton_owner.get(p_skeleton);
 	ERR_FAIL_COND_V(!skeleton, -1);
 	return skeleton->bones.size();
 }
-void RasterizerDummy::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform) {
+void RasterizerDummy::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) {
 
-	Skeleton *skeleton = skeleton_owner.get( p_skeleton );
+	Skeleton *skeleton = skeleton_owner.get(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
-	ERR_FAIL_INDEX( p_bone, skeleton->bones.size() );
+	ERR_FAIL_INDEX(p_bone, skeleton->bones.size());
 
 	skeleton->bones[p_bone] = p_transform;
 }
 
-Transform RasterizerDummy::skeleton_bone_get_transform(RID p_skeleton,int p_bone) {
+Transform RasterizerDummy::skeleton_bone_get_transform(RID p_skeleton, int p_bone) {
 
-	Skeleton *skeleton = skeleton_owner.get( p_skeleton );
+	Skeleton *skeleton = skeleton_owner.get(p_skeleton);
 	ERR_FAIL_COND_V(!skeleton, Transform());
-	ERR_FAIL_INDEX_V( p_bone, skeleton->bones.size(), Transform() );
+	ERR_FAIL_INDEX_V(p_bone, skeleton->bones.size(), Transform());
 
 	// something
 	return skeleton->bones[p_bone];
 }
 
-
 /* LIGHT API */
 
 RID RasterizerDummy::light_create(VS::LightType p_type) {
 
-	Light *light = memnew( Light );
-	light->type=p_type;
+	Light *light = memnew(Light);
+	light->type = p_type;
 	return light_owner.make_rid(light);
 }
 
 VS::LightType RasterizerDummy::light_get_type(RID p_light) const {
 
 	Light *light = light_owner.get(p_light);
-	ERR_FAIL_COND_V(!light,VS::LIGHT_OMNI);
+	ERR_FAIL_COND_V(!light, VS::LIGHT_OMNI);
 	return light->type;
 }
 
-void RasterizerDummy::light_set_color(RID p_light,VS::LightColor p_type, const Color& p_color) {
+void RasterizerDummy::light_set_color(RID p_light, VS::LightColor p_type, const Color &p_color) {
 
 	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND(!light);
-	ERR_FAIL_INDEX( p_type, 3 );
-	light->colors[p_type]=p_color;
+	ERR_FAIL_INDEX(p_type, 3);
+	light->colors[p_type] = p_color;
 }
-Color RasterizerDummy::light_get_color(RID p_light,VS::LightColor p_type) const {
+Color RasterizerDummy::light_get_color(RID p_light, VS::LightColor p_type) const {
 
 	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND_V(!light, Color());
-	ERR_FAIL_INDEX_V( p_type, 3, Color() );
+	ERR_FAIL_INDEX_V(p_type, 3, Color());
 	return light->colors[p_type];
 }
 
-void RasterizerDummy::light_set_shadow(RID p_light,bool p_enabled) {
+void RasterizerDummy::light_set_shadow(RID p_light, bool p_enabled) {
 
 	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND(!light);
-	light->shadow_enabled=p_enabled;
+	light->shadow_enabled = p_enabled;
 }
 
 bool RasterizerDummy::light_has_shadow(RID p_light) const {
 
 	Light *light = light_owner.get(p_light);
-	ERR_FAIL_COND_V(!light,false);
+	ERR_FAIL_COND_V(!light, false);
 	return light->shadow_enabled;
 }
 
-void RasterizerDummy::light_set_volumetric(RID p_light,bool p_enabled) {
+void RasterizerDummy::light_set_volumetric(RID p_light, bool p_enabled) {
 
 	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND(!light);
-	light->volumetric_enabled=p_enabled;
-
+	light->volumetric_enabled = p_enabled;
 }
 bool RasterizerDummy::light_is_volumetric(RID p_light) const {
 
 	Light *light = light_owner.get(p_light);
-	ERR_FAIL_COND_V(!light,false);
+	ERR_FAIL_COND_V(!light, false);
 	return light->volumetric_enabled;
 }
 
-void RasterizerDummy::light_set_projector(RID p_light,RID p_texture) {
+void RasterizerDummy::light_set_projector(RID p_light, RID p_texture) {
 
 	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND(!light);
-	light->projector=p_texture;
+	light->projector = p_texture;
 }
 RID RasterizerDummy::light_get_projector(RID p_light) const {
 
 	Light *light = light_owner.get(p_light);
-	ERR_FAIL_COND_V(!light,RID());
+	ERR_FAIL_COND_V(!light, RID());
 	return light->projector;
 }
 
 void RasterizerDummy::light_set_var(RID p_light, VS::LightParam p_var, float p_value) {
 
-	Light * light = light_owner.get( p_light );
+	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND(!light);
-	ERR_FAIL_INDEX( p_var, VS::LIGHT_PARAM_MAX );
+	ERR_FAIL_INDEX(p_var, VS::LIGHT_PARAM_MAX);
 
-	light->vars[p_var]=p_value;
+	light->vars[p_var] = p_value;
 }
 float RasterizerDummy::light_get_var(RID p_light, VS::LightParam p_var) const {
 
-	Light * light = light_owner.get( p_light );
-	ERR_FAIL_COND_V(!light,0);
+	Light *light = light_owner.get(p_light);
+	ERR_FAIL_COND_V(!light, 0);
 
-	ERR_FAIL_INDEX_V( p_var, VS::LIGHT_PARAM_MAX,0 );
+	ERR_FAIL_INDEX_V(p_var, VS::LIGHT_PARAM_MAX, 0);
 
 	return light->vars[p_var];
 }
 
-void RasterizerDummy::light_set_operator(RID p_light,VS::LightOp p_op) {
+void RasterizerDummy::light_set_operator(RID p_light, VS::LightOp p_op) {
 
-	Light * light = light_owner.get( p_light );
+	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND(!light);
-
-
 };
 
 VS::LightOp RasterizerDummy::light_get_operator(RID p_light) const {
@@ -1254,19 +1140,15 @@ VS::LightOp RasterizerDummy::light_get_operator(RID p_light) const {
 	return VS::LightOp(0);
 };
 
-void RasterizerDummy::light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode) {
-
-
+void RasterizerDummy::light_omni_set_shadow_mode(RID p_light, VS::LightOmniShadowMode p_mode) {
 }
 
-VS::LightOmniShadowMode RasterizerDummy::light_omni_get_shadow_mode(RID p_light) const{
+VS::LightOmniShadowMode RasterizerDummy::light_omni_get_shadow_mode(RID p_light) const {
 
 	return VS::LightOmniShadowMode(0);
 }
 
-void RasterizerDummy::light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode) {
-
-
+void RasterizerDummy::light_directional_set_shadow_mode(RID p_light, VS::LightDirectionalShadowMode p_mode) {
 }
 
 VS::LightDirectionalShadowMode RasterizerDummy::light_directional_get_shadow_mode(RID p_light) const {
@@ -1274,34 +1156,31 @@ VS::LightDirectionalShadowMode RasterizerDummy::light_directional_get_shadow_mod
 	return VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL;
 }
 
-void RasterizerDummy::light_directional_set_shadow_param(RID p_light,VS::LightDirectionalShadowParam p_param, float p_value) {
-
-
+void RasterizerDummy::light_directional_set_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param, float p_value) {
 }
 
-float RasterizerDummy::light_directional_get_shadow_param(RID p_light,VS::LightDirectionalShadowParam p_param) const {
+float RasterizerDummy::light_directional_get_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param) const {
 
 	return 0;
 }
 
-
 AABB RasterizerDummy::light_get_aabb(RID p_light) const {
 
-	Light *light = light_owner.get( p_light );
-	ERR_FAIL_COND_V(!light,AABB());
+	Light *light = light_owner.get(p_light);
+	ERR_FAIL_COND_V(!light, AABB());
 
-	switch( light->type ) {
+	switch (light->type) {
 
 		case VS::LIGHT_SPOT: {
 
-			float len=light->vars[VS::LIGHT_PARAM_RADIUS];
-			float size=Math::tan(Math::deg2rad(light->vars[VS::LIGHT_PARAM_SPOT_ANGLE]))*len;
-			return AABB( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) );
+			float len = light->vars[VS::LIGHT_PARAM_RADIUS];
+			float size = Math::tan(Math::deg2rad(light->vars[VS::LIGHT_PARAM_SPOT_ANGLE])) * len;
+			return AABB(Vector3(-size, -size, -len), Vector3(size * 2, size * 2, len));
 		} break;
 		case VS::LIGHT_OMNI: {
 
 			float r = light->vars[VS::LIGHT_PARAM_RADIUS];
-			return AABB( -Vector3(r,r,r), Vector3(r,r,r)*2 );
+			return AABB(-Vector3(r, r, r), Vector3(r, r, r) * 2);
 		} break;
 		case VS::LIGHT_DIRECTIONAL: {
 
@@ -1310,51 +1189,44 @@ AABB RasterizerDummy::light_get_aabb(RID p_light) const {
 		default: {}
 	}
 
-	ERR_FAIL_V( AABB() );
+	ERR_FAIL_V(AABB());
 }
 
-
 RID RasterizerDummy::light_instance_create(RID p_light) {
 
-	Light *light = light_owner.get( p_light );
+	Light *light = light_owner.get(p_light);
 	ERR_FAIL_COND_V(!light, RID());
 
-	LightInstance *light_instance = memnew( LightInstance );
-
-	light_instance->light=p_light;
-	light_instance->base=light;
+	LightInstance *light_instance = memnew(LightInstance);
 
+	light_instance->light = p_light;
+	light_instance->base = light;
 
-	return light_instance_owner.make_rid( light_instance );
+	return light_instance_owner.make_rid(light_instance);
 }
-void RasterizerDummy::light_instance_set_transform(RID p_light_instance,const Transform& p_transform) {
+void RasterizerDummy::light_instance_set_transform(RID p_light_instance, const Transform &p_transform) {
 
-	LightInstance *lighti = light_instance_owner.get( p_light_instance );
+	LightInstance *lighti = light_instance_owner.get(p_light_instance);
 	ERR_FAIL_COND(!lighti);
-	lighti->transform=p_transform;
-
+	lighti->transform = p_transform;
 }
 
 bool RasterizerDummy::light_instance_has_shadow(RID p_light_instance) const {
 
 	return false;
-
 }
 
-
 bool RasterizerDummy::light_instance_assign_shadow(RID p_light_instance) {
 
 	return false;
-
 }
 
-
 Rasterizer::ShadowType RasterizerDummy::light_instance_get_shadow_type(RID p_light_instance) const {
 
-	LightInstance *lighti = light_instance_owner.get( p_light_instance );
-	ERR_FAIL_COND_V(!lighti,Rasterizer::SHADOW_NONE);
+	LightInstance *lighti = light_instance_owner.get(p_light_instance);
+	ERR_FAIL_COND_V(!lighti, Rasterizer::SHADOW_NONE);
 
-	switch(lighti->base->type) {
+	switch (lighti->base->type) {
 
 		case VS::LIGHT_DIRECTIONAL: return SHADOW_PSM; break;
 		case VS::LIGHT_OMNI: return SHADOW_DUAL_PARABOLOID; break;
@@ -1364,13 +1236,11 @@ Rasterizer::ShadowType RasterizerDummy::light_instance_get_shadow_type(RID p_lig
 	return Rasterizer::SHADOW_NONE;
 }
 
-Rasterizer::ShadowType RasterizerDummy::light_instance_get_shadow_type(RID p_light_instance,bool p_far) const {
+Rasterizer::ShadowType RasterizerDummy::light_instance_get_shadow_type(RID p_light_instance, bool p_far) const {
 
 	return SHADOW_NONE;
 }
-void RasterizerDummy::light_instance_set_shadow_transform(RID p_light_instance, int p_index, const CameraMatrix& p_camera, const Transform& p_transform, float p_split_near,float p_split_far) {
-
-
+void RasterizerDummy::light_instance_set_shadow_transform(RID p_light_instance, int p_index, const CameraMatrix &p_camera, const Transform &p_transform, float p_split_near, float p_split_far) {
 }
 
 int RasterizerDummy::light_instance_get_shadow_passes(RID p_light_instance) const {
@@ -1383,22 +1253,18 @@ bool RasterizerDummy::light_instance_get_pssm_shadow_overlap(RID p_light_instanc
 	return false;
 }
 
+void RasterizerDummy::light_instance_set_custom_transform(RID p_light_instance, int p_index, const CameraMatrix &p_camera, const Transform &p_transform, float p_split_near, float p_split_far) {
 
-void RasterizerDummy::light_instance_set_custom_transform(RID p_light_instance, int p_index, const CameraMatrix& p_camera, const Transform& p_transform, float p_split_near,float p_split_far) {
-
-	LightInstance *lighti = light_instance_owner.get( p_light_instance );
+	LightInstance *lighti = light_instance_owner.get(p_light_instance);
 	ERR_FAIL_COND(!lighti);
 
-	ERR_FAIL_COND(lighti->base->type!=VS::LIGHT_DIRECTIONAL);
-	ERR_FAIL_INDEX(p_index,1);
-
-	lighti->custom_projection=p_camera;
-	lighti->custom_transform=p_transform;
+	ERR_FAIL_COND(lighti->base->type != VS::LIGHT_DIRECTIONAL);
+	ERR_FAIL_INDEX(p_index, 1);
 
+	lighti->custom_projection = p_camera;
+	lighti->custom_transform = p_transform;
 }
 void RasterizerDummy::shadow_clear_near() {
-
-
 }
 
 bool RasterizerDummy::shadow_allocate_near(RID p_light) {
@@ -1415,143 +1281,94 @@ bool RasterizerDummy::shadow_allocate_far(RID p_light) {
 
 RID RasterizerDummy::particles_instance_create(RID p_particles) {
 
-	ERR_FAIL_COND_V(!particles_owner.owns(p_particles),RID());
-	ParticlesInstance *particles_instance = memnew( ParticlesInstance );
-	ERR_FAIL_COND_V(!particles_instance, RID() );
-	particles_instance->particles=p_particles;
+	ERR_FAIL_COND_V(!particles_owner.owns(p_particles), RID());
+	ParticlesInstance *particles_instance = memnew(ParticlesInstance);
+	ERR_FAIL_COND_V(!particles_instance, RID());
+	particles_instance->particles = p_particles;
 	return particles_instance_owner.make_rid(particles_instance);
 }
 
-void RasterizerDummy::particles_instance_set_transform(RID p_particles_instance,const Transform& p_transform) {
+void RasterizerDummy::particles_instance_set_transform(RID p_particles_instance, const Transform &p_transform) {
 
-	ParticlesInstance *particles_instance=particles_instance_owner.get(p_particles_instance);
+	ParticlesInstance *particles_instance = particles_instance_owner.get(p_particles_instance);
 	ERR_FAIL_COND(!particles_instance);
-	particles_instance->transform=p_transform;
+	particles_instance->transform = p_transform;
 }
 
-
 /* RENDER API */
 /* all calls (inside begin/end shadow) are always warranted to be in the following order: */
 
-
 RID RasterizerDummy::viewport_data_create() {
 
 	return RID();
 }
 
-RID RasterizerDummy::render_target_create(){
+RID RasterizerDummy::render_target_create() {
 
 	return RID();
-
 }
-void RasterizerDummy::render_target_set_size(RID p_render_target, int p_width, int p_height){
-
-
+void RasterizerDummy::render_target_set_size(RID p_render_target, int p_width, int p_height) {
 }
-RID RasterizerDummy::render_target_get_texture(RID p_render_target) const{
+RID RasterizerDummy::render_target_get_texture(RID p_render_target) const {
 
 	return RID();
-
 }
-bool RasterizerDummy::render_target_renedered_in_frame(RID p_render_target){
+bool RasterizerDummy::render_target_renedered_in_frame(RID p_render_target) {
 
 	return false;
 }
 
-
 void RasterizerDummy::begin_frame() {
-
-
-
 }
 
-void RasterizerDummy::capture_viewport(Image* r_capture) {
-
-
+void RasterizerDummy::capture_viewport(Image *r_capture) {
 }
 
-
-void RasterizerDummy::clear_viewport(const Color& p_color) {
-
+void RasterizerDummy::clear_viewport(const Color &p_color){
 
 };
 
-void RasterizerDummy::set_viewport(const VS::ViewportRect& p_viewport) {
-
-
-
+void RasterizerDummy::set_viewport(const VS::ViewportRect &p_viewport) {
 }
 
 void RasterizerDummy::set_render_target(RID p_render_target, bool p_transparent_bg, bool p_vflip) {
-
-
 }
 
-
-void RasterizerDummy::begin_scene(RID p_viewport_data,RID p_env,VS::ScenarioDebugMode p_debug) {
-
+void RasterizerDummy::begin_scene(RID p_viewport_data, RID p_env, VS::ScenarioDebugMode p_debug){
 
 };
 
-void RasterizerDummy::begin_shadow_map( RID p_light_instance, int p_shadow_pass ) {
-
+void RasterizerDummy::begin_shadow_map(RID p_light_instance, int p_shadow_pass) {
 }
 
-void RasterizerDummy::set_camera(const Transform& p_world, const CameraMatrix& p_projection, bool p_ortho_hint) {
-
-
+void RasterizerDummy::set_camera(const Transform &p_world, const CameraMatrix &p_projection, bool p_ortho_hint) {
 }
 
-void RasterizerDummy::add_light( RID p_light_instance ) {
-
-
-
+void RasterizerDummy::add_light(RID p_light_instance) {
 }
 
-
-
-
-void RasterizerDummy::add_mesh( const RID& p_mesh, const InstanceData *p_data) {
-
-
+void RasterizerDummy::add_mesh(const RID &p_mesh, const InstanceData *p_data) {
 }
 
-void RasterizerDummy::add_multimesh( const RID& p_multimesh, const InstanceData *p_data){
-
-
-
-
+void RasterizerDummy::add_multimesh(const RID &p_multimesh, const InstanceData *p_data) {
 }
 
-void RasterizerDummy::add_particles( const RID& p_particle_instance, const InstanceData *p_data){
-
-
-
+void RasterizerDummy::add_particles(const RID &p_particle_instance, const InstanceData *p_data) {
 }
 
-
-
 void RasterizerDummy::end_scene() {
-
-
 }
 void RasterizerDummy::end_shadow_map() {
-
 }
 
-
 void RasterizerDummy::end_frame() {
-
-
 }
 
 RID RasterizerDummy::canvas_light_occluder_create() {
 	return RID();
 }
 
-void RasterizerDummy::canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines) {
-
-
+void RasterizerDummy::canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2> &p_lines) {
 }
 
 RID RasterizerDummy::canvas_light_shadow_buffer_create(int p_width) {
@@ -1559,206 +1376,152 @@ RID RasterizerDummy::canvas_light_shadow_buffer_create(int p_width) {
 	return RID();
 }
 
-void RasterizerDummy::canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, CanvasLightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache) {
-
-
+void RasterizerDummy::canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32 &p_light_xform, int p_light_mask, float p_near, float p_far, CanvasLightOccluderInstance *p_occluders, CameraMatrix *p_xform_cache) {
 }
 
-void RasterizerDummy::canvas_debug_viewport_shadows(CanvasLight* p_lights_with_shadow) {
-
-
+void RasterizerDummy::canvas_debug_viewport_shadows(CanvasLight *p_lights_with_shadow) {
 }
 
 /* CANVAS API */
 
-
 void RasterizerDummy::begin_canvas_bg() {
-
 }
 void RasterizerDummy::canvas_begin() {
-
-
-
 }
 void RasterizerDummy::canvas_disable_blending() {
-
-
-
 }
 
 void RasterizerDummy::canvas_set_opacity(float p_opacity) {
-
-
 }
 
 void RasterizerDummy::canvas_set_blend_mode(VS::MaterialBlendMode p_mode) {
-
-
 }
 
-
-void RasterizerDummy::canvas_begin_rect(const Matrix32& p_transform) {
-
-
-
+void RasterizerDummy::canvas_begin_rect(const Matrix32 &p_transform) {
 }
 
-void RasterizerDummy::canvas_set_clip(bool p_clip, const Rect2& p_rect) {
-
-
-
-
+void RasterizerDummy::canvas_set_clip(bool p_clip, const Rect2 &p_rect) {
 }
 
 void RasterizerDummy::canvas_end_rect() {
-
-
 }
 
-void RasterizerDummy::canvas_draw_line(const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width) {
-
-
-
+void RasterizerDummy::canvas_draw_line(const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width) {
 }
 
-void RasterizerDummy::canvas_draw_rect(const Rect2& p_rect, int p_flags, const Rect2& p_source,RID p_texture,const Color& p_modulate) {
-
-
-
-
+void RasterizerDummy::canvas_draw_rect(const Rect2 &p_rect, int p_flags, const Rect2 &p_source, RID p_texture, const Color &p_modulate) {
 }
-void RasterizerDummy::canvas_draw_style_box(const Rect2& p_rect, const Rect2& p_src_region, RID p_texture,const float *p_margin, bool p_draw_center,const Color& p_modulate) {
-
-
+void RasterizerDummy::canvas_draw_style_box(const Rect2 &p_rect, const Rect2 &p_src_region, RID p_texture, const float *p_margin, bool p_draw_center, const Color &p_modulate) {
 }
-void RasterizerDummy::canvas_draw_primitive(const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture,float p_width) {
-
-
-
+void RasterizerDummy::canvas_draw_primitive(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width) {
 }
 
-
-void RasterizerDummy::canvas_draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor) {
-
-
-
+void RasterizerDummy::canvas_draw_polygon(int p_vertex_count, const int *p_indices, const Vector2 *p_vertices, const Vector2 *p_uvs, const Color *p_colors, const RID &p_texture, bool p_singlecolor) {
 }
 
-void RasterizerDummy::canvas_set_transform(const Matrix32& p_transform) {
-
-
+void RasterizerDummy::canvas_set_transform(const Matrix32 &p_transform) {
 }
 
-void RasterizerDummy::canvas_render_items(CanvasItem *p_item_list,int p_z,const Color& p_modulate,CanvasLight *p_light) {
-
-
+void RasterizerDummy::canvas_render_items(CanvasItem *p_item_list, int p_z, const Color &p_modulate, CanvasLight *p_light) {
 }
 
 /* ENVIRONMENT */
 
 RID RasterizerDummy::environment_create() {
 
-	Environment * env = memnew( Environment );
+	Environment *env = memnew(Environment);
 	return environment_owner.make_rid(env);
 }
 
-void RasterizerDummy::environment_set_background(RID p_env,VS::EnvironmentBG p_bg) {
+void RasterizerDummy::environment_set_background(RID p_env, VS::EnvironmentBG p_bg) {
 
-	ERR_FAIL_INDEX(p_bg,VS::ENV_BG_MAX);
-	Environment * env = environment_owner.get(p_env);
+	ERR_FAIL_INDEX(p_bg, VS::ENV_BG_MAX);
+	Environment *env = environment_owner.get(p_env);
 	ERR_FAIL_COND(!env);
-	env->bg_mode=p_bg;
+	env->bg_mode = p_bg;
 }
 
-VS::EnvironmentBG RasterizerDummy::environment_get_background(RID p_env) const{
+VS::EnvironmentBG RasterizerDummy::environment_get_background(RID p_env) const {
 
-	const Environment * env = environment_owner.get(p_env);
-	ERR_FAIL_COND_V(!env,VS::ENV_BG_MAX);
+	const Environment *env = environment_owner.get(p_env);
+	ERR_FAIL_COND_V(!env, VS::ENV_BG_MAX);
 	return env->bg_mode;
 }
 
-void RasterizerDummy::environment_set_background_param(RID p_env,VS::EnvironmentBGParam p_param, const Variant& p_value){
+void RasterizerDummy::environment_set_background_param(RID p_env, VS::EnvironmentBGParam p_param, const Variant &p_value) {
 
-	ERR_FAIL_INDEX(p_param,VS::ENV_BG_PARAM_MAX);
-	Environment * env = environment_owner.get(p_env);
+	ERR_FAIL_INDEX(p_param, VS::ENV_BG_PARAM_MAX);
+	Environment *env = environment_owner.get(p_env);
 	ERR_FAIL_COND(!env);
-	env->bg_param[p_param]=p_value;
-
+	env->bg_param[p_param] = p_value;
 }
-Variant RasterizerDummy::environment_get_background_param(RID p_env,VS::EnvironmentBGParam p_param) const{
+Variant RasterizerDummy::environment_get_background_param(RID p_env, VS::EnvironmentBGParam p_param) const {
 
-	ERR_FAIL_INDEX_V(p_param,VS::ENV_BG_PARAM_MAX,Variant());
-	const Environment * env = environment_owner.get(p_env);
-	ERR_FAIL_COND_V(!env,Variant());
+	ERR_FAIL_INDEX_V(p_param, VS::ENV_BG_PARAM_MAX, Variant());
+	const Environment *env = environment_owner.get(p_env);
+	ERR_FAIL_COND_V(!env, Variant());
 	return env->bg_param[p_param];
-
 }
 
-void RasterizerDummy::environment_set_enable_fx(RID p_env,VS::EnvironmentFx p_effect,bool p_enabled){
+void RasterizerDummy::environment_set_enable_fx(RID p_env, VS::EnvironmentFx p_effect, bool p_enabled) {
 
-	ERR_FAIL_INDEX(p_effect,VS::ENV_FX_MAX);
-	Environment * env = environment_owner.get(p_env);
+	ERR_FAIL_INDEX(p_effect, VS::ENV_FX_MAX);
+	Environment *env = environment_owner.get(p_env);
 	ERR_FAIL_COND(!env);
-	env->fx_enabled[p_effect]=p_enabled;
+	env->fx_enabled[p_effect] = p_enabled;
 }
-bool RasterizerDummy::environment_is_fx_enabled(RID p_env,VS::EnvironmentFx p_effect) const{
+bool RasterizerDummy::environment_is_fx_enabled(RID p_env, VS::EnvironmentFx p_effect) const {
 
-	ERR_FAIL_INDEX_V(p_effect,VS::ENV_FX_MAX,false);
-	const Environment * env = environment_owner.get(p_env);
-	ERR_FAIL_COND_V(!env,false);
+	ERR_FAIL_INDEX_V(p_effect, VS::ENV_FX_MAX, false);
+	const Environment *env = environment_owner.get(p_env);
+	ERR_FAIL_COND_V(!env, false);
 	return env->fx_enabled[p_effect];
-
 }
 
-void RasterizerDummy::environment_fx_set_param(RID p_env,VS::EnvironmentFxParam p_param,const Variant& p_value){
+void RasterizerDummy::environment_fx_set_param(RID p_env, VS::EnvironmentFxParam p_param, const Variant &p_value) {
 
-	ERR_FAIL_INDEX(p_param,VS::ENV_FX_PARAM_MAX);
-	Environment * env = environment_owner.get(p_env);
+	ERR_FAIL_INDEX(p_param, VS::ENV_FX_PARAM_MAX);
+	Environment *env = environment_owner.get(p_env);
 	ERR_FAIL_COND(!env);
-	env->fx_param[p_param]=p_value;
+	env->fx_param[p_param] = p_value;
 }
-Variant RasterizerDummy::environment_fx_get_param(RID p_env,VS::EnvironmentFxParam p_param) const{
+Variant RasterizerDummy::environment_fx_get_param(RID p_env, VS::EnvironmentFxParam p_param) const {
 
-	ERR_FAIL_INDEX_V(p_param,VS::ENV_FX_PARAM_MAX,Variant());
-	const Environment * env = environment_owner.get(p_env);
-	ERR_FAIL_COND_V(!env,Variant());
+	ERR_FAIL_INDEX_V(p_param, VS::ENV_FX_PARAM_MAX, Variant());
+	const Environment *env = environment_owner.get(p_env);
+	ERR_FAIL_COND_V(!env, Variant());
 	return env->fx_param[p_param];
-
 }
 
-
-RID RasterizerDummy::sampled_light_dp_create(int p_width,int p_height) {
+RID RasterizerDummy::sampled_light_dp_create(int p_width, int p_height) {
 
 	return sampled_light_owner.make_rid(memnew(SampledLight));
 }
 
 void RasterizerDummy::sampled_light_dp_update(RID p_sampled_light, const Color *p_data, float p_multiplier) {
-
-
 }
 
-
 /*MISC*/
 
-bool RasterizerDummy::is_texture(const RID& p_rid) const {
+bool RasterizerDummy::is_texture(const RID &p_rid) const {
 
 	return texture_owner.owns(p_rid);
 }
-bool RasterizerDummy::is_material(const RID& p_rid) const {
+bool RasterizerDummy::is_material(const RID &p_rid) const {
 
 	return material_owner.owns(p_rid);
 }
-bool RasterizerDummy::is_mesh(const RID& p_rid) const {
+bool RasterizerDummy::is_mesh(const RID &p_rid) const {
 
 	return mesh_owner.owns(p_rid);
 }
 
-bool RasterizerDummy::is_immediate(const RID& p_rid) const {
+bool RasterizerDummy::is_immediate(const RID &p_rid) const {
 
 	return immediate_owner.owns(p_rid);
 }
 
-bool RasterizerDummy::is_multimesh(const RID& p_rid) const {
+bool RasterizerDummy::is_multimesh(const RID &p_rid) const {
 
 	return multimesh_owner.owns(p_rid);
 }
@@ -1767,38 +1530,38 @@ bool RasterizerDummy::is_particles(const RID &p_beam) const {
 	return particles_owner.owns(p_beam);
 }
 
-bool RasterizerDummy::is_light(const RID& p_rid) const {
+bool RasterizerDummy::is_light(const RID &p_rid) const {
 
 	return light_owner.owns(p_rid);
 }
-bool RasterizerDummy::is_light_instance(const RID& p_rid) const {
+bool RasterizerDummy::is_light_instance(const RID &p_rid) const {
 
 	return light_instance_owner.owns(p_rid);
 }
-bool RasterizerDummy::is_particles_instance(const RID& p_rid) const {
+bool RasterizerDummy::is_particles_instance(const RID &p_rid) const {
 
 	return particles_instance_owner.owns(p_rid);
 }
-bool RasterizerDummy::is_skeleton(const RID& p_rid) const {
+bool RasterizerDummy::is_skeleton(const RID &p_rid) const {
 
 	return skeleton_owner.owns(p_rid);
 }
-bool RasterizerDummy::is_environment(const RID& p_rid) const {
+bool RasterizerDummy::is_environment(const RID &p_rid) const {
 
 	return environment_owner.owns(p_rid);
 }
 
-bool RasterizerDummy::is_canvas_light_occluder(const RID& p_rid) const {
+bool RasterizerDummy::is_canvas_light_occluder(const RID &p_rid) const {
 
 	return false;
 }
 
-bool RasterizerDummy::is_shader(const RID& p_rid) const {
+bool RasterizerDummy::is_shader(const RID &p_rid) const {
 
 	return false;
 }
 
-void RasterizerDummy::free(const RID& p_rid) {
+void RasterizerDummy::free(const RID &p_rid) {
 
 	if (texture_owner.owns(p_rid)) {
 
@@ -1816,7 +1579,7 @@ void RasterizerDummy::free(const RID& p_rid) {
 
 	} else if (material_owner.owns(p_rid)) {
 
-		Material *material = material_owner.get( p_rid );
+		Material *material = material_owner.get(p_rid);
 		material_owner.free(p_rid);
 		memdelete(material);
 
@@ -1824,9 +1587,9 @@ void RasterizerDummy::free(const RID& p_rid) {
 
 		Mesh *mesh = mesh_owner.get(p_rid);
 
-		for (int i=0;i<mesh->surfaces.size();i++) {
+		for (int i = 0; i < mesh->surfaces.size(); i++) {
 
-			memdelete( mesh->surfaces[i] );
+			memdelete(mesh->surfaces[i]);
 		};
 
 		mesh->surfaces.clear();
@@ -1835,9 +1598,9 @@ void RasterizerDummy::free(const RID& p_rid) {
 
 	} else if (multimesh_owner.owns(p_rid)) {
 
-	       MultiMesh *multimesh = multimesh_owner.get(p_rid);
-	       multimesh_owner.free(p_rid);
-	       memdelete(multimesh);
+		MultiMesh *multimesh = multimesh_owner.get(p_rid);
+		multimesh_owner.free(p_rid);
+		memdelete(multimesh);
 
 	} else if (immediate_owner.owns(p_rid)) {
 
@@ -1858,42 +1621,38 @@ void RasterizerDummy::free(const RID& p_rid) {
 
 	} else if (skeleton_owner.owns(p_rid)) {
 
-		Skeleton *skeleton = skeleton_owner.get( p_rid );
+		Skeleton *skeleton = skeleton_owner.get(p_rid);
 		skeleton_owner.free(p_rid);
 		memdelete(skeleton);
 
 	} else if (light_owner.owns(p_rid)) {
 
-		Light *light = light_owner.get( p_rid );
+		Light *light = light_owner.get(p_rid);
 		light_owner.free(p_rid);
 		memdelete(light);
 
 	} else if (light_instance_owner.owns(p_rid)) {
 
-		LightInstance *light_instance = light_instance_owner.get( p_rid );
+		LightInstance *light_instance = light_instance_owner.get(p_rid);
 		light_instance_owner.free(p_rid);
-		memdelete( light_instance );
-
+		memdelete(light_instance);
 
 	} else if (environment_owner.owns(p_rid)) {
 
-		Environment *env = environment_owner.get( p_rid );
+		Environment *env = environment_owner.get(p_rid);
 		environment_owner.free(p_rid);
-		memdelete( env );
+		memdelete(env);
 	} else if (sampled_light_owner.owns(p_rid)) {
 
-		SampledLight *sampled_light = sampled_light_owner.get( p_rid );
+		SampledLight *sampled_light = sampled_light_owner.get(p_rid);
 		ERR_FAIL_COND(!sampled_light);
 
 		sampled_light_owner.free(p_rid);
-		memdelete( sampled_light );
-
+		memdelete(sampled_light);
 	};
 }
 
-
-void RasterizerDummy::custom_shade_model_set_shader(int p_model, RID p_shader) {
-
+void RasterizerDummy::custom_shade_model_set_shader(int p_model, RID p_shader){
 
 };
 
@@ -1902,7 +1661,7 @@ RID RasterizerDummy::custom_shade_model_get_shader(int p_model) const {
 	return RID();
 };
 
-void RasterizerDummy::custom_shade_model_set_name(int p_model, const String& p_name) {
+void RasterizerDummy::custom_shade_model_set_name(int p_model, const String &p_name){
 
 };
 
@@ -1911,24 +1670,18 @@ String RasterizerDummy::custom_shade_model_get_name(int p_model) const {
 	return String();
 };
 
-void RasterizerDummy::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo>& p_info) {
+void RasterizerDummy::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo> &p_info){
 
 };
 
-void RasterizerDummy::custom_shade_model_get_param_info(int p_model, List<PropertyInfo>* p_info) const {
+void RasterizerDummy::custom_shade_model_get_param_info(int p_model, List<PropertyInfo> *p_info) const {
 
 };
 
-
-
 void RasterizerDummy::init() {
-
-
 }
 
 void RasterizerDummy::finish() {
-
-
 }
 
 int RasterizerDummy::get_render_info(VS::RenderInfo p_info) {
@@ -1941,21 +1694,18 @@ bool RasterizerDummy::needs_to_draw_next_frame() const {
 	return false;
 }
 
-
 bool RasterizerDummy::has_feature(VS::Features p_feature) const {
 
 	return false;
-
 }
 
 void RasterizerDummy::restore_framebuffer() {
-
 }
 
-RasterizerDummy::RasterizerDummy() {
+RasterizerDummy::RasterizerDummy(){
 
 };
 
-RasterizerDummy::~RasterizerDummy() {
+RasterizerDummy::~RasterizerDummy(){
 
 };
diff --git a/servers/visual/rasterizer_dummy.h b/servers/visual/rasterizer_dummy.h
index c883de896..9e789f296 100644
--- a/servers/visual/rasterizer_dummy.h
+++ b/servers/visual/rasterizer_dummy.h
@@ -31,16 +31,14 @@
 
 #include "servers/visual/rasterizer.h"
 
-
+#include "camera_matrix.h"
 #include "image.h"
-#include "rid.h"
-#include "servers/visual_server.h"
 #include "list.h"
 #include "map.h"
-#include "camera_matrix.h"
+#include "rid.h"
+#include "servers/visual_server.h"
 #include "sort.h"
 
-
 #include "servers/visual/particle_system_sw.h"
 
 /**
@@ -51,17 +49,16 @@ class RasterizerDummy : public Rasterizer {
 	struct Texture {
 
 		uint32_t flags;
-		int width,height;
+		int width, height;
 		Image::Format format;
 		Image image[6];
 		Texture() {
 
-			flags=width=height=0;
-			format=Image::FORMAT_GRAYSCALE;
+			flags = width = height = 0;
+			format = Image::FORMAT_GRAYSCALE;
 		}
 
 		~Texture() {
-
 		}
 	};
 
@@ -73,19 +70,17 @@ class RasterizerDummy : public Rasterizer {
 		String fragment_code;
 		String light_code;
 		VS::ShaderMode mode;
-		Map<StringName,Variant> params;
+		Map<StringName, Variant> params;
 		int fragment_line;
 		int vertex_line;
 		int light_line;
 		bool valid;
 		bool has_alpha;
 		bool use_world_transform;
-
 	};
 
 	mutable RID_Owner<Shader> shader_owner;
 
-
 	struct Material {
 
 		bool flags[VS::MATERIAL_FLAG_MAX];
@@ -99,28 +94,24 @@ class RasterizerDummy : public Rasterizer {
 
 		RID shader; // shader material
 
-		Map<StringName,Variant> shader_params;
-
+		Map<StringName, Variant> shader_params;
 
 		Material() {
 
+			for (int i = 0; i < VS::MATERIAL_FLAG_MAX; i++)
+				flags[i] = false;
+			flags[VS::MATERIAL_FLAG_VISIBLE] = true;
 
-			for(int i=0;i<VS::MATERIAL_FLAG_MAX;i++)
-				flags[i]=false;
-			flags[VS::MATERIAL_FLAG_VISIBLE]=true;
-
-			depth_draw_mode=VS::MATERIAL_DEPTH_DRAW_OPAQUE_ONLY;
-			line_width=1;
-			blend_mode=VS::MATERIAL_BLEND_MODE_MIX;
+			depth_draw_mode = VS::MATERIAL_DEPTH_DRAW_OPAQUE_ONLY;
+			line_width = 1;
+			blend_mode = VS::MATERIAL_BLEND_MODE_MIX;
 			point_size = 1.0;
-
 		}
 	};
 	mutable RID_Owner<Material> material_owner;
 
 	void _material_check_alpha(Material *p_material);
 
-
 	struct Geometry {
 
 		enum Type {
@@ -136,8 +127,11 @@ class RasterizerDummy : public Rasterizer {
 		bool has_alpha;
 		bool material_owned;
 
-		Geometry() { has_alpha=false; material_owned = false; }
-		virtual ~Geometry() {};
+		Geometry() {
+			has_alpha = false;
+			material_owned = false;
+		}
+		virtual ~Geometry(){};
 	};
 
 	struct GeometryOwner {
@@ -164,35 +158,33 @@ class RasterizerDummy : public Rasterizer {
 
 		Surface() {
 
-			packed=false;
-			morph_target_count=0;
-			material_owned=false;
-			format=0;
-			morph_format=0;
+			packed = false;
+			morph_target_count = 0;
+			material_owned = false;
+			format = 0;
+			morph_format = 0;
 
-			primitive=VS::PRIMITIVE_POINTS;
+			primitive = VS::PRIMITIVE_POINTS;
 		}
 
 		~Surface() {
-
 		}
 	};
 
-
 	struct Mesh {
 
 		bool active;
-		Vector<Surface*> surfaces;
+		Vector<Surface *> surfaces;
 		int morph_target_count;
 		VS::MorphTargetMode morph_target_mode;
 		AABB custom_aabb;
 
 		mutable uint64_t last_pass;
 		Mesh() {
-			morph_target_mode=VS::MORPH_MODE_NORMALIZED;
-			morph_target_count=0;
-			last_pass=0;
-			active=false;
+			morph_target_mode = VS::MORPH_MODE_NORMALIZED;
+			morph_target_count = 0;
+			last_pass = 0;
+			active = false;
 		}
 	};
 	mutable RID_Owner<Mesh> mesh_owner;
@@ -202,7 +194,7 @@ class RasterizerDummy : public Rasterizer {
 	struct MultiMeshSurface : public Geometry {
 
 		Surface *surface;
-		MultiMeshSurface() { type=GEOMETRY_MULTISURFACE; }
+		MultiMeshSurface() { type = GEOMETRY_MULTISURFACE; }
 	};
 
 	struct MultiMesh : public GeometryOwner {
@@ -221,18 +213,14 @@ class RasterizerDummy : public Rasterizer {
 		Vector<Element> elements;
 
 		MultiMesh() {
-			visible=-1;
+			visible = -1;
 		}
-
-
 	};
 
-
 	mutable RID_Owner<MultiMesh> multimesh_owner;
 
 	struct Immediate {
 
-
 		RID material;
 		int empty;
 	};
@@ -244,8 +232,7 @@ class RasterizerDummy : public Rasterizer {
 		ParticleSystemSW data; // software particle system
 
 		Particles() {
-			type=GEOMETRY_PARTICLES;
-
+			type = GEOMETRY_PARTICLES;
 		}
 	};
 
@@ -258,7 +245,7 @@ class RasterizerDummy : public Rasterizer {
 		ParticleSystemProcessSW particles_process;
 		Transform transform;
 
-		ParticlesInstance() {  }
+		ParticlesInstance() {}
 	};
 
 	mutable RID_Owner<ParticlesInstance> particles_instance_owner;
@@ -267,12 +254,10 @@ class RasterizerDummy : public Rasterizer {
 	struct Skeleton {
 
 		Vector<Transform> bones;
-
 	};
 
 	mutable RID_Owner<Skeleton> skeleton_owner;
 
-
 	struct Light {
 
 		VS::LightType type;
@@ -283,27 +268,24 @@ class RasterizerDummy : public Rasterizer {
 		bool volumetric_enabled;
 		Color volumetric_color;
 
-
 		Light() {
 
-			vars[VS::LIGHT_PARAM_SPOT_ATTENUATION]=1;
-			vars[VS::LIGHT_PARAM_SPOT_ANGLE]=45;
-			vars[VS::LIGHT_PARAM_ATTENUATION]=1.0;
-			vars[VS::LIGHT_PARAM_ENERGY]=1.0;
-			vars[VS::LIGHT_PARAM_RADIUS]=1.0;
-			vars[VS::LIGHT_PARAM_SHADOW_Z_OFFSET]=0.05;
+			vars[VS::LIGHT_PARAM_SPOT_ATTENUATION] = 1;
+			vars[VS::LIGHT_PARAM_SPOT_ANGLE] = 45;
+			vars[VS::LIGHT_PARAM_ATTENUATION] = 1.0;
+			vars[VS::LIGHT_PARAM_ENERGY] = 1.0;
+			vars[VS::LIGHT_PARAM_RADIUS] = 1.0;
+			vars[VS::LIGHT_PARAM_SHADOW_Z_OFFSET] = 0.05;
 
-			colors[VS::LIGHT_COLOR_DIFFUSE]=Color(1,1,1);
-			colors[VS::LIGHT_COLOR_SPECULAR]=Color(1,1,1);
-			shadow_enabled=false;
-			volumetric_enabled=false;
+			colors[VS::LIGHT_COLOR_DIFFUSE] = Color(1, 1, 1);
+			colors[VS::LIGHT_COLOR_SPECULAR] = Color(1, 1, 1);
+			shadow_enabled = false;
+			volumetric_enabled = false;
 		}
 	};
 
-
 	struct Environment {
 
-
 		VS::EnvironmentBG bg_mode;
 		Variant bg_param[VS::ENV_BG_PARAM_MAX];
 		bool fx_enabled[VS::ENV_FX_MAX];
@@ -311,47 +293,44 @@ class RasterizerDummy : public Rasterizer {
 
 		Environment() {
 
-			bg_mode=VS::ENV_BG_DEFAULT_COLOR;
-			bg_param[VS::ENV_BG_PARAM_COLOR]=Color(0,0,0);
-			bg_param[VS::ENV_BG_PARAM_TEXTURE]=RID();
-			bg_param[VS::ENV_BG_PARAM_CUBEMAP]=RID();
-			bg_param[VS::ENV_BG_PARAM_ENERGY]=1.0;
-
-			for(int i=0;i<VS::ENV_FX_MAX;i++)
-				fx_enabled[i]=false;
-
-			fx_param[VS::ENV_FX_PARAM_GLOW_BLUR_PASSES]=1;
-			fx_param[VS::ENV_FX_PARAM_GLOW_BLOOM]=0.0;
-			fx_param[VS::ENV_FX_PARAM_GLOW_BLOOM_TRESHOLD]=0.5;
-			fx_param[VS::ENV_FX_PARAM_DOF_BLUR_PASSES]=1;
-			fx_param[VS::ENV_FX_PARAM_DOF_BLUR_BEGIN]=100.0;
-			fx_param[VS::ENV_FX_PARAM_DOF_BLUR_RANGE]=10.0;
-			fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE]=0.4;
-			fx_param[VS::ENV_FX_PARAM_HDR_WHITE]=1.0;
-			fx_param[VS::ENV_FX_PARAM_HDR_GLOW_TRESHOLD]=0.95;
-			fx_param[VS::ENV_FX_PARAM_HDR_GLOW_SCALE]=0.2;
-			fx_param[VS::ENV_FX_PARAM_HDR_MIN_LUMINANCE]=0.4;
-			fx_param[VS::ENV_FX_PARAM_HDR_MAX_LUMINANCE]=8.0;
-			fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE_ADJUST_SPEED]=0.5;
-			fx_param[VS::ENV_FX_PARAM_FOG_BEGIN]=100.0;
-			fx_param[VS::ENV_FX_PARAM_FOG_ATTENUATION]=1.0;
-			fx_param[VS::ENV_FX_PARAM_FOG_BEGIN_COLOR]=Color(0,0,0);
-			fx_param[VS::ENV_FX_PARAM_FOG_END_COLOR]=Color(0,0,0);
-			fx_param[VS::ENV_FX_PARAM_FOG_BG]=true;
-			fx_param[VS::ENV_FX_PARAM_BCS_BRIGHTNESS]=1.0;
-			fx_param[VS::ENV_FX_PARAM_BCS_CONTRAST]=1.0;
-			fx_param[VS::ENV_FX_PARAM_BCS_SATURATION]=1.0;
+			bg_mode = VS::ENV_BG_DEFAULT_COLOR;
+			bg_param[VS::ENV_BG_PARAM_COLOR] = Color(0, 0, 0);
+			bg_param[VS::ENV_BG_PARAM_TEXTURE] = RID();
+			bg_param[VS::ENV_BG_PARAM_CUBEMAP] = RID();
+			bg_param[VS::ENV_BG_PARAM_ENERGY] = 1.0;
 
+			for (int i = 0; i < VS::ENV_FX_MAX; i++)
+				fx_enabled[i] = false;
 
+			fx_param[VS::ENV_FX_PARAM_GLOW_BLUR_PASSES] = 1;
+			fx_param[VS::ENV_FX_PARAM_GLOW_BLOOM] = 0.0;
+			fx_param[VS::ENV_FX_PARAM_GLOW_BLOOM_TRESHOLD] = 0.5;
+			fx_param[VS::ENV_FX_PARAM_DOF_BLUR_PASSES] = 1;
+			fx_param[VS::ENV_FX_PARAM_DOF_BLUR_BEGIN] = 100.0;
+			fx_param[VS::ENV_FX_PARAM_DOF_BLUR_RANGE] = 10.0;
+			fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE] = 0.4;
+			fx_param[VS::ENV_FX_PARAM_HDR_WHITE] = 1.0;
+			fx_param[VS::ENV_FX_PARAM_HDR_GLOW_TRESHOLD] = 0.95;
+			fx_param[VS::ENV_FX_PARAM_HDR_GLOW_SCALE] = 0.2;
+			fx_param[VS::ENV_FX_PARAM_HDR_MIN_LUMINANCE] = 0.4;
+			fx_param[VS::ENV_FX_PARAM_HDR_MAX_LUMINANCE] = 8.0;
+			fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE_ADJUST_SPEED] = 0.5;
+			fx_param[VS::ENV_FX_PARAM_FOG_BEGIN] = 100.0;
+			fx_param[VS::ENV_FX_PARAM_FOG_ATTENUATION] = 1.0;
+			fx_param[VS::ENV_FX_PARAM_FOG_BEGIN_COLOR] = Color(0, 0, 0);
+			fx_param[VS::ENV_FX_PARAM_FOG_END_COLOR] = Color(0, 0, 0);
+			fx_param[VS::ENV_FX_PARAM_FOG_BG] = true;
+			fx_param[VS::ENV_FX_PARAM_BCS_BRIGHTNESS] = 1.0;
+			fx_param[VS::ENV_FX_PARAM_BCS_CONTRAST] = 1.0;
+			fx_param[VS::ENV_FX_PARAM_BCS_SATURATION] = 1.0;
 		}
-
 	};
 
 	mutable RID_Owner<Environment> environment_owner;
 
 	struct SampledLight {
 
-		int w,h;
+		int w, h;
 	};
 
 	mutable RID_Owner<SampledLight> sampled_light_owner;
@@ -380,38 +359,31 @@ class RasterizerDummy : public Rasterizer {
 		Vector3 spot_vector;
 		float linear_att;
 
-
-		LightInstance() { linear_att=1.0; }
-
+		LightInstance() { linear_att = 1.0; }
 	};
 
 	mutable RID_Owner<Light> light_owner;
 	mutable RID_Owner<LightInstance> light_instance_owner;
 
-
 	RID default_material;
 
-
-
-
 public:
-
 	/* TEXTURE API */
 
 	virtual RID texture_create();
-	virtual void texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags=VS::TEXTURE_FLAGS_DEFAULT);
-	virtual void texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT);
-	virtual Image texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT) const;
-	virtual void texture_set_flags(RID p_texture,uint32_t p_flags);
+	virtual void texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags = VS::TEXTURE_FLAGS_DEFAULT);
+	virtual void texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT);
+	virtual Image texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT) const;
+	virtual void texture_set_flags(RID p_texture, uint32_t p_flags);
 	virtual uint32_t texture_get_flags(RID p_texture) const;
 	virtual Image::Format texture_get_format(RID p_texture) const;
 	virtual uint32_t texture_get_width(RID p_texture) const;
 	virtual uint32_t texture_get_height(RID p_texture) const;
 	virtual bool texture_has_alpha(RID p_texture) const;
-	virtual void texture_set_size_override(RID p_texture,int p_width, int p_height);
-	virtual void texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName& p_function) const;
+	virtual void texture_set_size_override(RID p_texture, int p_width, int p_height);
+	virtual void texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function) const;
 
-	virtual void texture_set_path(RID p_texture,const String& p_path) {}
+	virtual void texture_set_path(RID p_texture, const String &p_path) {}
 	virtual String texture_get_path(RID p_texture) const { return String(); }
 	virtual void texture_debug_usage(List<VS::TextureInfo> *r_info) {}
 
@@ -419,23 +391,22 @@ public:
 
 	/* SHADER API */
 
-	virtual RID shader_create(VS::ShaderMode p_mode=VS::SHADER_MATERIAL);
+	virtual RID shader_create(VS::ShaderMode p_mode = VS::SHADER_MATERIAL);
 
-	virtual void shader_set_mode(RID p_shader,VS::ShaderMode p_mode);
+	virtual void shader_set_mode(RID p_shader, VS::ShaderMode p_mode);
 	virtual VS::ShaderMode shader_get_mode(RID p_shader) const;
 
-	virtual void shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs=0,int p_fragment_ofs=0,int p_light_ofs=0);
+	virtual void shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs = 0, int p_fragment_ofs = 0, int p_light_ofs = 0);
 	virtual String shader_get_fragment_code(RID p_shader) const;
 	virtual String shader_get_vertex_code(RID p_shader) const;
 	virtual String shader_get_light_code(RID p_shader) const;
 
 	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
 
+	virtual void shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture);
+	virtual RID shader_get_default_texture_param(RID p_shader, const StringName &p_name) const;
 
-	virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture);
-	virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const;
-
-	virtual Variant shader_get_default_param(RID p_shader, const StringName& p_name);
+	virtual Variant shader_get_default_param(RID p_shader, const StringName &p_name);
 
 	/* COMMON MATERIAL API */
 
@@ -444,38 +415,37 @@ public:
 	virtual void material_set_shader(RID p_shader_material, RID p_shader);
 	virtual RID material_get_shader(RID p_shader_material) const;
 
-	virtual void material_set_param(RID p_material, const StringName& p_param, const Variant& p_value);
-	virtual Variant material_get_param(RID p_material, const StringName& p_param) const;
+	virtual void material_set_param(RID p_material, const StringName &p_param, const Variant &p_value);
+	virtual Variant material_get_param(RID p_material, const StringName &p_param) const;
 
-	virtual void material_set_flag(RID p_material, VS::MaterialFlag p_flag,bool p_enabled);
-	virtual bool material_get_flag(RID p_material,VS::MaterialFlag p_flag) const;
+	virtual void material_set_flag(RID p_material, VS::MaterialFlag p_flag, bool p_enabled);
+	virtual bool material_get_flag(RID p_material, VS::MaterialFlag p_flag) const;
 
 	virtual void material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode);
 	virtual VS::MaterialDepthDrawMode material_get_depth_draw_mode(RID p_material) const;
 
-	virtual void material_set_blend_mode(RID p_material,VS::MaterialBlendMode p_mode);
+	virtual void material_set_blend_mode(RID p_material, VS::MaterialBlendMode p_mode);
 	virtual VS::MaterialBlendMode material_get_blend_mode(RID p_material) const;
 
-	virtual void material_set_line_width(RID p_material,float p_line_width);
+	virtual void material_set_line_width(RID p_material, float p_line_width);
 	virtual float material_get_line_width(RID p_material) const;
 
 	/* MESH API */
 
-
 	virtual RID mesh_create();
 
-	virtual void mesh_add_surface(RID p_mesh,VS::PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes=Array(),bool p_alpha_sort=false);
-	virtual Array mesh_get_surface_arrays(RID p_mesh,int p_surface) const;
-	virtual Array mesh_get_surface_morph_arrays(RID p_mesh,int p_surface) const;
-	virtual void mesh_add_custom_surface(RID p_mesh,const Variant& p_dat);
+	virtual void mesh_add_surface(RID p_mesh, VS::PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes = Array(), bool p_alpha_sort = false);
+	virtual Array mesh_get_surface_arrays(RID p_mesh, int p_surface) const;
+	virtual Array mesh_get_surface_morph_arrays(RID p_mesh, int p_surface) const;
+	virtual void mesh_add_custom_surface(RID p_mesh, const Variant &p_dat);
 
-	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount);
+	virtual void mesh_set_morph_target_count(RID p_mesh, int p_amount);
 	virtual int mesh_get_morph_target_count(RID p_mesh) const;
 
-	virtual void mesh_set_morph_target_mode(RID p_mesh,VS::MorphTargetMode p_mode);
+	virtual void mesh_set_morph_target_mode(RID p_mesh, VS::MorphTargetMode p_mode);
 	virtual VS::MorphTargetMode mesh_get_morph_target_mode(RID p_mesh) const;
 
-	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material,bool p_owned=false);
+	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned = false);
 	virtual RID mesh_surface_get_material(RID p_mesh, int p_surface) const;
 
 	virtual int mesh_surface_get_array_len(RID p_mesh, int p_surface) const;
@@ -483,49 +453,49 @@ public:
 	virtual uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const;
 	virtual VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const;
 
-	virtual void mesh_remove_surface(RID p_mesh,int p_index);
+	virtual void mesh_remove_surface(RID p_mesh, int p_index);
 	virtual int mesh_get_surface_count(RID p_mesh) const;
 
-	virtual AABB mesh_get_aabb(RID p_mesh,RID p_skeleton=RID()) const;
+	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton = RID()) const;
 
-	virtual void mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb);
+	virtual void mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb);
 	virtual AABB mesh_get_custom_aabb(RID p_mesh) const;
 
-
 	/* MULTIMESH API */
 
 	virtual RID multimesh_create();
 
-	virtual void multimesh_set_instance_count(RID p_multimesh,int p_count);
+	virtual void multimesh_set_instance_count(RID p_multimesh, int p_count);
 	virtual int multimesh_get_instance_count(RID p_multimesh) const;
 
-	virtual void multimesh_set_mesh(RID p_multimesh,RID p_mesh);
-	virtual void multimesh_set_aabb(RID p_multimesh,const AABB& p_aabb);
-	virtual void multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform);
-	virtual void multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color);
+	virtual void multimesh_set_mesh(RID p_multimesh, RID p_mesh);
+	virtual void multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb);
+	virtual void multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform);
+	virtual void multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color);
 
 	virtual RID multimesh_get_mesh(RID p_multimesh) const;
-	virtual AABB multimesh_get_aabb(RID p_multimesh) const;;
+	virtual AABB multimesh_get_aabb(RID p_multimesh) const;
+	;
 
-	virtual Transform multimesh_instance_get_transform(RID p_multimesh,int p_index) const;
-	virtual Color multimesh_instance_get_color(RID p_multimesh,int p_index) const;
+	virtual Transform multimesh_instance_get_transform(RID p_multimesh, int p_index) const;
+	virtual Color multimesh_instance_get_color(RID p_multimesh, int p_index) const;
 
-	virtual void multimesh_set_visible_instances(RID p_multimesh,int p_visible);
+	virtual void multimesh_set_visible_instances(RID p_multimesh, int p_visible);
 	virtual int multimesh_get_visible_instances(RID p_multimesh) const;
 
 	/* IMMEDIATE API */
 
 	virtual RID immediate_create();
-	virtual void immediate_begin(RID p_immediate,VS::PrimitiveType p_rimitive,RID p_texture=RID());
-	virtual void immediate_vertex(RID p_immediate,const Vector3& p_vertex);
-	virtual void immediate_normal(RID p_immediate,const Vector3& p_normal);
-	virtual void immediate_tangent(RID p_immediate,const Plane& p_tangent);
-	virtual void immediate_color(RID p_immediate,const Color& p_color);
-	virtual void immediate_uv(RID p_immediate,const Vector2& tex_uv);
-	virtual void immediate_uv2(RID p_immediate,const Vector2& tex_uv);
+	virtual void immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture = RID());
+	virtual void immediate_vertex(RID p_immediate, const Vector3 &p_vertex);
+	virtual void immediate_normal(RID p_immediate, const Vector3 &p_normal);
+	virtual void immediate_tangent(RID p_immediate, const Plane &p_tangent);
+	virtual void immediate_color(RID p_immediate, const Color &p_color);
+	virtual void immediate_uv(RID p_immediate, const Vector2 &tex_uv);
+	virtual void immediate_uv2(RID p_immediate, const Vector2 &tex_uv);
 	virtual void immediate_end(RID p_immediate);
 	virtual void immediate_clear(RID p_immediate);
-	virtual void immediate_set_material(RID p_immediate,RID p_material);
+	virtual void immediate_set_material(RID p_immediate, RID p_material);
 	virtual RID immediate_get_material(RID p_immediate) const;
 
 	virtual AABB immediate_get_aabb(RID p_mesh) const;
@@ -540,25 +510,25 @@ public:
 	virtual void particles_set_emitting(RID p_particles, bool p_emitting);
 	virtual bool particles_is_emitting(RID p_particles) const;
 
-	virtual void particles_set_visibility_aabb(RID p_particles, const AABB& p_visibility);
+	virtual void particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility);
 	virtual AABB particles_get_visibility_aabb(RID p_particles) const;
 
-	virtual void particles_set_emission_half_extents(RID p_particles, const Vector3& p_half_extents);
+	virtual void particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents);
 	virtual Vector3 particles_get_emission_half_extents(RID p_particles) const;
 
-	virtual void particles_set_emission_base_velocity(RID p_particles, const Vector3& p_base_velocity);
+	virtual void particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity);
 	virtual Vector3 particles_get_emission_base_velocity(RID p_particles) const;
 
-	virtual void particles_set_emission_points(RID p_particles, const DVector<Vector3>& p_points);
+	virtual void particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points);
 	virtual DVector<Vector3> particles_get_emission_points(RID p_particles) const;
 
-	virtual void particles_set_gravity_normal(RID p_particles, const Vector3& p_normal);
+	virtual void particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal);
 	virtual Vector3 particles_get_gravity_normal(RID p_particles) const;
 
-	virtual void particles_set_variable(RID p_particles, VS::ParticleVariable p_variable,float p_value);
+	virtual void particles_set_variable(RID p_particles, VS::ParticleVariable p_variable, float p_value);
 	virtual float particles_get_variable(RID p_particles, VS::ParticleVariable p_variable) const;
 
-	virtual void particles_set_randomness(RID p_particles, VS::ParticleVariable p_variable,float p_randomness);
+	virtual void particles_set_randomness(RID p_particles, VS::ParticleVariable p_variable, float p_randomness);
 	virtual float particles_get_randomness(RID p_particles, VS::ParticleVariable p_variable) const;
 
 	virtual void particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos);
@@ -567,19 +537,19 @@ public:
 	virtual void particles_set_color_phases(RID p_particles, int p_phases);
 	virtual int particles_get_color_phases(RID p_particles) const;
 
-	virtual void particles_set_color_phase_color(RID p_particles, int p_phase, const Color& p_color);
+	virtual void particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color);
 	virtual Color particles_get_color_phase_color(RID p_particles, int p_phase) const;
 
 	virtual void particles_set_attractors(RID p_particles, int p_attractors);
 	virtual int particles_get_attractors(RID p_particles) const;
 
-	virtual void particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3& p_pos);
-	virtual Vector3 particles_get_attractor_pos(RID p_particles,int p_attractor) const;
+	virtual void particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos);
+	virtual Vector3 particles_get_attractor_pos(RID p_particles, int p_attractor) const;
 
 	virtual void particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force);
-	virtual float particles_get_attractor_strength(RID p_particles,int p_attractor) const;
+	virtual float particles_get_attractor_strength(RID p_particles, int p_attractor) const;
 
-	virtual void particles_set_material(RID p_particles, RID p_material,bool p_owned=false);
+	virtual void particles_set_material(RID p_particles, RID p_material, bool p_owned = false);
 	virtual RID particles_get_material(RID p_particles) const;
 
 	virtual AABB particles_get_aabb(RID p_particles) const;
@@ -593,70 +563,66 @@ public:
 	/* SKELETON API */
 
 	virtual RID skeleton_create();
-	virtual void skeleton_resize(RID p_skeleton,int p_bones);
+	virtual void skeleton_resize(RID p_skeleton, int p_bones);
 	virtual int skeleton_get_bone_count(RID p_skeleton) const;
-	virtual void skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform);
-	virtual Transform skeleton_bone_get_transform(RID p_skeleton,int p_bone);
-
+	virtual void skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform);
+	virtual Transform skeleton_bone_get_transform(RID p_skeleton, int p_bone);
 
 	/* LIGHT API */
 
 	virtual RID light_create(VS::LightType p_type);
 	virtual VS::LightType light_get_type(RID p_light) const;
 
-	virtual void light_set_color(RID p_light,VS::LightColor p_type, const Color& p_color);
-	virtual Color light_get_color(RID p_light,VS::LightColor p_type) const;
+	virtual void light_set_color(RID p_light, VS::LightColor p_type, const Color &p_color);
+	virtual Color light_get_color(RID p_light, VS::LightColor p_type) const;
 
-	virtual void light_set_shadow(RID p_light,bool p_enabled);
+	virtual void light_set_shadow(RID p_light, bool p_enabled);
 	virtual bool light_has_shadow(RID p_light) const;
 
-	virtual void light_set_volumetric(RID p_light,bool p_enabled);
+	virtual void light_set_volumetric(RID p_light, bool p_enabled);
 	virtual bool light_is_volumetric(RID p_light) const;
 
-	virtual void light_set_projector(RID p_light,RID p_texture);
+	virtual void light_set_projector(RID p_light, RID p_texture);
 	virtual RID light_get_projector(RID p_light) const;
 
 	virtual void light_set_var(RID p_light, VS::LightParam p_var, float p_value);
 	virtual float light_get_var(RID p_light, VS::LightParam p_var) const;
 
-	virtual void light_set_operator(RID p_light,VS::LightOp p_op);
+	virtual void light_set_operator(RID p_light, VS::LightOp p_op);
 	virtual VS::LightOp light_get_operator(RID p_light) const;
 
-	virtual void light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode);
+	virtual void light_omni_set_shadow_mode(RID p_light, VS::LightOmniShadowMode p_mode);
 	virtual VS::LightOmniShadowMode light_omni_get_shadow_mode(RID p_light) const;
 
-
-	virtual void light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode);
+	virtual void light_directional_set_shadow_mode(RID p_light, VS::LightDirectionalShadowMode p_mode);
 	virtual VS::LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light) const;
-	virtual void light_directional_set_shadow_param(RID p_light,VS::LightDirectionalShadowParam p_param, float p_value);
-	virtual float light_directional_get_shadow_param(RID p_light,VS::LightDirectionalShadowParam p_param) const;
+	virtual void light_directional_set_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param, float p_value);
+	virtual float light_directional_get_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param) const;
 
 	virtual AABB light_get_aabb(RID p_poly) const;
 
-
 	virtual RID light_instance_create(RID p_light);
-	virtual void light_instance_set_transform(RID p_light_instance,const Transform& p_transform);
+	virtual void light_instance_set_transform(RID p_light_instance, const Transform &p_transform);
 
 	virtual bool light_instance_has_shadow(RID p_light_instance) const;
 	virtual bool light_instance_assign_shadow(RID p_light_instance);
 	virtual ShadowType light_instance_get_shadow_type(RID p_light_instance) const;
 	virtual int light_instance_get_shadow_passes(RID p_light_instance) const;
 	virtual bool light_instance_get_pssm_shadow_overlap(RID p_light_instance) const;
-	virtual void light_instance_set_custom_transform(RID p_light_instance, int p_index, const CameraMatrix& p_camera, const Transform& p_transform, float p_split_near=0,float p_split_far=0);
-	virtual int light_instance_get_shadow_size(RID p_light_instance, int p_index=0) const { return 1; }
+	virtual void light_instance_set_custom_transform(RID p_light_instance, int p_index, const CameraMatrix &p_camera, const Transform &p_transform, float p_split_near = 0, float p_split_far = 0);
+	virtual int light_instance_get_shadow_size(RID p_light_instance, int p_index = 0) const { return 1; }
 
-	virtual ShadowType light_instance_get_shadow_type(RID p_light_instance,bool p_far=false) const;
-	virtual void light_instance_set_shadow_transform(RID p_light_instance, int p_index, const CameraMatrix& p_camera, const Transform& p_transform, float p_split_near=0,float p_split_far=0);
+	virtual ShadowType light_instance_get_shadow_type(RID p_light_instance, bool p_far = false) const;
+	virtual void light_instance_set_shadow_transform(RID p_light_instance, int p_index, const CameraMatrix &p_camera, const Transform &p_transform, float p_split_near = 0, float p_split_far = 0);
 
 	virtual void shadow_clear_near();
 	virtual bool shadow_allocate_near(RID p_light);
 	virtual bool shadow_allocate_far(RID p_light);
 
-
 	/* PARTICLES INSTANCE */
 
 	virtual RID particles_instance_create(RID p_particles);
-	virtual void particles_instance_set_transform(RID p_particles_instance,const Transform& p_transform);
+	virtual void particles_instance_set_transform(RID p_particles_instance, const Transform &p_transform);
 
 	/* VIEWPORT */
 
@@ -672,24 +638,22 @@ public:
 
 	virtual void begin_frame();
 
-	virtual void set_viewport(const VS::ViewportRect& p_viewport);
-	virtual void set_render_target(RID p_render_target,bool p_transparent_bg=false,bool p_vflip=false);
-	virtual void clear_viewport(const Color& p_color);
-	virtual void capture_viewport(Image* r_capture);
-
-
-	virtual void begin_scene(RID p_viewport_data,RID p_env,VS::ScenarioDebugMode p_debug);
-	virtual void begin_shadow_map( RID p_light_instance, int p_shadow_pass );
+	virtual void set_viewport(const VS::ViewportRect &p_viewport);
+	virtual void set_render_target(RID p_render_target, bool p_transparent_bg = false, bool p_vflip = false);
+	virtual void clear_viewport(const Color &p_color);
+	virtual void capture_viewport(Image *r_capture);
 
-	virtual void set_camera(const Transform& p_world,const CameraMatrix& p_projection,bool p_ortho_hint);
+	virtual void begin_scene(RID p_viewport_data, RID p_env, VS::ScenarioDebugMode p_debug);
+	virtual void begin_shadow_map(RID p_light_instance, int p_shadow_pass);
 
-	virtual void add_light( RID p_light_instance ); ///< all "add_light" calls happen before add_geometry calls
+	virtual void set_camera(const Transform &p_world, const CameraMatrix &p_projection, bool p_ortho_hint);
 
+	virtual void add_light(RID p_light_instance); ///< all "add_light" calls happen before add_geometry calls
 
-	virtual void add_mesh( const RID& p_mesh, const InstanceData *p_data);
-	virtual void add_multimesh( const RID& p_multimesh, const InstanceData *p_data);
-	virtual void add_immediate( const RID& p_immediate, const InstanceData *p_data) {}
-	virtual void add_particles( const RID& p_particle_instance, const InstanceData *p_data);
+	virtual void add_mesh(const RID &p_mesh, const InstanceData *p_data);
+	virtual void add_multimesh(const RID &p_multimesh, const InstanceData *p_data);
+	virtual void add_immediate(const RID &p_immediate, const InstanceData *p_data) {}
+	virtual void add_particles(const RID &p_particle_instance, const InstanceData *p_data);
 
 	virtual void end_scene();
 	virtual void end_shadow_map();
@@ -703,74 +667,72 @@ public:
 	virtual void canvas_disable_blending();
 	virtual void canvas_set_opacity(float p_opacity);
 	virtual void canvas_set_blend_mode(VS::MaterialBlendMode p_mode);
-	virtual void canvas_begin_rect(const Matrix32& p_transform);
-	virtual void canvas_set_clip(bool p_clip, const Rect2& p_rect);
+	virtual void canvas_begin_rect(const Matrix32 &p_transform);
+	virtual void canvas_set_clip(bool p_clip, const Rect2 &p_rect);
 	virtual void canvas_end_rect();
-	virtual void canvas_draw_line(const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width);
-	virtual void canvas_draw_rect(const Rect2& p_rect, int p_flags, const Rect2& p_source,RID p_texture,const Color& p_modulate);
-	virtual void canvas_draw_style_box(const Rect2& p_rect, const Rect2& p_src_region, RID p_texture,const float *p_margins, bool p_draw_center=true,const Color& p_modulate=Color(1,1,1));
-	virtual void canvas_draw_primitive(const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture,float p_width);
-	virtual void canvas_draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor);
-	virtual void canvas_set_transform(const Matrix32& p_transform);
+	virtual void canvas_draw_line(const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width);
+	virtual void canvas_draw_rect(const Rect2 &p_rect, int p_flags, const Rect2 &p_source, RID p_texture, const Color &p_modulate);
+	virtual void canvas_draw_style_box(const Rect2 &p_rect, const Rect2 &p_src_region, RID p_texture, const float *p_margins, bool p_draw_center = true, const Color &p_modulate = Color(1, 1, 1));
+	virtual void canvas_draw_primitive(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width);
+	virtual void canvas_draw_polygon(int p_vertex_count, const int *p_indices, const Vector2 *p_vertices, const Vector2 *p_uvs, const Color *p_colors, const RID &p_texture, bool p_singlecolor);
+	virtual void canvas_set_transform(const Matrix32 &p_transform);
 
-	virtual void canvas_render_items(CanvasItem *p_item_list,int p_z,const Color& p_modulate,CanvasLight *p_light);
+	virtual void canvas_render_items(CanvasItem *p_item_list, int p_z, const Color &p_modulate, CanvasLight *p_light);
 
 	virtual RID canvas_light_occluder_create();
-	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines);
+	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2> &p_lines);
 
 	virtual RID canvas_light_shadow_buffer_create(int p_width);
-	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, CanvasLightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache);
+	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32 &p_light_xform, int p_light_mask, float p_near, float p_far, CanvasLightOccluderInstance *p_occluders, CameraMatrix *p_xform_cache);
 
-	virtual void canvas_debug_viewport_shadows(CanvasLight* p_lights_with_shadow);
+	virtual void canvas_debug_viewport_shadows(CanvasLight *p_lights_with_shadow);
 
 	/* ENVIRONMENT */
 
 	virtual RID environment_create();
 
-	virtual void environment_set_background(RID p_env,VS::EnvironmentBG p_bg);
+	virtual void environment_set_background(RID p_env, VS::EnvironmentBG p_bg);
 	virtual VS::EnvironmentBG environment_get_background(RID p_env) const;
 
-	virtual void environment_set_background_param(RID p_env,VS::EnvironmentBGParam p_param, const Variant& p_value);
-	virtual Variant environment_get_background_param(RID p_env,VS::EnvironmentBGParam p_param) const;
+	virtual void environment_set_background_param(RID p_env, VS::EnvironmentBGParam p_param, const Variant &p_value);
+	virtual Variant environment_get_background_param(RID p_env, VS::EnvironmentBGParam p_param) const;
 
-	virtual void environment_set_enable_fx(RID p_env,VS::EnvironmentFx p_effect,bool p_enabled);
-	virtual bool environment_is_fx_enabled(RID p_env,VS::EnvironmentFx p_effect) const;
+	virtual void environment_set_enable_fx(RID p_env, VS::EnvironmentFx p_effect, bool p_enabled);
+	virtual bool environment_is_fx_enabled(RID p_env, VS::EnvironmentFx p_effect) const;
 
-	virtual void environment_fx_set_param(RID p_env,VS::EnvironmentFxParam p_param,const Variant& p_value);
-	virtual Variant environment_fx_get_param(RID p_env,VS::EnvironmentFxParam p_param) const;
+	virtual void environment_fx_set_param(RID p_env, VS::EnvironmentFxParam p_param, const Variant &p_value);
+	virtual Variant environment_fx_get_param(RID p_env, VS::EnvironmentFxParam p_param) const;
 
 	/* SAMPLED LIGHT */
-	virtual RID sampled_light_dp_create(int p_width,int p_height);
-	virtual void sampled_light_dp_update(RID p_sampled_light,const Color *p_data,float p_multiplier);
-
+	virtual RID sampled_light_dp_create(int p_width, int p_height);
+	virtual void sampled_light_dp_update(RID p_sampled_light, const Color *p_data, float p_multiplier);
 
 	/*MISC*/
 
-	virtual bool is_texture(const RID& p_rid) const;
-	virtual bool is_material(const RID& p_rid) const;
-	virtual bool is_mesh(const RID& p_rid) const;
-	virtual bool is_immediate(const RID& p_rid) const;
-	virtual bool is_multimesh(const RID& p_rid) const;
+	virtual bool is_texture(const RID &p_rid) const;
+	virtual bool is_material(const RID &p_rid) const;
+	virtual bool is_mesh(const RID &p_rid) const;
+	virtual bool is_immediate(const RID &p_rid) const;
+	virtual bool is_multimesh(const RID &p_rid) const;
 	virtual bool is_particles(const RID &p_beam) const;
 
-	virtual bool is_light(const RID& p_rid) const;
-	virtual bool is_light_instance(const RID& p_rid) const;
-	virtual bool is_particles_instance(const RID& p_rid) const;
-	virtual bool is_skeleton(const RID& p_rid) const;
-	virtual bool is_environment(const RID& p_rid) const;
-	virtual bool is_canvas_light_occluder(const RID& p_rid) const;
+	virtual bool is_light(const RID &p_rid) const;
+	virtual bool is_light_instance(const RID &p_rid) const;
+	virtual bool is_particles_instance(const RID &p_rid) const;
+	virtual bool is_skeleton(const RID &p_rid) const;
+	virtual bool is_environment(const RID &p_rid) const;
+	virtual bool is_canvas_light_occluder(const RID &p_rid) const;
 
-	virtual bool is_shader(const RID& p_rid) const;
+	virtual bool is_shader(const RID &p_rid) const;
 
-	virtual void free(const RID& p_rid);
+	virtual void free(const RID &p_rid);
 
 	virtual void custom_shade_model_set_shader(int p_model, RID p_shader);
 	virtual RID custom_shade_model_get_shader(int p_model) const;
-	virtual void custom_shade_model_set_name(int p_model, const String& p_name);
+	virtual void custom_shade_model_set_name(int p_model, const String &p_name);
 	virtual String custom_shade_model_get_name(int p_model) const;
-	virtual void custom_shade_model_set_param_info(int p_model, const List<PropertyInfo>& p_info);
-	virtual void custom_shade_model_get_param_info(int p_model, List<PropertyInfo>* p_info) const;
-
+	virtual void custom_shade_model_set_param_info(int p_model, const List<PropertyInfo> &p_info);
+	virtual void custom_shade_model_get_param_info(int p_model, List<PropertyInfo> *p_info) const;
 
 	virtual void init();
 	virtual void finish();
@@ -787,5 +749,4 @@ public:
 	virtual ~RasterizerDummy();
 };
 
-
 #endif // RASTERIZER_DUMMY_H
diff --git a/servers/visual/shader_language.cpp b/servers/visual/shader_language.cpp
index 0c224ea71..a0a370f42 100644
--- a/servers/visual/shader_language.cpp
+++ b/servers/visual/shader_language.cpp
@@ -27,24 +27,24 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "shader_language.h"
-#include "print_string.h"
 #include "os/os.h"
+#include "print_string.h"
 static bool _is_text_char(CharType c) {
 
-	return (c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9') || c=='_';
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
 }
 
 static bool _is_number(CharType c) {
 
-	return (c>='0' && c<='9');
+	return (c >= '0' && c <= '9');
 }
 
 static bool _is_hex(CharType c) {
 
-	return (c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F');
+	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 }
 
-const char * ShaderLanguage::token_names[TK_MAX]={
+const char *ShaderLanguage::token_names[TK_MAX] = {
 	"EMPTY",
 	"INDENTIFIER",
 	"TRUE",
@@ -97,12 +97,12 @@ const char * ShaderLanguage::token_names[TK_MAX]={
 	"ERROR",
 };
 
-ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_len,int &r_line,int &r_chars) {
+ShaderLanguage::Token ShaderLanguage::read_token(const CharType *p_text, int p_len, int &r_line, int &r_chars) {
 
-#define GETCHAR(m_idx) ((m_idx<p_len)?p_text[m_idx]:CharType(0))
+#define GETCHAR(m_idx) ((m_idx < p_len) ? p_text[m_idx] : CharType(0))
 
-	r_chars=1; //by default everything eats one char
-	switch(GETCHAR(0)) {
+	r_chars = 1; //by default everything eats one char
+	switch (GETCHAR(0)) {
 
 		case '\t':
 		case '\r':
@@ -113,18 +113,19 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 			return Token();
 		case '/': {
 
-			switch(GETCHAR(1)) {
+			switch (GETCHAR(1)) {
 				case '*': { // block comment
 
-
-					while(true) {
-						if (GETCHAR(r_chars+1)==0) {
-							r_chars+=1;
+					while (true) {
+						if (GETCHAR(r_chars + 1) == 0) {
+							r_chars += 1;
 							break;
-						} if (GETCHAR(r_chars+1)=='*' && GETCHAR(r_chars+2)=='/') {
-							r_chars+=3;
+						}
+						if (GETCHAR(r_chars + 1) == '*' && GETCHAR(r_chars + 2) == '/') {
+							r_chars += 3;
 							break;
-						} if (GETCHAR(r_chars+1)=='\n') {
+						}
+						if (GETCHAR(r_chars + 1) == '\n') {
 							r_line++;
 						}
 
@@ -136,8 +137,8 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 				} break;
 				case '/': { // line comment skip
 
-					while(GETCHAR(r_chars+1)!='\n' && GETCHAR(r_chars+1)!=0) {
-							r_chars++;
+					while (GETCHAR(r_chars + 1) != '\n' && GETCHAR(r_chars + 1) != 0) {
+						r_chars++;
 					}
 					r_chars++;
 					//r_line++;
@@ -147,17 +148,16 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 				} break;
 				case '=': { // diveq
 
-					r_chars=2;
+					r_chars = 2;
 					return Token(TK_OP_ASSIGN_DIV);
 
 				} break;
 				default:
 					return Token(TK_OP_DIV);
-
 			}
 		} break;
 		case '=': {
-			if (GETCHAR(1)=='=') {
+			if (GETCHAR(1) == '=') {
 				r_chars++;
 				return Token(TK_OP_EQUAL);
 			}
@@ -166,7 +166,7 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 
 		} break;
 		case '<': {
-			if (GETCHAR(1)=='=') {
+			if (GETCHAR(1) == '=') {
 				r_chars++;
 				return Token(TK_OP_LESS_EQUAL);
 			} /*else if (GETCHAR(1)=='<') {
@@ -183,10 +183,10 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 
 		} break;
 		case '>': {
-			if (GETCHAR(1)=='=') {
+			if (GETCHAR(1) == '=') {
 				r_chars++;
 				return Token(TK_OP_GREATER_EQUAL);
-			}/* else if (GETCHAR(1)=='<') {
+			} /* else if (GETCHAR(1)=='<') {
 				r_chars++;
 				if (GETCHAR(2)=='=') {
 					r_chars++;
@@ -200,7 +200,7 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 
 		} break;
 		case '!': {
-			if (GETCHAR(1)=='=') {
+			if (GETCHAR(1) == '=') {
 				r_chars++;
 				return Token(TK_OP_NOT_EQUAL);
 			}
@@ -217,7 +217,7 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 		//case '[':
 		//	return Token(TK_BRACKET_OPEN);
 		//case ']':
-	//		return Token(TK_BRACKET_CLOSE);
+		//		return Token(TK_BRACKET_CLOSE);
 		case '(':
 			return Token(TK_PARENTHESIS_OPEN);
 		case ')':
@@ -233,18 +233,18 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 		//case '^':
 		//	return Token(TK_OP_BIT_XOR);
 		//case '~':
-	//		return Token(TK_OP_BIT_INVERT);
+		//		return Token(TK_OP_BIT_INVERT);
 		case '&': {
 
-			if (GETCHAR(1)=='&') {
+			if (GETCHAR(1) == '&') {
 
 				r_chars++;
 				return Token(TK_OP_AND);
 			}
 
-			return Token(TK_ERROR,"Unknown character");
+			return Token(TK_ERROR, "Unknown character");
 
-/*
+			/*
 			if (GETCHAR(1)=='=') {
 				r_chars++;
 				return Token(TK_OP_ASSIGN_BIT_AND);
@@ -256,13 +256,13 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 		} break;
 		case '|': {
 
-			if (GETCHAR(1)=='|') {
+			if (GETCHAR(1) == '|') {
 
 				r_chars++;
 				return Token(TK_OP_OR);
 			}
 
-			return Token(TK_ERROR,"Unknown character");
+			return Token(TK_ERROR, "Unknown character");
 
 			/*
 			if (GETCHAR(1)=='=') {
@@ -277,7 +277,7 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 		} break;
 		case '*': {
 
-			if (GETCHAR(1)=='=') {
+			if (GETCHAR(1) == '=') {
 				r_chars++;
 				return Token(TK_OP_ASSIGN_MUL);
 			}
@@ -285,10 +285,10 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 		} break;
 		case '+': {
 
-			if (GETCHAR(1)=='=') {
+			if (GETCHAR(1) == '=') {
 				r_chars++;
 				return Token(TK_OP_ASSIGN_ADD);
-			}  /*else if (GETCHAR(1)=='+') {
+			} /*else if (GETCHAR(1)=='+') {
 
 				r_chars++;
 				return Token(TK_OP_PLUS_PLUS);
@@ -298,10 +298,10 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 		} break;
 		case '-': {
 
-			if (GETCHAR(1)=='=') {
+			if (GETCHAR(1) == '=') {
 				r_chars++;
 				return Token(TK_OP_ASSIGN_SUB);
-			}/* else if (GETCHAR(1)=='-') {
+			} /* else if (GETCHAR(1)=='-') {
 
 				r_chars++;
 				return Token(TK_OP_MINUS_MINUS);
@@ -320,58 +320,57 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 		} break;*/
 		default: {
 
-			if (_is_number(GETCHAR(0)) || (GETCHAR(0)=='.' && _is_number(GETCHAR(1)))) {
+			if (_is_number(GETCHAR(0)) || (GETCHAR(0) == '.' && _is_number(GETCHAR(1)))) {
 				// parse number
-				bool period_found=false;
-				bool exponent_found=false;
-				bool hexa_found=false;
-				bool sign_found=false;
+				bool period_found = false;
+				bool exponent_found = false;
+				bool hexa_found = false;
+				bool sign_found = false;
 
 				String str;
-				int i=0;
+				int i = 0;
 
-				while(true) {
-					if (GETCHAR(i)=='.') {
+				while (true) {
+					if (GETCHAR(i) == '.') {
 						if (period_found || exponent_found)
-							return Token(TK_ERROR,"Invalid numeric constant");
-						period_found=true;
-					} else if (GETCHAR(i)=='x') {
-						if (hexa_found || str.length()!=1 || str[0]!='0')
-							return Token(TK_ERROR,"Invalid numeric constant");
-						hexa_found=true;
-					} else if (GETCHAR(i)=='e') {
+							return Token(TK_ERROR, "Invalid numeric constant");
+						period_found = true;
+					} else if (GETCHAR(i) == 'x') {
+						if (hexa_found || str.length() != 1 || str[0] != '0')
+							return Token(TK_ERROR, "Invalid numeric constant");
+						hexa_found = true;
+					} else if (GETCHAR(i) == 'e') {
 						if (hexa_found || exponent_found)
-							return Token(TK_ERROR,"Invalid numeric constant");
-						exponent_found=true;
+							return Token(TK_ERROR, "Invalid numeric constant");
+						exponent_found = true;
 					} else if (_is_number(GETCHAR(i))) {
 						//all ok
 					} else if (hexa_found && _is_hex(GETCHAR(i))) {
 
-					} else if ((GETCHAR(i)=='-' || GETCHAR(i)=='+') && exponent_found) {
+					} else if ((GETCHAR(i) == '-' || GETCHAR(i) == '+') && exponent_found) {
 						if (sign_found)
-							return Token(TK_ERROR,"Invalid numeric constant");
-						sign_found=true;
+							return Token(TK_ERROR, "Invalid numeric constant");
+						sign_found = true;
 					} else
 						break;
 
-					str+=CharType(GETCHAR(i));
+					str += CharType(GETCHAR(i));
 					i++;
 				}
 
-				if (!_is_number(str[str.length()-1]))
-					return Token(TK_ERROR,"Invalid numeric constant");
+				if (!_is_number(str[str.length() - 1]))
+					return Token(TK_ERROR, "Invalid numeric constant");
 
-				r_chars+=str.length()-1;
-				return Token(TK_REAL_CONSTANT,str);
+				r_chars += str.length() - 1;
+				return Token(TK_REAL_CONSTANT, str);
 				/*
 				if (period_found)
 					return Token(TK_NUMBER_REAL,str);
 				else
 					return Token(TK_NUMBER_INTEGER,str);*/
-
 			}
 
-			if (GETCHAR(0)=='.') {
+			if (GETCHAR(0) == '.') {
 				//parse period
 				return Token(TK_PERIOD);
 			}
@@ -379,43 +378,46 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 			if (_is_text_char(GETCHAR(0))) {
 				// parse identifier
 				String str;
-				str+=CharType(GETCHAR(0));
+				str += CharType(GETCHAR(0));
 
-				while(_is_text_char(GETCHAR(r_chars))) {
+				while (_is_text_char(GETCHAR(r_chars))) {
 
-					str+=CharType(GETCHAR(r_chars));
+					str += CharType(GETCHAR(r_chars));
 					r_chars++;
 				}
 
 				//see if keyword
-				struct _kws { TokenType token; const char *text;};
-				static const  _kws keyword_list[]={
-					{TK_TRUE,"true"},
-					{TK_FALSE,"false"},
-					{TK_TYPE_VOID,"void"},
-					{TK_TYPE_BOOL,"bool"},
+				struct _kws {
+					TokenType token;
+					const char *text;
+				};
+				static const _kws keyword_list[] = {
+					{ TK_TRUE, "true" },
+					{ TK_FALSE, "false" },
+					{ TK_TYPE_VOID, "void" },
+					{ TK_TYPE_BOOL, "bool" },
 					/*{TK_TYPE_INT,"int"},
 					{TK_TYPE_INT2,"int2"},
 					{TK_TYPE_INT3,"int3"},
 					{TK_TYPE_INT4,"int4"},*/
-					{TK_TYPE_FLOAT,"float"},
+					{ TK_TYPE_FLOAT, "float" },
 					/*{TK_TYPE_FLOAT2,"float2"},
 					{TK_TYPE_FLOAT3,"float3"},
 					{TK_TYPE_FLOAT4,"float4"},*/
-					{TK_TYPE_VEC2,"vec2"},
-					{TK_TYPE_VEC3,"vec3"},
-					{TK_TYPE_VEC4,"vec4"},
-					{TK_TYPE_TEXTURE,"texture"},
-					{TK_TYPE_CUBEMAP,"cubemap"},
-					{TK_TYPE_COLOR,"color"},
+					{ TK_TYPE_VEC2, "vec2" },
+					{ TK_TYPE_VEC3, "vec3" },
+					{ TK_TYPE_VEC4, "vec4" },
+					{ TK_TYPE_TEXTURE, "texture" },
+					{ TK_TYPE_CUBEMAP, "cubemap" },
+					{ TK_TYPE_COLOR, "color" },
 
-					{TK_TYPE_MAT2,"mat2"},
+					{ TK_TYPE_MAT2, "mat2" },
 					/*{TK_TYPE_MAT3,"mat3"},
 					{TK_TYPE_MAT4,"mat3"},*/
-					{TK_TYPE_MAT3,"mat3"},
-					{TK_TYPE_MAT4,"mat4"},
-					{TK_CF_IF,"if"},
-					{TK_CF_ELSE,"else"},
+					{ TK_TYPE_MAT3, "mat3" },
+					{ TK_TYPE_MAT4, "mat4" },
+					{ TK_CF_IF, "if" },
+					{ TK_CF_ELSE, "else" },
 					/*
 					{TK_CF_FOR,"for"},
 					{TK_CF_WHILE,"while"},
@@ -423,28 +425,27 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 					{TK_CF_SWITCH,"switch"},
 					{TK_CF_BREAK,"break"},
 					{TK_CF_CONTINUE,"continue"},*/
-					{TK_CF_RETURN,"return"},
-					{TK_UNIFORM,"uniform"},
-					{TK_ERROR,NULL}
+					{ TK_CF_RETURN, "return" },
+					{ TK_UNIFORM, "uniform" },
+					{ TK_ERROR, NULL }
 				};
 
-				int idx=0;
+				int idx = 0;
 
-				while(keyword_list[idx].text) {
+				while (keyword_list[idx].text) {
 
-					if (str==keyword_list[idx].text)
+					if (str == keyword_list[idx].text)
 						return Token(keyword_list[idx].token);
 					idx++;
 				}
 
-
-				return Token(TK_INDENTIFIER,str);
+				return Token(TK_INDENTIFIER, str);
 			}
 
-			if (GETCHAR(0)>32)
-				return Token(TK_ERROR,"Tokenizer: Unknown character #"+itos(GETCHAR(0))+": '"+String::chr(GETCHAR(0))+"'");
+			if (GETCHAR(0) > 32)
+				return Token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)) + ": '" + String::chr(GETCHAR(0)) + "'");
 			else
-				return Token(TK_ERROR,"Tokenizer: Unknown character #"+itos(GETCHAR(0)));
+				return Token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)));
 
 		} break;
 	}
@@ -453,88 +454,82 @@ ShaderLanguage::Token ShaderLanguage::read_token(const CharType* p_text,int p_le
 	return Token();
 }
 
-Error ShaderLanguage::tokenize(const String& p_text,Vector<Token> *p_tokens,String *r_error,int *r_err_line,int *r_err_column) {
+Error ShaderLanguage::tokenize(const String &p_text, Vector<Token> *p_tokens, String *r_error, int *r_err_line, int *r_err_column) {
 
+	int len = p_text.length();
+	int pos = 0;
 
-	int len =p_text.length();
-	int pos=0;
+	int line = 0;
+	int col = 0;
 
-	int line=0;
-	int col=0;
+	while (pos < len) {
 
-	while(pos<len) {
+		int advance = 0;
+		int prev_line = line;
+		Token t = read_token(&p_text[pos], len - pos, line, advance);
+		t.line = line;
+		t.col = col;
 
-		int advance=0;
-		int prev_line=line;
-		Token t = read_token(&p_text[pos],len-pos,line,advance);
-		t.line=line;
-		t.col=col;
-
-		if (t.type==TK_ERROR) {
+		if (t.type == TK_ERROR) {
 
 			if (r_error) {
-				*r_error=t.text;
-				*r_err_line=line;
-				*r_err_column=col;
+				*r_error = t.text;
+				*r_err_line = line;
+				*r_err_column = col;
 				return ERR_COMPILATION_FAILED;
 			}
 		}
 
-		if (line==prev_line) {
-			col+=advance;
+		if (line == prev_line) {
+			col += advance;
 		} else {
-			col=0;
+			col = 0;
 			//p_tokens->push_back(Token(TK_LINE,itos(line)))
 		}
 
-		if (t.type!=TK_EMPTY)
+		if (t.type != TK_EMPTY)
 			p_tokens->push_back(t);
 
-		pos+=advance;
-
+		pos += advance;
 	}
 
 	return OK;
-
 }
 
-String ShaderLanguage::lex_debug(const String& p_code) {
+String ShaderLanguage::lex_debug(const String &p_code) {
 
 	Vector<Token> tokens;
 	String error;
-	int errline,errcol;
-	if (tokenize(p_code,&tokens,&error,&errline,&errcol)!=OK)
+	int errline, errcol;
+	if (tokenize(p_code, &tokens, &error, &errline, &errcol) != OK)
 		return error;
 	String ret;
-	for(int i=0;i<tokens.size();i++) {
-		ret+=String(token_names[tokens[i].type])+":"+itos(tokens[i].line)+":"+itos(tokens[i].col)+":"+tokens[i].text+"\n";
+	for (int i = 0; i < tokens.size(); i++) {
+		ret += String(token_names[tokens[i].type]) + ":" + itos(tokens[i].line) + ":" + itos(tokens[i].col) + ":" + tokens[i].text + "\n";
 	}
 
 	return ret;
-
 }
 
 bool ShaderLanguage::is_token_datatype(TokenType p_type) {
 
-	return
-	(p_type==TK_TYPE_VOID) ||
-	(p_type==TK_TYPE_BOOL) ||
-	(p_type==TK_TYPE_FLOAT) ||
-	(p_type==TK_TYPE_VEC2) ||
-	(p_type==TK_TYPE_VEC3) ||
-	(p_type==TK_TYPE_VEC4) ||
-	(p_type==TK_TYPE_COLOR) ||
-	(p_type==TK_TYPE_MAT2) ||
-	(p_type==TK_TYPE_MAT3) ||
-	(p_type==TK_TYPE_MAT4) ||
-	(p_type==TK_TYPE_CUBEMAP) ||
-	(p_type==TK_TYPE_TEXTURE);
-
+	return (p_type == TK_TYPE_VOID) ||
+		   (p_type == TK_TYPE_BOOL) ||
+		   (p_type == TK_TYPE_FLOAT) ||
+		   (p_type == TK_TYPE_VEC2) ||
+		   (p_type == TK_TYPE_VEC3) ||
+		   (p_type == TK_TYPE_VEC4) ||
+		   (p_type == TK_TYPE_COLOR) ||
+		   (p_type == TK_TYPE_MAT2) ||
+		   (p_type == TK_TYPE_MAT3) ||
+		   (p_type == TK_TYPE_MAT4) ||
+		   (p_type == TK_TYPE_CUBEMAP) ||
+		   (p_type == TK_TYPE_TEXTURE);
 }
 
 ShaderLanguage::DataType ShaderLanguage::get_token_datatype(TokenType p_type) {
 
-	switch(p_type) {
+	switch (p_type) {
 
 		case TK_TYPE_VOID: return TYPE_VOID;
 		case TK_TYPE_BOOL: return TYPE_BOOL;
@@ -554,10 +549,9 @@ ShaderLanguage::DataType ShaderLanguage::get_token_datatype(TokenType p_type) {
 	return TYPE_VOID;
 }
 
-
 String ShaderLanguage::get_datatype_name(DataType p_type) {
 
-	switch(p_type) {
+	switch (p_type) {
 
 		case TYPE_VOID: return "void";
 		case TYPE_BOOL: return "bool";
@@ -576,136 +570,123 @@ String ShaderLanguage::get_datatype_name(DataType p_type) {
 	return "";
 }
 
-
 bool ShaderLanguage::is_token_nonvoid_datatype(TokenType p_type) {
 
-	return
-		(p_type==TK_TYPE_BOOL) ||
-		(p_type==TK_TYPE_FLOAT) ||
-		(p_type==TK_TYPE_VEC2) ||
-		(p_type==TK_TYPE_VEC3) ||
-		(p_type==TK_TYPE_VEC4) ||
-		(p_type==TK_TYPE_COLOR) ||
-		(p_type==TK_TYPE_MAT2) ||
-		(p_type==TK_TYPE_MAT3) ||
-		(p_type==TK_TYPE_MAT4) ||
-		(p_type==TK_TYPE_TEXTURE) ||
-		(p_type==TK_TYPE_CUBEMAP);
-
+	return (p_type == TK_TYPE_BOOL) ||
+		   (p_type == TK_TYPE_FLOAT) ||
+		   (p_type == TK_TYPE_VEC2) ||
+		   (p_type == TK_TYPE_VEC3) ||
+		   (p_type == TK_TYPE_VEC4) ||
+		   (p_type == TK_TYPE_COLOR) ||
+		   (p_type == TK_TYPE_MAT2) ||
+		   (p_type == TK_TYPE_MAT3) ||
+		   (p_type == TK_TYPE_MAT4) ||
+		   (p_type == TK_TYPE_TEXTURE) ||
+		   (p_type == TK_TYPE_CUBEMAP);
 }
 
+bool ShaderLanguage::parser_is_at_function(Parser &parser) {
 
-bool ShaderLanguage::parser_is_at_function(Parser& parser) {
-
-	return (is_token_datatype(parser.get_next_token_type(0)) && parser.get_next_token_type(1)==TK_INDENTIFIER && parser.get_next_token_type(2)==TK_PARENTHESIS_OPEN);
+	return (is_token_datatype(parser.get_next_token_type(0)) && parser.get_next_token_type(1) == TK_INDENTIFIER && parser.get_next_token_type(2) == TK_PARENTHESIS_OPEN);
 }
 
-
-
-bool ShaderLanguage::test_existing_identifier(Node *p_node,const StringName p_identifier,bool p_func,bool p_var,bool p_builtin) {
+bool ShaderLanguage::test_existing_identifier(Node *p_node, const StringName p_identifier, bool p_func, bool p_var, bool p_builtin) {
 
 	Node *node = p_node;
 
-	while(node) {
+	while (node) {
 
-		if (node->type==Node::TYPE_BLOCK) {
+		if (node->type == Node::TYPE_BLOCK) {
 
-			BlockNode *block = (BlockNode*)node;
+			BlockNode *block = (BlockNode *)node;
 			if (block->variables.has(p_identifier))
 				return true;
-		} else if (node->type==Node::TYPE_PROGRAM) {
+		} else if (node->type == Node::TYPE_PROGRAM) {
 
-			ProgramNode *program = (ProgramNode*)node;
-			for(int i=0;i<program->functions.size();i++) {
+			ProgramNode *program = (ProgramNode *)node;
+			for (int i = 0; i < program->functions.size(); i++) {
 
-				if (program->functions[i].name==p_identifier) {
+				if (program->functions[i].name == p_identifier) {
 					return true;
 				}
 			}
 
-			if(program->builtin_variables.has(p_identifier)) {
+			if (program->builtin_variables.has(p_identifier)) {
 				return true;
 			}
-			if(program->uniforms.has(p_identifier)) {
+			if (program->uniforms.has(p_identifier)) {
 				return true;
 			}
 
-		} else if (node->type==Node::TYPE_FUNCTION) {
+		} else if (node->type == Node::TYPE_FUNCTION) {
 
-			FunctionNode *func=(FunctionNode*)node;
-			for(int i=0;i<func->arguments.size();i++)
-				if (func->arguments[i].name==p_identifier)
+			FunctionNode *func = (FunctionNode *)node;
+			for (int i = 0; i < func->arguments.size(); i++)
+				if (func->arguments[i].name == p_identifier)
 					return true;
 		}
 
-		node=node->parent;
+		node = node->parent;
 	}
 
 	// try keywords
 
-	int idx=0;
+	int idx = 0;
 
 	//todo optimize
-	while(intrinsic_func_defs[idx].name) {
+	while (intrinsic_func_defs[idx].name) {
 
-		if (p_identifier.operator String()==intrinsic_func_defs[idx].name)
+		if (p_identifier.operator String() == intrinsic_func_defs[idx].name)
 			return true;
 		idx++;
 	}
 
-
 	return false;
-
 }
 
+Error ShaderLanguage::parse_function(Parser &parser, BlockNode *p_block) {
 
-Error ShaderLanguage::parse_function(Parser& parser,BlockNode *p_block) {
-
-	if (!p_block->parent || p_block->parent->type!=Node::TYPE_PROGRAM) {
+	if (!p_block->parent || p_block->parent->type != Node::TYPE_PROGRAM) {
 		parser.set_error("Misplaced function");
 		return ERR_PARSE_ERROR;
-
 	}
 
-
-	ProgramNode *program = (ProgramNode*)p_block->parent;
+	ProgramNode *program = (ProgramNode *)p_block->parent;
 
 	StringName name = parser.get_next_token(1).text;
 
-	if (test_existing_identifier(p_block,name)) {
+	if (test_existing_identifier(p_block, name)) {
 
-		parser.set_error("Duplicate Identifier (existing variable/builtin/function): "+name);
+		parser.set_error("Duplicate Identifier (existing variable/builtin/function): " + name);
 		return ERR_PARSE_ERROR;
-
 	}
 
-
 	FunctionNode *function = parser.create_node<FunctionNode>(program);
 	function->body = parser.create_node<BlockNode>(function);
 
-	function->name=name;
+	function->name = name;
 
-	function->return_type=get_token_datatype(parser.get_next_token_type(0));
+	function->return_type = get_token_datatype(parser.get_next_token_type(0));
 
 	{ //add to programnode
 		ProgramNode::Function f;
-		f.name=name;
-		f.function=function;
+		f.name = name;
+		f.function = function;
 		program->functions.push_back(f);
 	}
 
-	int ofs=3;
+	int ofs = 3;
 
-	while(true) {
+	while (true) {
 
 		//end of arguments
-		if (parser.get_next_token_type(ofs)==TK_PARENTHESIS_CLOSE) {
+		if (parser.get_next_token_type(ofs) == TK_PARENTHESIS_CLOSE) {
 			ofs++;
 			break;
 		}
 		//next argument awaits
-		if (parser.get_next_token_type(ofs)==TK_COMMA) {
-			if (!is_token_nonvoid_datatype(parser.get_next_token_type(ofs+1))) {
+		if (parser.get_next_token_type(ofs) == TK_COMMA) {
+			if (!is_token_nonvoid_datatype(parser.get_next_token_type(ofs + 1))) {
 				parser.set_error("Expected Identifier or ')' following ','");
 				return ERR_PARSE_ERROR;
 			}
@@ -713,60 +694,58 @@ Error ShaderLanguage::parse_function(Parser& parser,BlockNode *p_block) {
 			continue;
 		}
 
-
-
-		if (!is_token_nonvoid_datatype(parser.get_next_token_type(ofs+0))) {
+		if (!is_token_nonvoid_datatype(parser.get_next_token_type(ofs + 0))) {
 			parser.set_error("Invalid Argument Type");
 			return ERR_PARSE_ERROR;
 		}
 
-		DataType identtype=get_token_datatype(parser.get_next_token_type(ofs+0));
+		DataType identtype = get_token_datatype(parser.get_next_token_type(ofs + 0));
 
-		if (parser.get_next_token_type(ofs+1)!=TK_INDENTIFIER) {
+		if (parser.get_next_token_type(ofs + 1) != TK_INDENTIFIER) {
 			parser.set_error("Expected Argument Identifier");
 			return ERR_PARSE_ERROR;
 		}
 
-		StringName identname=parser.get_next_token(ofs+1).text;
+		StringName identname = parser.get_next_token(ofs + 1).text;
 
-		if (test_existing_identifier(function,identname)) {
-			parser.set_error("Duplicate Argument Identifier: "+identname);
+		if (test_existing_identifier(function, identname)) {
+			parser.set_error("Duplicate Argument Identifier: " + identname);
 			return ERR_DUPLICATE_SYMBOL;
 		}
 
 		FunctionNode::Argument arg;
-		arg.name=identname;
-		arg.type=identtype;
+		arg.name = identname;
+		arg.type = identtype;
 		//function->body->variables[arg.name]=arg.type;
 		function->arguments.push_back(arg);
 
-		ofs+=2;
+		ofs += 2;
 	}
 
 	parser.advance(ofs);
 	// match {
-	if (parser.get_next_token_type()!=TK_CURLY_BRACKET_OPEN) {
+	if (parser.get_next_token_type() != TK_CURLY_BRACKET_OPEN) {
 		parser.set_error("Expected '{'");
 		return ERR_PARSE_ERROR;
 	}
 
 	parser.advance();
-	Error err = parse_block(parser,function->body);
+	Error err = parse_block(parser, function->body);
 
 	if (err)
 		return err;
 
 	// make sure that if the function has a return type, it does return something..
-	if (function->return_type!=TYPE_VOID) {
-		bool found=false;
-		for(int i=0;i<function->body->statements.size();i++) {
-			if (function->body->statements[i]->type==Node::TYPE_CONTROL_FLOW) {
+	if (function->return_type != TYPE_VOID) {
+		bool found = false;
+		for (int i = 0; i < function->body->statements.size(); i++) {
+			if (function->body->statements[i]->type == Node::TYPE_CONTROL_FLOW) {
 
-				ControlFlowNode *cf = (ControlFlowNode*)function->body->statements[i];
-				if (cf->flow_op==FLOW_OP_RETURN) {
+				ControlFlowNode *cf = (ControlFlowNode *)function->body->statements[i];
+				if (cf->flow_op == FLOW_OP_RETURN) {
 					// type of return was already checked when inserted
 					// no need to check here
-					found=true;
+					found = true;
 				}
 			}
 		}
@@ -780,607 +759,606 @@ Error ShaderLanguage::parse_function(Parser& parser,BlockNode *p_block) {
 	return OK;
 }
 
-
-const ShaderLanguage::IntrinsicFuncDef ShaderLanguage::intrinsic_func_defs[]={
+const ShaderLanguage::IntrinsicFuncDef ShaderLanguage::intrinsic_func_defs[] = {
 	//constructors
-	{"bool",TYPE_BOOL,{TYPE_BOOL,TYPE_VOID}},
-	{"float",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"vec2",TYPE_VEC2,{TYPE_FLOAT,TYPE_VOID}},
-	{"vec2",TYPE_VEC2,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"vec3",TYPE_VEC3,{TYPE_FLOAT,TYPE_VOID}},
-	{"vec3",TYPE_VEC3,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"vec3",TYPE_VEC3,{TYPE_VEC2,TYPE_FLOAT,TYPE_VOID}},
-	{"vec3",TYPE_VEC3,{TYPE_FLOAT,TYPE_VEC2,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_VEC2,TYPE_FLOAT,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_VEC2,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VEC2,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_VEC3,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_VEC3,TYPE_FLOAT,TYPE_VOID}},
-	{"vec4",TYPE_VEC4,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"mat2",TYPE_MAT2,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"mat3",TYPE_MAT3,{TYPE_VEC3,TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"mat4",TYPE_MAT4,{TYPE_VEC4,TYPE_VEC4,TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
+	{ "bool", TYPE_BOOL, { TYPE_BOOL, TYPE_VOID } },
+	{ "float", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "vec2", TYPE_VEC2, { TYPE_FLOAT, TYPE_VOID } },
+	{ "vec2", TYPE_VEC2, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_VOID } },
+	{ "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "vec3", TYPE_VEC3, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
+	{ "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_VEC2, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC3, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
+	{ "vec4", TYPE_VEC4, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "mat2", TYPE_MAT2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "mat3", TYPE_MAT3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "mat4", TYPE_MAT4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
 	//intrinsics - trigonometry
-	{"sin",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"cos",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"tan",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"asin",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"acos",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"atan",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"atan2",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"sinh",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"cosh",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"tanh",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
+	{ "sin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "cos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "tan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "asin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "acos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "atan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "atan2", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "sinh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "cosh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "tanh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
 	//intrinsics - exponential
-	{"pow",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"pow",TYPE_VEC2,{TYPE_VEC2,TYPE_FLOAT,TYPE_VOID}},
-	{"pow",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"pow",TYPE_VEC3,{TYPE_VEC3,TYPE_FLOAT,TYPE_VOID}},
-	{"pow",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"pow",TYPE_VEC4,{TYPE_VEC4,TYPE_FLOAT,TYPE_VOID}},
-	{"pow",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"exp",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"exp",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"exp",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"exp",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"log",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"log",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"log",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"log",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"sqrt",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"sqrt",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"sqrt",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"sqrt",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
+	{ "pow", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "pow", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
+	{ "pow", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "pow", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
+	{ "pow", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "pow", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
+	{ "pow", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "exp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "exp", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "exp", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "exp", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "log", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "log", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "log", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "log", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "sqrt", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "sqrt", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "sqrt", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "sqrt", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
 	//intrinsics - common
-	{"abs",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"abs",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"abs",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"abs",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"sign",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"sign",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"sign",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"sign",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"floor",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"floor",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"floor",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"floor",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"trunc",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"trunc",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"trunc",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"trunc",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"round",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"round",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"round",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"round",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"ceil",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"ceil",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"ceil",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"ceil",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"fract",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{"fract",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"fract",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"fract",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"mod",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"mod",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"mod",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"mod",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"min",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"min",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"min",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"min",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"max",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"max",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"max",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"max",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"clamp",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"clamp",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"clamp",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"clamp",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"clamp",TYPE_VEC2,{TYPE_VEC2,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"clamp",TYPE_VEC3,{TYPE_VEC3,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"clamp",TYPE_VEC4,{TYPE_VEC4,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"mix",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"mix",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_FLOAT,TYPE_VOID}},
-	{"mix",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"mix",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_FLOAT,TYPE_VOID}},
-	{"mix",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"mix",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_FLOAT,TYPE_VOID}},
-	{"mix",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"step",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"step",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"step",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"step",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"step",TYPE_VEC2,{TYPE_FLOAT,TYPE_VEC2,TYPE_VOID}},
-	{"step",TYPE_VEC3,{TYPE_FLOAT,TYPE_VEC3,TYPE_VOID}},
-	{"step",TYPE_VEC4,{TYPE_FLOAT,TYPE_VEC4,TYPE_VOID}},
-	{"smoothstep",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
-	{"smoothstep",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"smoothstep",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"smoothstep",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"smoothstep",TYPE_VEC2,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VEC2,TYPE_VOID}},
-	{"smoothstep",TYPE_VEC3,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VEC3,TYPE_VOID}},
-	{"smoothstep",TYPE_VEC4,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VEC4,TYPE_VOID}},
+	{ "abs", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "abs", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "abs", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "abs", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "sign", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "sign", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "sign", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "sign", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "floor", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "floor", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "floor", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "floor", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "trunc", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "trunc", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "trunc", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "trunc", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "round", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "round", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "round", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "round", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "ceil", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "ceil", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "ceil", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "ceil", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "fract", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ "fract", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "fract", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "fract", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "mod", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "mod", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "mod", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "mod", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "min", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "min", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "min", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "min", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "max", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "max", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "max", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "max", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "clamp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "mix", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
+	{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
+	{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
+	{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "step", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "step", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "step", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "step", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "step", TYPE_VEC2, { TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
+	{ "step", TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC3, TYPE_VOID } },
+	{ "step", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC4, TYPE_VOID } },
+	{ "smoothstep", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
+	{ "smoothstep", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "smoothstep", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "smoothstep", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "smoothstep", TYPE_VEC2, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
+	{ "smoothstep", TYPE_VEC3, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC3, TYPE_VOID } },
+	{ "smoothstep", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC4, TYPE_VOID } },
 
 	//intrinsics - geometric
-	{"length",TYPE_FLOAT,{TYPE_VEC2,TYPE_VOID}},
-	{"length",TYPE_FLOAT,{TYPE_VEC3,TYPE_VOID}},
-	{"length",TYPE_FLOAT,{TYPE_VEC4,TYPE_VOID}},
-	{"distance",TYPE_FLOAT,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"distance",TYPE_FLOAT,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"distance",TYPE_FLOAT,{TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"dot",TYPE_FLOAT,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
-	{"dot",TYPE_FLOAT,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"dot",TYPE_FLOAT,{TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
-	{"cross",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"normalize",TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{"normalize",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{"normalize",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{"reflect",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
-	{"refract",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_FLOAT,TYPE_VOID}},
+	{ "length", TYPE_FLOAT, { TYPE_VEC2, TYPE_VOID } },
+	{ "length", TYPE_FLOAT, { TYPE_VEC3, TYPE_VOID } },
+	{ "length", TYPE_FLOAT, { TYPE_VEC4, TYPE_VOID } },
+	{ "distance", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "distance", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "distance", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "dot", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
+	{ "dot", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "dot", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
+	{ "cross", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "normalize", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ "normalize", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ "normalize", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ "reflect", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
+	{ "refract", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
 	//intrinsics - texture
-	{"tex",TYPE_VEC4,{TYPE_TEXTURE,TYPE_VEC2,TYPE_VOID}},
-	{"texcube",TYPE_VEC4,{TYPE_CUBEMAP,TYPE_VEC3,TYPE_VOID}},
-	{"texscreen",TYPE_VEC3,{TYPE_VEC2,TYPE_VOID}},
-	{"texpos",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
+	{ "tex", TYPE_VEC4, { TYPE_TEXTURE, TYPE_VEC2, TYPE_VOID } },
+	{ "texcube", TYPE_VEC4, { TYPE_CUBEMAP, TYPE_VEC3, TYPE_VOID } },
+	{ "texscreen", TYPE_VEC3, { TYPE_VEC2, TYPE_VOID } },
+	{ "texpos", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
 
-	{NULL,TYPE_VOID,{TYPE_VOID}}
+	{ NULL, TYPE_VOID, { TYPE_VOID } }
 
 };
 
-const ShaderLanguage::OperatorDef ShaderLanguage::operator_defs[]={
+const ShaderLanguage::OperatorDef ShaderLanguage::operator_defs[] = {
 
-	{OP_ASSIGN,TYPE_VOID,{TYPE_BOOL,TYPE_BOOL}},
-	{OP_ASSIGN,TYPE_VOID,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_ASSIGN,TYPE_VOID,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_ASSIGN,TYPE_VOID,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_ASSIGN,TYPE_VOID,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_ASSIGN,TYPE_VOID,{TYPE_MAT2,TYPE_MAT2}},
-	{OP_ASSIGN,TYPE_VOID,{TYPE_MAT3,TYPE_MAT3}},
-	{OP_ASSIGN,TYPE_VOID,{TYPE_MAT4,TYPE_MAT4}},
-	{OP_ADD,TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_ADD,TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_ADD,TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_ADD,TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_SUB,TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_SUB,TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_SUB,TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_SUB,TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_MUL,TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_MUL,TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_MUL,TYPE_VEC2,{TYPE_VEC2,TYPE_FLOAT}},
-	{OP_MUL,TYPE_VEC2,{TYPE_FLOAT,TYPE_VEC2}},
-	{OP_MUL,TYPE_VEC2,{TYPE_VEC2,TYPE_MAT3}},
-	{OP_MUL,TYPE_VEC2,{TYPE_MAT2,TYPE_VEC2}},
-	{OP_MUL,TYPE_VEC2,{TYPE_VEC2,TYPE_MAT2}},
-	{OP_MUL,TYPE_VEC2,{TYPE_MAT3,TYPE_VEC2}},
-	{OP_MUL,TYPE_VEC2,{TYPE_VEC2,TYPE_MAT4}},
-	{OP_MUL,TYPE_VEC2,{TYPE_MAT4,TYPE_VEC2}},
-	{OP_MUL,TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_MUL,TYPE_VEC3,{TYPE_VEC3,TYPE_FLOAT}},
-	{OP_MUL,TYPE_VEC3,{TYPE_FLOAT,TYPE_VEC3}},
-	{OP_MUL,TYPE_VEC3,{TYPE_MAT3,TYPE_VEC3}},
-	{OP_MUL,TYPE_VEC3,{TYPE_MAT4,TYPE_VEC3}},
-	{OP_MUL,TYPE_VEC3,{TYPE_VEC3,TYPE_MAT3}},
-	{OP_MUL,TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_MUL,TYPE_VEC4,{TYPE_VEC4,TYPE_FLOAT}},
-	{OP_MUL,TYPE_VEC4,{TYPE_FLOAT,TYPE_VEC4}},
-	{OP_MUL,TYPE_VEC4,{TYPE_MAT4,TYPE_VEC4}},
-	{OP_MUL,TYPE_VEC4,{TYPE_VEC4,TYPE_MAT4}},
-	{OP_MUL,TYPE_MAT2,{TYPE_MAT2,TYPE_MAT2}},
-	{OP_MUL,TYPE_MAT3,{TYPE_MAT3,TYPE_MAT3}},
-	{OP_MUL,TYPE_MAT4,{TYPE_MAT4,TYPE_MAT4}},
-	{OP_DIV,TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_DIV,TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_DIV,TYPE_VEC2,{TYPE_VEC2,TYPE_FLOAT}},
-	{OP_DIV,TYPE_VEC2,{TYPE_FLOAT,TYPE_VEC2}},
-	{OP_DIV,TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_DIV,TYPE_VEC3,{TYPE_VEC3,TYPE_FLOAT}},
-	{OP_DIV,TYPE_VEC3,{TYPE_FLOAT,TYPE_VEC3}},
-	{OP_DIV,TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_DIV,TYPE_VEC4,{TYPE_VEC4,TYPE_FLOAT}},
-	{OP_DIV,TYPE_VEC4,{TYPE_FLOAT,TYPE_VEC4}},
-	{OP_ASSIGN_ADD,TYPE_VOID,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_ASSIGN_ADD,TYPE_VOID,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_ASSIGN_ADD,TYPE_VOID,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_ASSIGN_ADD,TYPE_VOID,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_ASSIGN_ADD,TYPE_VOID,{TYPE_VEC2,TYPE_FLOAT}},
-	{OP_ASSIGN_ADD,TYPE_VOID,{TYPE_VEC3,TYPE_FLOAT}},
-	{OP_ASSIGN_ADD,TYPE_VOID,{TYPE_VEC4,TYPE_FLOAT}},
-	{OP_ASSIGN_SUB,TYPE_VOID,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_ASSIGN_SUB,TYPE_VOID,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_ASSIGN_SUB,TYPE_VOID,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_ASSIGN_SUB,TYPE_VOID,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_ASSIGN_SUB,TYPE_VOID,{TYPE_VEC2,TYPE_FLOAT}},
-	{OP_ASSIGN_SUB,TYPE_VOID,{TYPE_VEC3,TYPE_FLOAT}},
-	{OP_ASSIGN_SUB,TYPE_VOID,{TYPE_VEC4,TYPE_FLOAT}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC2,TYPE_FLOAT}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC2,TYPE_MAT2}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_MAT2,TYPE_MAT2}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC3,TYPE_MAT3}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC3,TYPE_FLOAT}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC3,TYPE_MAT4}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC4,TYPE_FLOAT}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC4,TYPE_MAT4}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_MAT3,TYPE_MAT3}},
-	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_MAT4,TYPE_MAT4}},
-	{OP_ASSIGN_DIV,TYPE_VOID,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_ASSIGN_DIV,TYPE_VOID,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_ASSIGN_DIV,TYPE_VOID,{TYPE_VEC2,TYPE_FLOAT}},
-	{OP_ASSIGN_DIV,TYPE_VOID,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_ASSIGN_DIV,TYPE_VOID,{TYPE_VEC3,TYPE_FLOAT}},
-	{OP_ASSIGN_DIV,TYPE_VOID,{TYPE_VEC4,TYPE_VEC4}},
-	{OP_ASSIGN_DIV,TYPE_VOID,{TYPE_VEC4,TYPE_FLOAT}},
-	{OP_NEG,TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
-	{OP_NEG,TYPE_VEC2,{TYPE_VEC2,TYPE_VOID}},
-	{OP_NEG,TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
-	{OP_NEG,TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
-	{OP_NOT,TYPE_BOOL,{TYPE_BOOL,TYPE_VOID}},
-	{OP_CMP_EQ,TYPE_BOOL,{TYPE_BOOL,TYPE_BOOL}},
-	{OP_CMP_EQ,TYPE_BOOL,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_CMP_EQ,TYPE_BOOL,{TYPE_VEC3,TYPE_VEC2}},
-	{OP_CMP_EQ,TYPE_BOOL,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_CMP_EQ,TYPE_BOOL,{TYPE_VEC3,TYPE_VEC4}},
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_BOOL, TYPE_BOOL } },
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_MAT2, TYPE_MAT2 } },
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_MAT3, TYPE_MAT3 } },
+	{ OP_ASSIGN, TYPE_VOID, { TYPE_MAT4, TYPE_MAT4 } },
+	{ OP_ADD, TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_ADD, TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_ADD, TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_ADD, TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_SUB, TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_SUB, TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_SUB, TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_SUB, TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_MUL, TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_FLOAT, TYPE_VEC2 } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_VEC2, TYPE_MAT3 } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_MAT2, TYPE_VEC2 } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_VEC2, TYPE_MAT2 } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_MAT3, TYPE_VEC2 } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_VEC2, TYPE_MAT4 } },
+	{ OP_MUL, TYPE_VEC2, { TYPE_MAT4, TYPE_VEC2 } },
+	{ OP_MUL, TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_MUL, TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT } },
+	{ OP_MUL, TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC3 } },
+	{ OP_MUL, TYPE_VEC3, { TYPE_MAT3, TYPE_VEC3 } },
+	{ OP_MUL, TYPE_VEC3, { TYPE_MAT4, TYPE_VEC3 } },
+	{ OP_MUL, TYPE_VEC3, { TYPE_VEC3, TYPE_MAT3 } },
+	{ OP_MUL, TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_MUL, TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT } },
+	{ OP_MUL, TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC4 } },
+	{ OP_MUL, TYPE_VEC4, { TYPE_MAT4, TYPE_VEC4 } },
+	{ OP_MUL, TYPE_VEC4, { TYPE_VEC4, TYPE_MAT4 } },
+	{ OP_MUL, TYPE_MAT2, { TYPE_MAT2, TYPE_MAT2 } },
+	{ OP_MUL, TYPE_MAT3, { TYPE_MAT3, TYPE_MAT3 } },
+	{ OP_MUL, TYPE_MAT4, { TYPE_MAT4, TYPE_MAT4 } },
+	{ OP_DIV, TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_DIV, TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_DIV, TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT } },
+	{ OP_DIV, TYPE_VEC2, { TYPE_FLOAT, TYPE_VEC2 } },
+	{ OP_DIV, TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_DIV, TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT } },
+	{ OP_DIV, TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC3 } },
+	{ OP_DIV, TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_DIV, TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT } },
+	{ OP_DIV, TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC4 } },
+	{ OP_ASSIGN_ADD, TYPE_VOID, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_ASSIGN_ADD, TYPE_VOID, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_ASSIGN_ADD, TYPE_VOID, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_ASSIGN_ADD, TYPE_VOID, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_ASSIGN_ADD, TYPE_VOID, { TYPE_VEC2, TYPE_FLOAT } },
+	{ OP_ASSIGN_ADD, TYPE_VOID, { TYPE_VEC3, TYPE_FLOAT } },
+	{ OP_ASSIGN_ADD, TYPE_VOID, { TYPE_VEC4, TYPE_FLOAT } },
+	{ OP_ASSIGN_SUB, TYPE_VOID, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_ASSIGN_SUB, TYPE_VOID, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_ASSIGN_SUB, TYPE_VOID, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_ASSIGN_SUB, TYPE_VOID, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_ASSIGN_SUB, TYPE_VOID, { TYPE_VEC2, TYPE_FLOAT } },
+	{ OP_ASSIGN_SUB, TYPE_VOID, { TYPE_VEC3, TYPE_FLOAT } },
+	{ OP_ASSIGN_SUB, TYPE_VOID, { TYPE_VEC4, TYPE_FLOAT } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC2, TYPE_FLOAT } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC2, TYPE_MAT2 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_MAT2, TYPE_MAT2 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC3, TYPE_MAT3 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC3, TYPE_FLOAT } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC3, TYPE_MAT4 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC4, TYPE_FLOAT } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_VEC4, TYPE_MAT4 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_MAT3, TYPE_MAT3 } },
+	{ OP_ASSIGN_MUL, TYPE_VOID, { TYPE_MAT4, TYPE_MAT4 } },
+	{ OP_ASSIGN_DIV, TYPE_VOID, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_ASSIGN_DIV, TYPE_VOID, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_ASSIGN_DIV, TYPE_VOID, { TYPE_VEC2, TYPE_FLOAT } },
+	{ OP_ASSIGN_DIV, TYPE_VOID, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_ASSIGN_DIV, TYPE_VOID, { TYPE_VEC3, TYPE_FLOAT } },
+	{ OP_ASSIGN_DIV, TYPE_VOID, { TYPE_VEC4, TYPE_VEC4 } },
+	{ OP_ASSIGN_DIV, TYPE_VOID, { TYPE_VEC4, TYPE_FLOAT } },
+	{ OP_NEG, TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
+	{ OP_NEG, TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
+	{ OP_NEG, TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
+	{ OP_NEG, TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
+	{ OP_NOT, TYPE_BOOL, { TYPE_BOOL, TYPE_VOID } },
+	{ OP_CMP_EQ, TYPE_BOOL, { TYPE_BOOL, TYPE_BOOL } },
+	{ OP_CMP_EQ, TYPE_BOOL, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_CMP_EQ, TYPE_BOOL, { TYPE_VEC3, TYPE_VEC2 } },
+	{ OP_CMP_EQ, TYPE_BOOL, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_CMP_EQ, TYPE_BOOL, { TYPE_VEC3, TYPE_VEC4 } },
 	//{OP_CMP_EQ,TYPE_MAT3,{TYPE_MAT4,TYPE_MAT3}}, ??
 	//{OP_CMP_EQ,TYPE_MAT4,{TYPE_MAT4,TYPE_MAT4}}, ??
-	{OP_CMP_NEQ,TYPE_BOOL,{TYPE_BOOL,TYPE_BOOL}},
-	{OP_CMP_NEQ,TYPE_BOOL,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_CMP_NEQ,TYPE_BOOL,{TYPE_VEC2,TYPE_VEC2}},
-	{OP_CMP_NEQ,TYPE_BOOL,{TYPE_VEC3,TYPE_VEC3}},
-	{OP_CMP_NEQ,TYPE_BOOL,{TYPE_VEC4,TYPE_VEC4}},
+	{ OP_CMP_NEQ, TYPE_BOOL, { TYPE_BOOL, TYPE_BOOL } },
+	{ OP_CMP_NEQ, TYPE_BOOL, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_CMP_NEQ, TYPE_BOOL, { TYPE_VEC2, TYPE_VEC2 } },
+	{ OP_CMP_NEQ, TYPE_BOOL, { TYPE_VEC3, TYPE_VEC3 } },
+	{ OP_CMP_NEQ, TYPE_BOOL, { TYPE_VEC4, TYPE_VEC4 } },
 	//{OP_CMP_NEQ,TYPE_MAT4,{TYPE_MAT4,TYPE_MAT4}}, //?
-	{OP_CMP_LEQ,TYPE_BOOL,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_CMP_GEQ,TYPE_BOOL,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_CMP_LESS,TYPE_BOOL,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_CMP_GREATER,TYPE_BOOL,{TYPE_FLOAT,TYPE_FLOAT}},
-	{OP_CMP_OR,TYPE_BOOL,{TYPE_BOOL,TYPE_BOOL}},
-	{OP_CMP_AND,TYPE_BOOL,{TYPE_BOOL,TYPE_BOOL}},
-	{OP_MAX,TYPE_VOID,{TYPE_VOID,TYPE_VOID}}
+	{ OP_CMP_LEQ, TYPE_BOOL, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_CMP_GEQ, TYPE_BOOL, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_CMP_LESS, TYPE_BOOL, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_CMP_GREATER, TYPE_BOOL, { TYPE_FLOAT, TYPE_FLOAT } },
+	{ OP_CMP_OR, TYPE_BOOL, { TYPE_BOOL, TYPE_BOOL } },
+	{ OP_CMP_AND, TYPE_BOOL, { TYPE_BOOL, TYPE_BOOL } },
+	{ OP_MAX, TYPE_VOID, { TYPE_VOID, TYPE_VOID } }
 };
 
+const ShaderLanguage::BuiltinsDef ShaderLanguage::vertex_builtins_defs[] = {
 
-const ShaderLanguage::BuiltinsDef ShaderLanguage::vertex_builtins_defs[]={
-
-	{ "SRC_VERTEX", TYPE_VEC3},
-	{ "SRC_NORMAL", TYPE_VEC3},
-	{ "SRC_TANGENT", TYPE_VEC3},
-	{ "SRC_BINORMALF", TYPE_FLOAT},
+	{ "SRC_VERTEX", TYPE_VEC3 },
+	{ "SRC_NORMAL", TYPE_VEC3 },
+	{ "SRC_TANGENT", TYPE_VEC3 },
+	{ "SRC_BINORMALF", TYPE_FLOAT },
 
 	{ "POSITION", TYPE_VEC4 },
-	{ "VERTEX", TYPE_VEC3},
-	{ "NORMAL", TYPE_VEC3},
-	{ "TANGENT", TYPE_VEC3},
-	{ "BINORMAL", TYPE_VEC3},
-	{ "UV", TYPE_VEC2},
-	{ "UV2", TYPE_VEC2},
-	{ "COLOR", TYPE_VEC4},
-	{ "BONES", TYPE_VEC4},
-	{ "WEIGHTS", TYPE_VEC4},
-	{ "VAR1", TYPE_VEC4},
-	{ "VAR2", TYPE_VEC4},
-	{ "SPEC_EXP", TYPE_FLOAT},
-	{ "POINT_SIZE", TYPE_FLOAT},
+	{ "VERTEX", TYPE_VEC3 },
+	{ "NORMAL", TYPE_VEC3 },
+	{ "TANGENT", TYPE_VEC3 },
+	{ "BINORMAL", TYPE_VEC3 },
+	{ "UV", TYPE_VEC2 },
+	{ "UV2", TYPE_VEC2 },
+	{ "COLOR", TYPE_VEC4 },
+	{ "BONES", TYPE_VEC4 },
+	{ "WEIGHTS", TYPE_VEC4 },
+	{ "VAR1", TYPE_VEC4 },
+	{ "VAR2", TYPE_VEC4 },
+	{ "SPEC_EXP", TYPE_FLOAT },
+	{ "POINT_SIZE", TYPE_FLOAT },
 
 	//builtins
-	{ "WORLD_MATRIX", TYPE_MAT4},
-	{ "INV_CAMERA_MATRIX", TYPE_MAT4},
-	{ "PROJECTION_MATRIX", TYPE_MAT4},
-	{ "MODELVIEW_MATRIX", TYPE_MAT4},
-	{ "INSTANCE_ID", TYPE_FLOAT},
-	{ "TIME", TYPE_FLOAT},
-	{ NULL, TYPE_VOID},
+	{ "WORLD_MATRIX", TYPE_MAT4 },
+	{ "INV_CAMERA_MATRIX", TYPE_MAT4 },
+	{ "PROJECTION_MATRIX", TYPE_MAT4 },
+	{ "MODELVIEW_MATRIX", TYPE_MAT4 },
+	{ "INSTANCE_ID", TYPE_FLOAT },
+	{ "TIME", TYPE_FLOAT },
+	{ NULL, TYPE_VOID },
 };
-const ShaderLanguage::BuiltinsDef ShaderLanguage::fragment_builtins_defs[]={
+const ShaderLanguage::BuiltinsDef ShaderLanguage::fragment_builtins_defs[] = {
 
-	{ "VERTEX", TYPE_VEC3},
-	{ "POSITION", TYPE_VEC4},
-	{ "NORMAL", TYPE_VEC3},
-	{ "TANGENT", TYPE_VEC3},
-	{ "BINORMAL", TYPE_VEC3},
-	{ "NORMALMAP", TYPE_VEC3},
-	{ "NORMALMAP_DEPTH", TYPE_FLOAT},
-	{ "UV", TYPE_VEC2},
-	{ "UV2", TYPE_VEC2},
-	{ "COLOR", TYPE_VEC4},
-	{ "NORMAL", TYPE_VEC3},
-	{ "VAR1", TYPE_VEC4},
-	{ "VAR2", TYPE_VEC4},
-	{ "DIFFUSE", TYPE_VEC3},
-	{ "DIFFUSE_ALPHA", TYPE_VEC4},
-	{ "SPECULAR", TYPE_VEC3},
-	{ "EMISSION", TYPE_VEC3},
-	{ "SPEC_EXP", TYPE_FLOAT},
-	{ "GLOW", TYPE_FLOAT},
-	{ "SHADE_PARAM", TYPE_FLOAT},
-	{ "DISCARD", TYPE_BOOL},
-	{ "SCREEN_UV", TYPE_VEC2},
-	{ "POINT_COORD", TYPE_VEC2},
-	{ "INV_CAMERA_MATRIX", TYPE_MAT4},
+	{ "VERTEX", TYPE_VEC3 },
+	{ "POSITION", TYPE_VEC4 },
+	{ "NORMAL", TYPE_VEC3 },
+	{ "TANGENT", TYPE_VEC3 },
+	{ "BINORMAL", TYPE_VEC3 },
+	{ "NORMALMAP", TYPE_VEC3 },
+	{ "NORMALMAP_DEPTH", TYPE_FLOAT },
+	{ "UV", TYPE_VEC2 },
+	{ "UV2", TYPE_VEC2 },
+	{ "COLOR", TYPE_VEC4 },
+	{ "NORMAL", TYPE_VEC3 },
+	{ "VAR1", TYPE_VEC4 },
+	{ "VAR2", TYPE_VEC4 },
+	{ "DIFFUSE", TYPE_VEC3 },
+	{ "DIFFUSE_ALPHA", TYPE_VEC4 },
+	{ "SPECULAR", TYPE_VEC3 },
+	{ "EMISSION", TYPE_VEC3 },
+	{ "SPEC_EXP", TYPE_FLOAT },
+	{ "GLOW", TYPE_FLOAT },
+	{ "SHADE_PARAM", TYPE_FLOAT },
+	{ "DISCARD", TYPE_BOOL },
+	{ "SCREEN_UV", TYPE_VEC2 },
+	{ "POINT_COORD", TYPE_VEC2 },
+	{ "INV_CAMERA_MATRIX", TYPE_MAT4 },
 
-//	{ "SCREEN_POS", TYPE_VEC2},
-//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
-	{ "TIME", TYPE_FLOAT},
-	{ NULL, TYPE_VOID}
+	//	{ "SCREEN_POS", TYPE_VEC2},
+	//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
+	{ "TIME", TYPE_FLOAT },
+	{ NULL, TYPE_VOID }
 
 };
 
-const ShaderLanguage::BuiltinsDef ShaderLanguage::light_builtins_defs[]={
+const ShaderLanguage::BuiltinsDef ShaderLanguage::light_builtins_defs[] = {
 
-	{ "NORMAL", TYPE_VEC3},
-	{ "LIGHT_DIR", TYPE_VEC3},
-	{ "LIGHT_DIFFUSE", TYPE_VEC3},
-	{ "LIGHT_SPECULAR", TYPE_VEC3},
-	{ "EYE_VEC", TYPE_VEC3},
-	{ "DIFFUSE", TYPE_VEC3},
-	{ "SPECULAR", TYPE_VEC3},
-	{ "SPECULAR_EXP", TYPE_FLOAT},
-	{ "SHADE_PARAM", TYPE_FLOAT},
-	{ "LIGHT", TYPE_VEC3},
+	{ "NORMAL", TYPE_VEC3 },
+	{ "LIGHT_DIR", TYPE_VEC3 },
+	{ "LIGHT_DIFFUSE", TYPE_VEC3 },
+	{ "LIGHT_SPECULAR", TYPE_VEC3 },
+	{ "EYE_VEC", TYPE_VEC3 },
+	{ "DIFFUSE", TYPE_VEC3 },
+	{ "SPECULAR", TYPE_VEC3 },
+	{ "SPECULAR_EXP", TYPE_FLOAT },
+	{ "SHADE_PARAM", TYPE_FLOAT },
+	{ "LIGHT", TYPE_VEC3 },
 	{ "SHADOW", TYPE_VEC3 },
 	{ "POINT_COORD", TYPE_VEC2 },
-//	{ "SCREEN_POS", TYPE_VEC2},
-//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
-	{ "TIME", TYPE_FLOAT},
-	{ NULL, TYPE_VOID}
+	//	{ "SCREEN_POS", TYPE_VEC2},
+	//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
+	{ "TIME", TYPE_FLOAT },
+	{ NULL, TYPE_VOID }
 
 };
 
+const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_vertex_builtins_defs[] = {
 
-
-const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_vertex_builtins_defs[]={
-
-	{ "SRC_VERTEX", TYPE_VEC2},
-	{ "VERTEX", TYPE_VEC2},
-	{ "WORLD_VERTEX", TYPE_VEC2},
-	{ "UV", TYPE_VEC2},
-	{ "COLOR", TYPE_VEC4},
-	{ "VAR1", TYPE_VEC4},
-	{ "VAR2", TYPE_VEC4},
-	{ "POINT_SIZE", TYPE_FLOAT},
+	{ "SRC_VERTEX", TYPE_VEC2 },
+	{ "VERTEX", TYPE_VEC2 },
+	{ "WORLD_VERTEX", TYPE_VEC2 },
+	{ "UV", TYPE_VEC2 },
+	{ "COLOR", TYPE_VEC4 },
+	{ "VAR1", TYPE_VEC4 },
+	{ "VAR2", TYPE_VEC4 },
+	{ "POINT_SIZE", TYPE_FLOAT },
 
 	//builtins
-	{ "WORLD_MATRIX", TYPE_MAT4},
-	{ "PROJECTION_MATRIX", TYPE_MAT4},
-	{ "EXTRA_MATRIX", TYPE_MAT4},
-	{ "TIME", TYPE_FLOAT},
-	{ NULL, TYPE_VOID},
+	{ "WORLD_MATRIX", TYPE_MAT4 },
+	{ "PROJECTION_MATRIX", TYPE_MAT4 },
+	{ "EXTRA_MATRIX", TYPE_MAT4 },
+	{ "TIME", TYPE_FLOAT },
+	{ NULL, TYPE_VOID },
 };
-const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_fragment_builtins_defs[]={
+const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_fragment_builtins_defs[] = {
 
-	{ "SRC_COLOR", TYPE_VEC4},
-	{ "POSITION", TYPE_VEC2},
-	{ "NORMAL", TYPE_VEC3},
-	{ "NORMALMAP", TYPE_VEC3},
-	{ "NORMALMAP_DEPTH", TYPE_FLOAT},
-	{ "UV", TYPE_VEC2},
-	{ "COLOR", TYPE_VEC4},
-	{ "TEXTURE", TYPE_TEXTURE},
-	{ "TEXTURE_PIXEL_SIZE", TYPE_VEC2},
-	{ "VAR1", TYPE_VEC4},
-	{ "VAR2", TYPE_VEC4},
-	{ "SCREEN_UV", TYPE_VEC2},
-	{ "POINT_COORD", TYPE_VEC2},
+	{ "SRC_COLOR", TYPE_VEC4 },
+	{ "POSITION", TYPE_VEC2 },
+	{ "NORMAL", TYPE_VEC3 },
+	{ "NORMALMAP", TYPE_VEC3 },
+	{ "NORMALMAP_DEPTH", TYPE_FLOAT },
+	{ "UV", TYPE_VEC2 },
+	{ "COLOR", TYPE_VEC4 },
+	{ "TEXTURE", TYPE_TEXTURE },
+	{ "TEXTURE_PIXEL_SIZE", TYPE_VEC2 },
+	{ "VAR1", TYPE_VEC4 },
+	{ "VAR2", TYPE_VEC4 },
+	{ "SCREEN_UV", TYPE_VEC2 },
+	{ "POINT_COORD", TYPE_VEC2 },
 
-//	{ "SCREEN_POS", TYPE_VEC2},
-//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
-	{ "TIME", TYPE_FLOAT},
-	{ NULL, TYPE_VOID}
+	//	{ "SCREEN_POS", TYPE_VEC2},
+	//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
+	{ "TIME", TYPE_FLOAT },
+	{ NULL, TYPE_VOID }
 
 };
 
-const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_light_builtins_defs[]={
+const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_light_builtins_defs[] = {
 
-	{ "POSITION", TYPE_VEC2},
-	{ "NORMAL", TYPE_VEC3},
-	{ "UV", TYPE_VEC2},
-	{ "COLOR", TYPE_VEC4},
-	{ "TEXTURE", TYPE_TEXTURE},
-	{ "TEXTURE_PIXEL_SIZE", TYPE_VEC2},
-	{ "VAR1", TYPE_VEC4},
-	{ "VAR2", TYPE_VEC4},
-	{ "SCREEN_UV", TYPE_VEC2},
-	{ "LIGHT_VEC", TYPE_VEC2},
-	{ "LIGHT_HEIGHT", TYPE_FLOAT},
-	{ "LIGHT_COLOR", TYPE_VEC4},
-	{ "LIGHT_UV", TYPE_VEC2},
-	{ "LIGHT_SHADOW", TYPE_VEC4},
-	{ "LIGHT", TYPE_VEC4},
-	{ "SHADOW", TYPE_VEC4},
-	{ "POINT_COORD", TYPE_VEC2},
-//	{ "SCREEN_POS", TYPE_VEC2},
-//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
-	{ "TIME", TYPE_FLOAT},
-	{ NULL, TYPE_VOID}
+	{ "POSITION", TYPE_VEC2 },
+	{ "NORMAL", TYPE_VEC3 },
+	{ "UV", TYPE_VEC2 },
+	{ "COLOR", TYPE_VEC4 },
+	{ "TEXTURE", TYPE_TEXTURE },
+	{ "TEXTURE_PIXEL_SIZE", TYPE_VEC2 },
+	{ "VAR1", TYPE_VEC4 },
+	{ "VAR2", TYPE_VEC4 },
+	{ "SCREEN_UV", TYPE_VEC2 },
+	{ "LIGHT_VEC", TYPE_VEC2 },
+	{ "LIGHT_HEIGHT", TYPE_FLOAT },
+	{ "LIGHT_COLOR", TYPE_VEC4 },
+	{ "LIGHT_UV", TYPE_VEC2 },
+	{ "LIGHT_SHADOW", TYPE_VEC4 },
+	{ "LIGHT", TYPE_VEC4 },
+	{ "SHADOW", TYPE_VEC4 },
+	{ "POINT_COORD", TYPE_VEC2 },
+	//	{ "SCREEN_POS", TYPE_VEC2},
+	//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
+	{ "TIME", TYPE_FLOAT },
+	{ NULL, TYPE_VOID }
 
 };
 
-const ShaderLanguage::BuiltinsDef ShaderLanguage::postprocess_fragment_builtins_defs[]={
+const ShaderLanguage::BuiltinsDef ShaderLanguage::postprocess_fragment_builtins_defs[] = {
 
-	{ "IN_COLOR", TYPE_VEC3},
-	{ "IN_POSITION", TYPE_VEC3},
-	{ "OUT_COLOR", TYPE_VEC3},
-	{ "SCREEN_POS", TYPE_VEC2},
-	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
-	{ "TIME", TYPE_FLOAT},
-	{ NULL, TYPE_VOID}
+	{ "IN_COLOR", TYPE_VEC3 },
+	{ "IN_POSITION", TYPE_VEC3 },
+	{ "OUT_COLOR", TYPE_VEC3 },
+	{ "SCREEN_POS", TYPE_VEC2 },
+	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2 },
+	{ "TIME", TYPE_FLOAT },
+	{ NULL, TYPE_VOID }
 };
 
-
-
 ShaderLanguage::DataType ShaderLanguage::compute_node_type(Node *p_node) {
 
-	switch(p_node->type) {
+	switch (p_node->type) {
 
 		case Node::TYPE_PROGRAM: ERR_FAIL_V(TYPE_VOID);
-		case Node::TYPE_FUNCTION: return static_cast<FunctionNode*>(p_node)->return_type;
+		case Node::TYPE_FUNCTION: return static_cast<FunctionNode *>(p_node)->return_type;
 		case Node::TYPE_BLOCK: ERR_FAIL_V(TYPE_VOID);
-		case Node::TYPE_VARIABLE: return static_cast<VariableNode*>(p_node)->datatype_cache;
-		case Node::TYPE_CONSTANT: return static_cast<ConstantNode*>(p_node)->datatype;
-		case Node::TYPE_OPERATOR: return static_cast<OperatorNode*>(p_node)->return_cache;
+		case Node::TYPE_VARIABLE: return static_cast<VariableNode *>(p_node)->datatype_cache;
+		case Node::TYPE_CONSTANT: return static_cast<ConstantNode *>(p_node)->datatype;
+		case Node::TYPE_OPERATOR: return static_cast<OperatorNode *>(p_node)->return_cache;
 		case Node::TYPE_CONTROL_FLOW: ERR_FAIL_V(TYPE_VOID);
-		case Node::TYPE_MEMBER: return static_cast<MemberNode*>(p_node)->datatype;
+		case Node::TYPE_MEMBER: return static_cast<MemberNode *>(p_node)->datatype;
 	}
 
 	return TYPE_VOID;
 }
 
+ShaderLanguage::Node *ShaderLanguage::validate_function_call(Parser &parser, OperatorNode *p_func) {
 
-ShaderLanguage::Node* ShaderLanguage::validate_function_call(Parser&parser, OperatorNode *p_func) {
-
-	ERR_FAIL_COND_V(p_func->op!=OP_CALL && p_func->op!=OP_CONSTRUCT,NULL);
-
+	ERR_FAIL_COND_V(p_func->op != OP_CALL && p_func->op != OP_CONSTRUCT, NULL);
 
 	Vector<DataType> args;
 
-	ERR_FAIL_COND_V( p_func->arguments[0]->type!=Node::TYPE_VARIABLE, NULL );
+	ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::TYPE_VARIABLE, NULL);
 
-	String name = static_cast<VariableNode*>(p_func->arguments[0])->name.operator String();
+	String name = static_cast<VariableNode *>(p_func->arguments[0])->name.operator String();
 
-	bool all_const=true;
-	for(int i=1;i<p_func->arguments.size();i++) {
-		if (p_func->arguments[i]->type!=Node::TYPE_CONSTANT)
-			all_const=false;
+	bool all_const = true;
+	for (int i = 1; i < p_func->arguments.size(); i++) {
+		if (p_func->arguments[i]->type != Node::TYPE_CONSTANT)
+			all_const = false;
 		args.push_back(compute_node_type(p_func->arguments[i]));
 	}
 
-	int argcount=args.size();
+	int argcount = args.size();
 
-	bool found_intrinsic=false;
+	bool found_intrinsic = false;
 
-	if (argcount<=4) {
+	if (argcount <= 4) {
 		// test intrinsics
-		int idx=0;
+		int idx = 0;
 
 		while (intrinsic_func_defs[idx].name) {
 
-			if (name==intrinsic_func_defs[idx].name) {
+			if (name == intrinsic_func_defs[idx].name) {
 
-				bool fail=false;
-				for(int i=0;i<argcount;i++) {
+				bool fail = false;
+				for (int i = 0; i < argcount; i++) {
 
-					if (args[i]!=intrinsic_func_defs[idx].args[i]) {
-						fail=true;
+					if (args[i] != intrinsic_func_defs[idx].args[i]) {
+						fail = true;
 						break;
 					}
 				}
 
-				if (!fail && argcount<4 && intrinsic_func_defs[idx].args[argcount]!=TYPE_VOID)
-					fail=true; //make sure the number of arguments matches
+				if (!fail && argcount < 4 && intrinsic_func_defs[idx].args[argcount] != TYPE_VOID)
+					fail = true; //make sure the number of arguments matches
 
 				if (!fail) {
-					p_func->return_cache=intrinsic_func_defs[idx].rettype;
-					found_intrinsic=true;
+					p_func->return_cache = intrinsic_func_defs[idx].rettype;
+					found_intrinsic = true;
 					break;
-
 				}
-
 			}
 
 			idx++;
 		}
 	}
 
-
 	if (found_intrinsic) {
 
-		if (p_func->op==OP_CONSTRUCT && all_const) {
-
+		if (p_func->op == OP_CONSTRUCT && all_const) {
 
 			Vector<float> cdata;
-			for(int i=0;i<argcount;i++) {
+			for (int i = 0; i < argcount; i++) {
 
-				Variant v = static_cast<ConstantNode*>(p_func->arguments[i+1])->value;
-				switch(v.get_type()) {
+				Variant v = static_cast<ConstantNode *>(p_func->arguments[i + 1])->value;
+				switch (v.get_type()) {
 
 					case Variant::REAL: cdata.push_back(v); break;
-					case Variant::VECTOR2: { Vector2 v2=v; cdata.push_back(v2.x); cdata.push_back(v2.y); } break;
-					case Variant::VECTOR3: { Vector3 v3=v; cdata.push_back(v3.x); cdata.push_back(v3.y); cdata.push_back(v3.z);} break;
-					case Variant::PLANE: { Plane v4=v; cdata.push_back(v4.normal.x); cdata.push_back(v4.normal.y); cdata.push_back(v4.normal.z); cdata.push_back(v4.d); } break;
+					case Variant::VECTOR2: {
+						Vector2 v2 = v;
+						cdata.push_back(v2.x);
+						cdata.push_back(v2.y);
+					} break;
+					case Variant::VECTOR3: {
+						Vector3 v3 = v;
+						cdata.push_back(v3.x);
+						cdata.push_back(v3.y);
+						cdata.push_back(v3.z);
+					} break;
+					case Variant::PLANE: {
+						Plane v4 = v;
+						cdata.push_back(v4.normal.x);
+						cdata.push_back(v4.normal.y);
+						cdata.push_back(v4.normal.z);
+						cdata.push_back(v4.d);
+					} break;
 					default: ERR_FAIL_V(NULL);
-
 				}
-
 			}
 
 			ConstantNode *cn = parser.create_node<ConstantNode>(p_func->parent);
 			Variant data;
-			switch(p_func->return_cache) {
+			switch (p_func->return_cache) {
 				case TYPE_FLOAT: data = cdata[0]; break;
 				case TYPE_VEC2:
-					if (cdata.size()==1)
-						data = Vector2(cdata[0],cdata[0]);
+					if (cdata.size() == 1)
+						data = Vector2(cdata[0], cdata[0]);
 					else
-						data = Vector2(cdata[0],cdata[1]);
+						data = Vector2(cdata[0], cdata[1]);
 
 					break;
 				case TYPE_VEC3:
-					if (cdata.size()==1)
-						data = Vector3(cdata[0],cdata[0],cdata[0]);
+					if (cdata.size() == 1)
+						data = Vector3(cdata[0], cdata[0], cdata[0]);
 					else
-						data = Vector3(cdata[0],cdata[1],cdata[2]);
+						data = Vector3(cdata[0], cdata[1], cdata[2]);
 					break;
 				case TYPE_VEC4:
-					if (cdata.size()==1)
-						data = Plane(cdata[0],cdata[0],cdata[0],cdata[0]);
+					if (cdata.size() == 1)
+						data = Plane(cdata[0], cdata[0], cdata[0], cdata[0]);
 					else
-						data = Plane(cdata[0],cdata[1],cdata[2],cdata[3]);
+						data = Plane(cdata[0], cdata[1], cdata[2], cdata[3]);
 					break;
 			}
 
-			cn->datatype=p_func->return_cache;
-			cn->value=data;
+			cn->datatype = p_func->return_cache;
+			cn->value = data;
 			return cn;
-
 		}
 		return p_func;
 	}
 
 	// try existing functions..
 
-	FunctionNode *exclude_function=NULL; //exclude current function (in case inside one)
-
+	FunctionNode *exclude_function = NULL; //exclude current function (in case inside one)
 
 	Node *node = p_func;
 
-	while(node->parent) {
+	while (node->parent) {
 
-		if (node->type==Node::TYPE_FUNCTION) {
+		if (node->type == Node::TYPE_FUNCTION) {
 
-			exclude_function = (FunctionNode*)node;
+			exclude_function = (FunctionNode *)node;
 		}
 
-		node=node->parent;
+		node = node->parent;
 	}
 
-	ERR_FAIL_COND_V(node->type!=Node::TYPE_PROGRAM,NULL);
-	ProgramNode *program = (ProgramNode*)node;
+	ERR_FAIL_COND_V(node->type != Node::TYPE_PROGRAM, NULL);
+	ProgramNode *program = (ProgramNode *)node;
 
-	for(int i=0;i<program->functions.size();i++) {
+	for (int i = 0; i < program->functions.size(); i++) {
 
-		if (program->functions[i].function==exclude_function)
+		if (program->functions[i].function == exclude_function)
 			continue;
 
 		FunctionNode *pfunc = program->functions[i].function;
 
-		if (pfunc->arguments.size()!=args.size())
+		if (pfunc->arguments.size() != args.size())
 			continue;
 
-		bool fail=false;
+		bool fail = false;
 
-		for(int i=0;i<args.size();i++) {
-			if (args[i]!=pfunc->arguments[i].type) {
-				fail=true;
+		for (int i = 0; i < args.size(); i++) {
+			if (args[i] != pfunc->arguments[i].type) {
+				fail = true;
 				break;
 			}
 		}
 
 		if (!fail && name == program->functions[i].name) {
-			p_func->return_cache=pfunc->return_type;
+			p_func->return_cache = pfunc->return_type;
 			return p_func;
 		}
 	}
@@ -1388,35 +1366,31 @@ ShaderLanguage::Node* ShaderLanguage::validate_function_call(Parser&parser, Oper
 	return NULL;
 }
 
-
-ShaderLanguage::Node * ShaderLanguage::validate_operator(Parser& parser,OperatorNode *p_func) {
+ShaderLanguage::Node *ShaderLanguage::validate_operator(Parser &parser, OperatorNode *p_func) {
 
 	int argcount = p_func->arguments.size();
-	ERR_FAIL_COND_V(argcount>2,NULL);
+	ERR_FAIL_COND_V(argcount > 2, NULL);
 
-	DataType argtype[2]={TYPE_VOID,TYPE_VOID};
-	bool all_const=true;
+	DataType argtype[2] = { TYPE_VOID, TYPE_VOID };
+	bool all_const = true;
 
-	for(int i=0;i<argcount;i++) {
-
-		argtype[i]=compute_node_type(p_func->arguments[i]);
-		if (p_func->arguments[i]->type!=Node::TYPE_CONSTANT)
-			all_const=false;
+	for (int i = 0; i < argcount; i++) {
 
+		argtype[i] = compute_node_type(p_func->arguments[i]);
+		if (p_func->arguments[i]->type != Node::TYPE_CONSTANT)
+			all_const = false;
 	}
-	int idx=0;
-
-	bool valid=false;
-	while(operator_defs[idx].op!=OP_MAX) {
-
-		if (p_func->op==operator_defs[idx].op) {
+	int idx = 0;
 
+	bool valid = false;
+	while (operator_defs[idx].op != OP_MAX) {
 
+		if (p_func->op == operator_defs[idx].op) {
 
-			if (operator_defs[idx].args[0]==argtype[0] && operator_defs[idx].args[1]==argtype[1]) {
+			if (operator_defs[idx].args[0] == argtype[0] && operator_defs[idx].args[1] == argtype[1]) {
 
-				p_func->return_cache=operator_defs[idx].rettype;
-				valid=true;
+				p_func->return_cache = operator_defs[idx].rettype;
+				valid = true;
 				break;
 			}
 		}
@@ -1427,122 +1401,117 @@ ShaderLanguage::Node * ShaderLanguage::validate_operator(Parser& parser,Operator
 	if (!valid)
 		return NULL;
 
-#define _RCO2(m_op,m_vop)\
-case m_op: {\
-	ConstantNode *cn = parser.create_node<ConstantNode>(p_func->parent);\
-	cn->datatype=p_func->return_cache;	\
-	Variant::evaluate(m_vop,static_cast<ConstantNode*>(p_func->arguments[0])->value,static_cast<ConstantNode*>(p_func->arguments[1])->value,cn->value,valid);\
-	if (!valid)\
-		return NULL;\
-	return cn;\
-} break;
+#define _RCO2(m_op, m_vop)                                                                                                                                              \
+	case m_op: {                                                                                                                                                        \
+		ConstantNode *cn = parser.create_node<ConstantNode>(p_func->parent);                                                                                            \
+		cn->datatype = p_func->return_cache;                                                                                                                            \
+		Variant::evaluate(m_vop, static_cast<ConstantNode *>(p_func->arguments[0])->value, static_cast<ConstantNode *>(p_func->arguments[1])->value, cn->value, valid); \
+		if (!valid)                                                                                                                                                     \
+			return NULL;                                                                                                                                                \
+		return cn;                                                                                                                                                      \
+	} break;
 
-#define _RCO1(m_op,m_vop)\
-case m_op: {\
-	ConstantNode *cn = parser.create_node<ConstantNode>(p_func->parent);\
-	cn->datatype=p_func->return_cache;	\
-	Variant::evaluate(m_vop,static_cast<ConstantNode*>(p_func->arguments[0])->value,Variant(),cn->value,valid);\
-	if (!valid)\
-		return NULL;\
-	return cn;\
-} break;
+#define _RCO1(m_op, m_vop)                                                                                               \
+	case m_op: {                                                                                                         \
+		ConstantNode *cn = parser.create_node<ConstantNode>(p_func->parent);                                             \
+		cn->datatype = p_func->return_cache;                                                                             \
+		Variant::evaluate(m_vop, static_cast<ConstantNode *>(p_func->arguments[0])->value, Variant(), cn->value, valid); \
+		if (!valid)                                                                                                      \
+			return NULL;                                                                                                 \
+		return cn;                                                                                                       \
+	} break;
 
 	if (all_const) {
 		//reduce constant operator
-		switch(p_func->op) {
-			_RCO2(OP_ADD,Variant::OP_ADD);
-			_RCO2(OP_SUB,Variant::OP_SUBSTRACT);
-			_RCO2(OP_MUL,Variant::OP_MULTIPLY);
-			_RCO2(OP_DIV,Variant::OP_DIVIDE);
-			_RCO1(OP_NEG,Variant::OP_NEGATE);
-			_RCO1(OP_NOT,Variant::OP_NOT);
-			_RCO2(OP_CMP_EQ,Variant::OP_EQUAL);
-			_RCO2(OP_CMP_NEQ,Variant::OP_NOT_EQUAL);
-			_RCO2(OP_CMP_LEQ,Variant::OP_LESS_EQUAL);
-			_RCO2(OP_CMP_GEQ,Variant::OP_GREATER_EQUAL);
-			_RCO2(OP_CMP_LESS,Variant::OP_LESS);
-			_RCO2(OP_CMP_GREATER,Variant::OP_GREATER);
-			_RCO2(OP_CMP_OR,Variant::OP_OR);
-			_RCO2(OP_CMP_AND,Variant::OP_AND);
+		switch (p_func->op) {
+			_RCO2(OP_ADD, Variant::OP_ADD);
+			_RCO2(OP_SUB, Variant::OP_SUBSTRACT);
+			_RCO2(OP_MUL, Variant::OP_MULTIPLY);
+			_RCO2(OP_DIV, Variant::OP_DIVIDE);
+			_RCO1(OP_NEG, Variant::OP_NEGATE);
+			_RCO1(OP_NOT, Variant::OP_NOT);
+			_RCO2(OP_CMP_EQ, Variant::OP_EQUAL);
+			_RCO2(OP_CMP_NEQ, Variant::OP_NOT_EQUAL);
+			_RCO2(OP_CMP_LEQ, Variant::OP_LESS_EQUAL);
+			_RCO2(OP_CMP_GEQ, Variant::OP_GREATER_EQUAL);
+			_RCO2(OP_CMP_LESS, Variant::OP_LESS);
+			_RCO2(OP_CMP_GREATER, Variant::OP_GREATER);
+			_RCO2(OP_CMP_OR, Variant::OP_OR);
+			_RCO2(OP_CMP_AND, Variant::OP_AND);
 			default: {}
 		}
 	}
 
-
 	return p_func;
-
 }
 
 bool ShaderLanguage::is_token_operator(TokenType p_type) {
 
-	return (p_type==TK_OP_EQUAL) ||
-	(p_type==TK_OP_NOT_EQUAL) ||
-	(p_type==TK_OP_LESS) ||
-	(p_type==TK_OP_LESS_EQUAL) ||
-	(p_type==TK_OP_GREATER) ||
-	(p_type==TK_OP_GREATER_EQUAL) ||
-	(p_type==TK_OP_AND) ||
-	(p_type==TK_OP_OR) ||
-	(p_type==TK_OP_NOT) ||
-	(p_type==TK_OP_ADD) ||
-	(p_type==TK_OP_SUB) ||
-	(p_type==TK_OP_MUL) ||
-	(p_type==TK_OP_DIV) ||
-	(p_type==TK_OP_NEG) ||
-	(p_type==TK_OP_ASSIGN) ||
-	(p_type==TK_OP_ASSIGN_ADD) ||
-	(p_type==TK_OP_ASSIGN_SUB) ||
-	(p_type==TK_OP_ASSIGN_MUL) ||
-	(p_type==TK_OP_ASSIGN_DIV);
-
+	return (p_type == TK_OP_EQUAL) ||
+		   (p_type == TK_OP_NOT_EQUAL) ||
+		   (p_type == TK_OP_LESS) ||
+		   (p_type == TK_OP_LESS_EQUAL) ||
+		   (p_type == TK_OP_GREATER) ||
+		   (p_type == TK_OP_GREATER_EQUAL) ||
+		   (p_type == TK_OP_AND) ||
+		   (p_type == TK_OP_OR) ||
+		   (p_type == TK_OP_NOT) ||
+		   (p_type == TK_OP_ADD) ||
+		   (p_type == TK_OP_SUB) ||
+		   (p_type == TK_OP_MUL) ||
+		   (p_type == TK_OP_DIV) ||
+		   (p_type == TK_OP_NEG) ||
+		   (p_type == TK_OP_ASSIGN) ||
+		   (p_type == TK_OP_ASSIGN_ADD) ||
+		   (p_type == TK_OP_ASSIGN_SUB) ||
+		   (p_type == TK_OP_ASSIGN_MUL) ||
+		   (p_type == TK_OP_ASSIGN_DIV);
 }
 ShaderLanguage::Operator ShaderLanguage::get_token_operator(TokenType p_type) {
 
-	switch(p_type) {
-		case TK_OP_EQUAL: return OP_CMP_EQ ;
+	switch (p_type) {
+		case TK_OP_EQUAL: return OP_CMP_EQ;
 		case TK_OP_NOT_EQUAL: return OP_CMP_NEQ;
-		case TK_OP_LESS: return OP_CMP_LESS ;
-		case TK_OP_LESS_EQUAL: return OP_CMP_LEQ ;
-		case TK_OP_GREATER: return OP_CMP_GREATER ;
-		case TK_OP_GREATER_EQUAL: return OP_CMP_GEQ ;
-		case TK_OP_AND: return OP_CMP_AND ;
-		case TK_OP_OR: return OP_CMP_OR ;
-		case TK_OP_NOT: return OP_NOT ;
-		case TK_OP_ADD: return OP_ADD ;
-		case TK_OP_SUB: return OP_SUB ;
-		case TK_OP_MUL: return OP_MUL ;
-		case TK_OP_DIV: return OP_DIV ;
-		case TK_OP_NEG: return OP_NEG ;
-		case TK_OP_ASSIGN: return OP_ASSIGN ;
-		case TK_OP_ASSIGN_ADD: return OP_ASSIGN_ADD ;
-		case TK_OP_ASSIGN_SUB: return OP_ASSIGN_SUB ;
-		case TK_OP_ASSIGN_MUL: return OP_ASSIGN_MUL ;
-		case TK_OP_ASSIGN_DIV: return OP_ASSIGN_DIV ;
+		case TK_OP_LESS: return OP_CMP_LESS;
+		case TK_OP_LESS_EQUAL: return OP_CMP_LEQ;
+		case TK_OP_GREATER: return OP_CMP_GREATER;
+		case TK_OP_GREATER_EQUAL: return OP_CMP_GEQ;
+		case TK_OP_AND: return OP_CMP_AND;
+		case TK_OP_OR: return OP_CMP_OR;
+		case TK_OP_NOT: return OP_NOT;
+		case TK_OP_ADD: return OP_ADD;
+		case TK_OP_SUB: return OP_SUB;
+		case TK_OP_MUL: return OP_MUL;
+		case TK_OP_DIV: return OP_DIV;
+		case TK_OP_NEG: return OP_NEG;
+		case TK_OP_ASSIGN: return OP_ASSIGN;
+		case TK_OP_ASSIGN_ADD: return OP_ASSIGN_ADD;
+		case TK_OP_ASSIGN_SUB: return OP_ASSIGN_SUB;
+		case TK_OP_ASSIGN_MUL: return OP_ASSIGN_MUL;
+		case TK_OP_ASSIGN_DIV: return OP_ASSIGN_DIV;
 		default: ERR_FAIL_V(OP_MAX);
 	}
 
 	return OP_MAX;
 }
 
-
-Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_expr) {
+Error ShaderLanguage::parse_expression(Parser &parser, Node *p_parent, Node **r_expr) {
 
 	Vector<Expression> expression;
 	//Vector<TokenType> operators;
 
-	while(true) {
+	while (true) {
 
-		Node *expr=NULL;
+		Node *expr = NULL;
 
-
-		if (parser.get_next_token_type()==TK_PARENTHESIS_OPEN) {
+		if (parser.get_next_token_type() == TK_PARENTHESIS_OPEN) {
 			//handle subexpression
 			parser.advance();
-			Error err = parse_expression(parser,p_parent,&expr);
+			Error err = parse_expression(parser, p_parent, &expr);
 			if (err)
 				return err;
 
-			if (parser.get_next_token_type()!=TK_PARENTHESIS_CLOSE) {
+			if (parser.get_next_token_type() != TK_PARENTHESIS_CLOSE) {
 
 				parser.set_error("Expected ')' in expression");
 				return ERR_PARSE_ERROR;
@@ -1550,64 +1519,62 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 
 			parser.advance();
 
-		} else if (parser.get_next_token_type()==TK_REAL_CONSTANT) {
-
+		} else if (parser.get_next_token_type() == TK_REAL_CONSTANT) {
 
 			ConstantNode *constant = parser.create_node<ConstantNode>(p_parent);
-			constant->value=parser.get_next_token().text.operator String().to_double();
-			constant->datatype=TYPE_FLOAT;
-			expr=constant;
+			constant->value = parser.get_next_token().text.operator String().to_double();
+			constant->datatype = TYPE_FLOAT;
+			expr = constant;
 			parser.advance();
-		} else if (parser.get_next_token_type()==TK_TRUE) {
+		} else if (parser.get_next_token_type() == TK_TRUE) {
 			//print_line("found true");
 
 			//handle true constant
 			ConstantNode *constant = parser.create_node<ConstantNode>(p_parent);
-			constant->value=true;
-			constant->datatype=TYPE_BOOL;
-			expr=constant;
+			constant->value = true;
+			constant->datatype = TYPE_BOOL;
+			expr = constant;
 			parser.advance();
-		} else if (parser.get_next_token_type()==TK_FALSE) {
+		} else if (parser.get_next_token_type() == TK_FALSE) {
 
 			//handle false constant
 			ConstantNode *constant = parser.create_node<ConstantNode>(p_parent);
-			constant->value=false;
-			constant->datatype=TYPE_BOOL;
-			expr=constant;
+			constant->value = false;
+			constant->datatype = TYPE_BOOL;
+			expr = constant;
 			parser.advance();
-		} else if (parser.get_next_token_type()==TK_TYPE_VOID) {
+		} else if (parser.get_next_token_type() == TK_TYPE_VOID) {
 
 			//make sure void is not used in expression
 			parser.set_error("Void value not allowed in Expression");
 			return ERR_PARSE_ERROR;
-		} else if (parser.get_next_token_type(1)==TK_PARENTHESIS_OPEN && (is_token_nonvoid_datatype(parser.get_next_token_type()) || parser.get_next_token_type()==TK_INDENTIFIER)) {
-
+		} else if (parser.get_next_token_type(1) == TK_PARENTHESIS_OPEN && (is_token_nonvoid_datatype(parser.get_next_token_type()) || parser.get_next_token_type() == TK_INDENTIFIER)) {
 
 			//function or constructor
 			StringName name;
-			DataType constructor=TYPE_VOID;
+			DataType constructor = TYPE_VOID;
 			if (is_token_nonvoid_datatype(parser.get_next_token_type())) {
 
-				constructor=get_token_datatype(parser.get_next_token_type());
-				switch(get_token_datatype(parser.get_next_token_type())) {
-				   case TYPE_BOOL: name="bool"; break;
-				   case TYPE_FLOAT: name="float"; break;
-				   case TYPE_VEC2: name="vec2"; break;
-				   case TYPE_VEC3: name="vec3"; break;
-				   case TYPE_VEC4: name="vec4"; break;
-				   case TYPE_MAT2: name="mat2"; break;
-				   case TYPE_MAT3: name="mat3"; break;
-				   case TYPE_MAT4: name="mat4"; break;
-				   default: ERR_FAIL_V(ERR_BUG);
+				constructor = get_token_datatype(parser.get_next_token_type());
+				switch (get_token_datatype(parser.get_next_token_type())) {
+					case TYPE_BOOL: name = "bool"; break;
+					case TYPE_FLOAT: name = "float"; break;
+					case TYPE_VEC2: name = "vec2"; break;
+					case TYPE_VEC3: name = "vec3"; break;
+					case TYPE_VEC4: name = "vec4"; break;
+					case TYPE_MAT2: name = "mat2"; break;
+					case TYPE_MAT3: name = "mat3"; break;
+					case TYPE_MAT4: name = "mat4"; break;
+					default: ERR_FAIL_V(ERR_BUG);
 				}
 			} else {
 
-				name=parser.get_next_token().text;
+				name = parser.get_next_token().text;
 			}
 
-			if (!test_existing_identifier(p_parent,name)) {
+			if (!test_existing_identifier(p_parent, name)) {
 
-				parser.set_error("Unknown identifier in expression: "+name);
+				parser.set_error("Unknown identifier in expression: " + name);
 				return ERR_PARSE_ERROR;
 			}
 
@@ -1615,34 +1582,33 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 
 			OperatorNode *func = parser.create_node<OperatorNode>(p_parent);
 
-			func->op=constructor!=TYPE_VOID?OP_CONSTRUCT:OP_CALL;
+			func->op = constructor != TYPE_VOID ? OP_CONSTRUCT : OP_CALL;
 
 			VariableNode *funcname = parser.create_node<VariableNode>(func);
-			funcname->name=name;
+			funcname->name = name;
 			func->arguments.push_back(funcname);
 
 			//parse parameters
 
-			if (parser.get_next_token_type()==TK_PARENTHESIS_CLOSE) {
+			if (parser.get_next_token_type() == TK_PARENTHESIS_CLOSE) {
 				parser.advance();
 			} else {
 
-				while(true) {
-
+				while (true) {
 
-					Node *arg=NULL;
-					Error err = parse_expression(parser,func,&arg);
+					Node *arg = NULL;
+					Error err = parse_expression(parser, func, &arg);
 					if (err)
 						return err;
 					func->arguments.push_back(arg);
 
-					if (parser.get_next_token_type()==TK_PARENTHESIS_CLOSE) {
+					if (parser.get_next_token_type() == TK_PARENTHESIS_CLOSE) {
 						parser.advance();
 						break;
 
-					} else if (parser.get_next_token_type()==TK_COMMA) {
+					} else if (parser.get_next_token_type() == TK_COMMA) {
 
-						if (parser.get_next_token_type(1)==TK_PARENTHESIS_CLOSE) {
+						if (parser.get_next_token_type(1) == TK_PARENTHESIS_CLOSE) {
 
 							parser.set_error("Expression expected");
 							return ERR_PARSE_ERROR;
@@ -1654,92 +1620,86 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 						parser.set_error("Expected ',' or ')'");
 						return ERR_PARSE_ERROR;
 					}
-
 				}
 			}
 
-			expr=validate_function_call(parser,func);
+			expr = validate_function_call(parser, func);
 			if (!expr) {
 
-				parser.set_error("Invalid arguments to function/constructor: "+StringName(name));
+				parser.set_error("Invalid arguments to function/constructor: " + StringName(name));
 				return ERR_PARSE_ERROR;
-
 			}
 
-		} else if (parser.get_next_token_type()==TK_INDENTIFIER) {
+		} else if (parser.get_next_token_type() == TK_INDENTIFIER) {
 			//probably variable
 
-
-			Node *node =p_parent;
-			bool existing=false;
+			Node *node = p_parent;
+			bool existing = false;
 			DataType datatype;
-			StringName identifier=parser.get_next_token().text;
+			StringName identifier = parser.get_next_token().text;
 
-			while(node) {
+			while (node) {
 
-				if (node->type==Node::TYPE_BLOCK) {
+				if (node->type == Node::TYPE_BLOCK) {
 
-					BlockNode *block = (BlockNode*)node;
+					BlockNode *block = (BlockNode *)node;
 
 					if (block->variables.has(identifier)) {
-						existing=true;
-						datatype=block->variables[identifier];
+						existing = true;
+						datatype = block->variables[identifier];
 						break;
 					}
 				}
 
-				if (node->type==Node::TYPE_FUNCTION) {
+				if (node->type == Node::TYPE_FUNCTION) {
 
-					FunctionNode *function=(FunctionNode*)node;
-					for(int i=0;i<function->arguments.size();i++) {
-						if (function->arguments[i].name==identifier) {
-							existing=true;
-							datatype=function->arguments[i].type;
+					FunctionNode *function = (FunctionNode *)node;
+					for (int i = 0; i < function->arguments.size(); i++) {
+						if (function->arguments[i].name == identifier) {
+							existing = true;
+							datatype = function->arguments[i].type;
 							break;
 						}
 					}
 
 					if (existing)
 						break;
-
 				}
 
-				if (node->type==Node::TYPE_PROGRAM) {
+				if (node->type == Node::TYPE_PROGRAM) {
 
-					ProgramNode *program = (ProgramNode*)node;
+					ProgramNode *program = (ProgramNode *)node;
 					if (program->builtin_variables.has(identifier)) {
 						datatype = program->builtin_variables[identifier];
-						existing=true;
+						existing = true;
 						break;
 					}
 					if (program->uniforms.has(identifier)) {
 						datatype = program->uniforms[identifier].type;
-						existing=true;
+						existing = true;
 						break;
 					}
-
 				}
 
-				node=node->parent;
+				node = node->parent;
 			}
 
 			if (!existing) {
 
-				parser.set_error("Nonexistent identifier in expression: "+identifier);
+				parser.set_error("Nonexistent identifier in expression: " + identifier);
 				return ERR_PARSE_ERROR;
-
 			}
 
 			VariableNode *varname = parser.create_node<VariableNode>(p_parent);
-			varname->name=identifier;
-			varname->datatype_cache=datatype;
+			varname->name = identifier;
+			varname->datatype_cache = datatype;
 			parser.advance();
-			expr=varname;
+			expr = varname;
 
-		} else if (parser.get_next_token_type()==TK_OP_SUB || parser.get_next_token_type()==TK_OP_NOT) {
+		} else if (parser.get_next_token_type() == TK_OP_SUB || parser.get_next_token_type() == TK_OP_NOT) {
 
 			//single prefix operators
-			TokenType token_type=parser.get_next_token_type();
+			TokenType token_type = parser.get_next_token_type();
 			parser.advance();
 			//Node *subexpr=NULL;
 			//Error err = parse_expression(parser,p_parent,&subexpr);
@@ -1749,11 +1709,13 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 			//OperatorNode *op = parser.create_node<OperatorNode>(p_parent);
 
 			Expression e;
-			e.is_op=true;
+			e.is_op = true;
 
-			switch(token_type) {
-				case TK_OP_SUB: e.op=TK_OP_NEG; break;
-				case TK_OP_NOT: e.op=TK_OP_NOT; break;
+			switch (token_type) {
+				case TK_OP_SUB: e.op = TK_OP_NEG; break;
+				case TK_OP_NOT:
+					e.op = TK_OP_NOT;
+					break;
 				//case TK_OP_PLUS_PLUS: op->op=OP_PLUS_PLUS; break;
 				//case TK_OP_MINUS_MINUS: op->op=OP_MINUS_MINUS; break;
 				default: ERR_FAIL_V(ERR_BUG);
@@ -1763,27 +1725,24 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 
 			continue;
 
-
 		} else {
 			print_line("found bug?");
-			print_line("misplaced token: "+String(token_names[parser.get_next_token_type()]));
+			print_line("misplaced token: " + String(token_names[parser.get_next_token_type()]));
 
-			parser.set_error("Error parsing expression, misplaced: "+String(token_names[parser.get_next_token_type()]));
+			parser.set_error("Error parsing expression, misplaced: " + String(token_names[parser.get_next_token_type()]));
 			return ERR_PARSE_ERROR;
 			//nothing
 		}
 
-		ERR_FAIL_COND_V(!expr,ERR_BUG);
-
+		ERR_FAIL_COND_V(!expr, ERR_BUG);
 
 		/* OK now see what's NEXT to the operator.. */
 		/* OK now see what's NEXT to the operator.. */
 		/* OK now see what's NEXT to the operator.. */
 
+		if (parser.get_next_token_type() == TK_PERIOD) {
 
-		if (parser.get_next_token_type()==TK_PERIOD) {
-
-			if (parser.get_next_token_type(1)!=TK_INDENTIFIER) {
+			if (parser.get_next_token_type(1) != TK_INDENTIFIER) {
 				parser.set_error("Expected identifier as member");
 				return ERR_PARSE_ERROR;
 			}
@@ -1791,32 +1750,32 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 			DataType dt = compute_node_type(expr);
 			String ident = parser.get_next_token(1).text;
 
-			bool ok=true;
+			bool ok = true;
 			DataType member_type;
-			switch(dt) {
+			switch (dt) {
 				case TYPE_VEC2: {
 
 					int l = ident.length();
-					if (l==1) {
-						member_type=TYPE_FLOAT;
-					} else if (l==2) {
-						member_type=TYPE_VEC2;
+					if (l == 1) {
+						member_type = TYPE_FLOAT;
+					} else if (l == 2) {
+						member_type = TYPE_VEC2;
 					} else {
-						ok=false;
+						ok = false;
 						break;
 					}
 
-					const CharType *c=ident.ptr();
-					for(int i=0;i<l;i++) {
+					const CharType *c = ident.ptr();
+					for (int i = 0; i < l; i++) {
 
-						switch(c[i]) {
+						switch (c[i]) {
 							case 'r':
 							case 'g':
 							case 'x':
 							case 'y':
 								break;
 							default:
-								ok=false;
+								ok = false;
 								break;
 						}
 					}
@@ -1825,21 +1784,21 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 				case TYPE_VEC3: {
 
 					int l = ident.length();
-					if (l==1) {
-						member_type=TYPE_FLOAT;
-					} else if (l==2) {
-						member_type=TYPE_VEC2;
-					} else if (l==3) {
-						member_type=TYPE_VEC3;
+					if (l == 1) {
+						member_type = TYPE_FLOAT;
+					} else if (l == 2) {
+						member_type = TYPE_VEC2;
+					} else if (l == 3) {
+						member_type = TYPE_VEC3;
 					} else {
-						ok=false;
+						ok = false;
 						break;
 					}
 
-					const CharType *c=ident.ptr();
-					for(int i=0;i<l;i++) {
+					const CharType *c = ident.ptr();
+					for (int i = 0; i < l; i++) {
 
-						switch(c[i]) {
+						switch (c[i]) {
 							case 'r':
 							case 'g':
 							case 'b':
@@ -1848,7 +1807,7 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 							case 'z':
 								break;
 							default:
-								ok=false;
+								ok = false;
 								break;
 						}
 					}
@@ -1857,23 +1816,23 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 				case TYPE_VEC4: {
 
 					int l = ident.length();
-					if (l==1) {
-						member_type=TYPE_FLOAT;
-					} else if (l==2) {
-						member_type=TYPE_VEC2;
-					} else if (l==3) {
-						member_type=TYPE_VEC3;
-					} else if (l==4) {
-						member_type=TYPE_VEC4;
+					if (l == 1) {
+						member_type = TYPE_FLOAT;
+					} else if (l == 2) {
+						member_type = TYPE_VEC2;
+					} else if (l == 3) {
+						member_type = TYPE_VEC3;
+					} else if (l == 4) {
+						member_type = TYPE_VEC4;
 					} else {
-						ok=false;
+						ok = false;
 						break;
 					}
 
-					const CharType *c=ident.ptr();
-					for(int i=0;i<l;i++) {
+					const CharType *c = ident.ptr();
+					for (int i = 0; i < l; i++) {
 
-						switch(c[i]) {
+						switch (c[i]) {
 							case 'r':
 							case 'g':
 							case 'b':
@@ -1884,43 +1843,50 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 							case 'w':
 								break;
 							default:
-								ok=false;
+								ok = false;
 								break;
 						}
 					}
 
 				} break;
-				case TYPE_MAT2: ok=(ident=="x" || ident=="y"); member_type=TYPE_VEC2; break;
-				case TYPE_MAT3: ok=(ident=="x" || ident=="y" || ident=="z" ); member_type=TYPE_VEC3; break;
-				case TYPE_MAT4: ok=(ident=="x" || ident=="y" || ident=="z" || ident=="w"); member_type=TYPE_VEC4; break;
+				case TYPE_MAT2:
+					ok = (ident == "x" || ident == "y");
+					member_type = TYPE_VEC2;
+					break;
+				case TYPE_MAT3:
+					ok = (ident == "x" || ident == "y" || ident == "z");
+					member_type = TYPE_VEC3;
+					break;
+				case TYPE_MAT4:
+					ok = (ident == "x" || ident == "y" || ident == "z" || ident == "w");
+					member_type = TYPE_VEC4;
+					break;
 				default: {}
 			}
 
 			if (!ok) {
 
-				parser.set_error("Invalid member for expression: ."+ident);
+				parser.set_error("Invalid member for expression: ." + ident);
 				return ERR_PARSE_ERROR;
 			}
 
 			MemberNode *mn = parser.create_node<MemberNode>(p_parent);
-			mn->basetype=dt;
-			mn->datatype=member_type;
-			mn->name=ident;
-			mn->owner=expr;
-			expr=mn;
+			mn->basetype = dt;
+			mn->datatype = member_type;
+			mn->name = ident;
+			mn->owner = expr;
+			expr = mn;
 
 			parser.advance(2);
 			//todo
 			//member (period) has priority over any operator
 			//creates a subindexing expression in place
 
-
-		} else if (parser.get_next_token_type()==TK_BRACKET_OPEN) {
+		} else if (parser.get_next_token_type() == TK_BRACKET_OPEN) {
 			//todo
 			//subindexing has priority over any operator
 			//creates a subindexing expression in place
 
-
 		} /*else if (parser.get_next_token_type()==TK_OP_PLUS_PLUS || parser.get_next_token_type()==TK_OP_MINUS_MINUS) {
 			//todo
 			//inc/dec operators have priority over any operator
@@ -1930,16 +1896,15 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 		} */
 
 		Expression e;
-		e.is_op=false;
-		e.node=expr;
+		e.is_op = false;
+		e.node = expr;
 		expression.push_back(e);
 
-
 		if (is_token_operator(parser.get_next_token_type())) {
 
 			Expression o;
-			o.is_op=true;
-			o.op=parser.get_next_token_type();
+			o.is_op = true;
+			o.op = parser.get_next_token_type();
 			expression.push_back(o);
 			parser.advance();
 		} else {
@@ -1947,87 +1912,96 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 		}
 	}
 
-
-
 	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
 
-	while(expression.size()>1) {
+	while (expression.size() > 1) {
 
-		int next_op=-1;
-		int min_priority=0xFFFFF;
-		bool is_unary=false;
+		int next_op = -1;
+		int min_priority = 0xFFFFF;
+		bool is_unary = false;
 
-		for(int i=0;i<expression.size();i++) {
+		for (int i = 0; i < expression.size(); i++) {
 
 			if (!expression[i].is_op) {
 
 				continue;
 			}
 
-			bool unary=false;
+			bool unary = false;
 
 			int priority;
-			switch(expression[i].op) {
+			switch (expression[i].op) {
 
-				case TK_OP_NOT: priority=0; unary=true; break;
-				case TK_OP_NEG: priority=0; unary=true; break;
+				case TK_OP_NOT:
+					priority = 0;
+					unary = true;
+					break;
+				case TK_OP_NEG:
+					priority = 0;
+					unary = true;
+					break;
 
-				case TK_OP_MUL: priority=1; break;
-				case TK_OP_DIV: priority=1; break;
+				case TK_OP_MUL: priority = 1; break;
+				case TK_OP_DIV: priority = 1; break;
 
-				case TK_OP_ADD: priority=2; break;
-				case TK_OP_SUB: priority=2; break;
+				case TK_OP_ADD: priority = 2; break;
+				case TK_OP_SUB:
+					priority = 2;
+					break;
 
 				// shift left/right =2
 
-				case TK_OP_LESS: priority=4; break;
-				case TK_OP_LESS_EQUAL: priority=4; break;
-				case TK_OP_GREATER: priority=4; break;
-				case TK_OP_GREATER_EQUAL: priority=4; break;
+				case TK_OP_LESS: priority = 4; break;
+				case TK_OP_LESS_EQUAL: priority = 4; break;
+				case TK_OP_GREATER: priority = 4; break;
+				case TK_OP_GREATER_EQUAL: priority = 4; break;
 
-				case TK_OP_EQUAL: priority=5; break;
-				case TK_OP_NOT_EQUAL: priority=5; break;
+				case TK_OP_EQUAL: priority = 5; break;
+				case TK_OP_NOT_EQUAL:
+					priority = 5;
+					break;
 
 				//bit and =5
 				//bit xor =6
 				//bit or=7
 
-				case TK_OP_AND: priority=8; break;
-				case TK_OP_OR: priority=9; break;
+				case TK_OP_AND: priority = 8; break;
+				case TK_OP_OR:
+					priority = 9;
+					break;
 
 				// ?: = 10
 
-				case TK_OP_ASSIGN_ADD: priority=11; break;
-				case TK_OP_ASSIGN_SUB: priority=11; break;
-				case TK_OP_ASSIGN_MUL: priority=11; break;
-				case TK_OP_ASSIGN_DIV: priority=11; break;
-				case TK_OP_ASSIGN: priority=11; break;
-
-				default: ERR_FAIL_V(ERR_BUG); //unexpected operator
+				case TK_OP_ASSIGN_ADD: priority = 11; break;
+				case TK_OP_ASSIGN_SUB: priority = 11; break;
+				case TK_OP_ASSIGN_MUL: priority = 11; break;
+				case TK_OP_ASSIGN_DIV: priority = 11; break;
+				case TK_OP_ASSIGN: priority = 11; break;
 
+				default:
+					ERR_FAIL_V(ERR_BUG); //unexpected operator
 			}
 
-			if (priority<min_priority) {
+			if (priority < min_priority) {
 				// < is used for left to right (default)
 				// <= is used for right to left
-				next_op=i;
-				min_priority=priority;
-				is_unary=unary;
+				next_op = i;
+				min_priority = priority;
+				is_unary = unary;
 			}
-
 		}
 
-		ERR_FAIL_COND_V(next_op==-1,ERR_BUG);
+		ERR_FAIL_COND_V(next_op == -1, ERR_BUG);
 
 		// OK! create operator..
 		// OK! create operator..
 		if (is_unary) {
 
-			int expr_pos=next_op;
-			while(expression[expr_pos].is_op) {
+			int expr_pos = next_op;
+			while (expression[expr_pos].is_op) {
 
 				expr_pos++;
-				if (expr_pos==expression.size()) {
+				if (expr_pos == expression.size()) {
 					//can happen..
 					parser.set_error("Unexpected end of expression..");
 					return ERR_BUG;
@@ -2035,72 +2009,68 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 			}
 
 			//consecutively do unary opeators
-			for(int i=expr_pos-1;i>=next_op;i--) {
+			for (int i = expr_pos - 1; i >= next_op; i--) {
 
 				OperatorNode *op = parser.create_node<OperatorNode>(p_parent);
-				op->op=get_token_operator(expression[i].op);
-				op->arguments.push_back(expression[i+1].node);
+				op->op = get_token_operator(expression[i].op);
+				op->arguments.push_back(expression[i + 1].node);
 
-				expression[i].is_op=false;
-				expression[i].node=validate_operator(parser,op);
+				expression[i].is_op = false;
+				expression[i].node = validate_operator(parser, op);
 				if (!expression[i].node) {
 
 					String at;
-					for(int i=0;i<op->arguments.size();i++) {
-						if (i>0)
-							at+=" and ";
-						at+=get_datatype_name(compute_node_type(op->arguments[i]));
-
+					for (int i = 0; i < op->arguments.size(); i++) {
+						if (i > 0)
+							at += " and ";
+						at += get_datatype_name(compute_node_type(op->arguments[i]));
 					}
-					parser.set_error("Invalid argument to unary operator "+String(token_names[op->op])+": "+at);
+					parser.set_error("Invalid argument to unary operator " + String(token_names[op->op]) + ": " + at);
 					return ERR_PARSE_ERROR;
 				}
-				expression.remove(i+1);
+				expression.remove(i + 1);
 			}
 		} else {
 
-			if (next_op <1 || next_op>=(expression.size()-1)) {
+			if (next_op < 1 || next_op >= (expression.size() - 1)) {
 				parser.set_error("Parser bug..");
 				ERR_FAIL_V(ERR_BUG);
 			}
 
 			OperatorNode *op = parser.create_node<OperatorNode>(p_parent);
-			op->op=get_token_operator(expression[next_op].op);
+			op->op = get_token_operator(expression[next_op].op);
 
-			if (expression[next_op-1].is_op) {
+			if (expression[next_op - 1].is_op) {
 
 				parser.set_error("Parser bug..");
 				ERR_FAIL_V(ERR_BUG);
 			}
 
-			if (expression[next_op+1].is_op) {
+			if (expression[next_op + 1].is_op) {
 				// this is not invalid and can really appear
 				// but it becomes invalid anyway because no binary op
 				// can be followed by an unary op in a valid combination,
 				// due to how precedence works, unaries will always dissapear first
 
 				parser.set_error("Parser bug..");
-
 			}
 
-
-			op->arguments.push_back(expression[next_op-1].node); //expression goes as left
-			op->arguments.push_back(expression[next_op+1].node); //next expression goes as right
+			op->arguments.push_back(expression[next_op - 1].node); //expression goes as left
+			op->arguments.push_back(expression[next_op + 1].node); //next expression goes as right
 
 			//replace all 3 nodes by this operator and make it an expression
-			expression[next_op-1].node=validate_operator(parser,op);
-			if (!expression[next_op-1].node) {
+			expression[next_op - 1].node = validate_operator(parser, op);
+			if (!expression[next_op - 1].node) {
 
 				String at;
-				for(int i=0;i<op->arguments.size();i++) {
-					if (i>0)
-						at+=" and ";
-					at+=get_datatype_name(compute_node_type(op->arguments[i]));
-
+				for (int i = 0; i < op->arguments.size(); i++) {
+					if (i > 0)
+						at += " and ";
+					at += get_datatype_name(compute_node_type(op->arguments[i]));
 				}
-				static const char *op_names[OP_MAX]={"=","+","-","*","/","+=","-=","*=","/=","-","!","==","!=","<=",">=","<",">","||","&&","call","()"};
+				static const char *op_names[OP_MAX] = { "=", "+", "-", "*", "/", "+=", "-=", "*=", "/=", "-", "!", "==", "!=", "<=", ">=", "<", ">", "||", "&&", "call", "()" };
 
-				parser.set_error("Invalid arguments to operator "+String(op_names[op->op])+": "+at);
+				parser.set_error("Invalid arguments to operator " + String(op_names[op->op]) + ": " + at);
 				return ERR_PARSE_ERROR;
 			}
 			expression.remove(next_op);
@@ -2132,14 +2102,13 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 		expressions.remove(next_op+1);
 		operators.remove(next_op);
 #endif
-
 	}
 
-	*r_expr=expression[0].node;
+	*r_expr = expression[0].node;
 
 	return OK;
 
-/*
+	/*
 			TokenType token_type=parser.get_next_token_type();
 			OperatorNode *op = parser.create_node<OperatorNode>(p_parent);
 			op->op=get_token_operator(parser.get_next_token_type());
@@ -2159,101 +2128,97 @@ Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_ex
 			}
 
 */
-
 }
 
-Error ShaderLanguage::parse_variable_declaration(Parser& parser,BlockNode *p_block) {
+Error ShaderLanguage::parse_variable_declaration(Parser &parser, BlockNode *p_block) {
 
-	bool uniform = parser.get_next_token(-1).type==TK_UNIFORM;
+	bool uniform = parser.get_next_token(-1).type == TK_UNIFORM;
 
-	DataType type=get_token_datatype(parser.get_next_token_type(0));
-	bool iscolor = parser.get_next_token_type(0)==TK_TYPE_COLOR;
+	DataType type = get_token_datatype(parser.get_next_token_type(0));
+	bool iscolor = parser.get_next_token_type(0) == TK_TYPE_COLOR;
 
-	if (type==TYPE_VOID) {
+	if (type == TYPE_VOID) {
 
 		parser.set_error("Cannot Declare a 'void' Variable");
 		return ERR_PARSE_ERROR;
 	}
 
-	if (type==TYPE_TEXTURE && !uniform) {
+	if (type == TYPE_TEXTURE && !uniform) {
 
 		parser.set_error("Cannot Declare a Non-Uniform Texture");
 		return ERR_PARSE_ERROR;
 	}
-	if (type==TYPE_CUBEMAP && !uniform) {
+	if (type == TYPE_CUBEMAP && !uniform) {
 
 		parser.set_error("Cannot Declare a Non-Uniform Cubemap");
 		return ERR_PARSE_ERROR;
 	}
 
-
 	parser.advance();
-	int found=0;
-
-	while(true) {
+	int found = 0;
 
+	while (true) {
 
-		if (found && parser.get_next_token_type()!=TK_COMMA) {
+		if (found && parser.get_next_token_type() != TK_COMMA) {
 			break;
 		}
 
-		if (parser.get_next_token_type()!=TK_INDENTIFIER) {
+		if (parser.get_next_token_type() != TK_INDENTIFIER) {
 
 			parser.set_error("Identifier Expected");
 			return ERR_PARSE_ERROR;
-
 		}
 
 		StringName name = parser.get_next_token().text;
 
-		if (test_existing_identifier(p_block,name)) {
-			parser.set_error("Duplicate Identifier (existing variable/function): "+name);
+		if (test_existing_identifier(p_block, name)) {
+			parser.set_error("Duplicate Identifier (existing variable/function): " + name);
 			return ERR_PARSE_ERROR;
 		}
 
-		found=true;
+		found = true;
 
 		parser.advance();
 		//see if declaration has an initializer
-		if (parser.get_next_token_type()==TK_OP_ASSIGN) {
+		if (parser.get_next_token_type() == TK_OP_ASSIGN) {
 			parser.advance();
-			OperatorNode * op = parser.create_node<OperatorNode>(p_block);
-			VariableNode * var = parser.create_node<VariableNode>(op);
-			var->name=name;
-			var->datatype_cache=type;
-			var->uniform=uniform;
+			OperatorNode *op = parser.create_node<OperatorNode>(p_block);
+			VariableNode *var = parser.create_node<VariableNode>(op);
+			var->name = name;
+			var->datatype_cache = type;
+			var->uniform = uniform;
 			Node *expr;
-			Error err = parse_expression(parser,p_block,&expr);
+			Error err = parse_expression(parser, p_block, &expr);
 
 			if (err)
 				return err;
 
 			if (var->uniform) {
 
-				if (expr->type!=Node::TYPE_CONSTANT) {
+				if (expr->type != Node::TYPE_CONSTANT) {
 
 					parser.set_error("Uniform can only be initialized to a constant.");
 					return ERR_PARSE_ERROR;
 				}
 
 				Uniform u;
-				u.order=parser.program->uniforms.size();
-				u.type=type;
-				u.default_value=static_cast<ConstantNode*>(expr)->value;
-				if (iscolor && u.default_value.get_type()==Variant::PLANE) {
+				u.order = parser.program->uniforms.size();
+				u.type = type;
+				u.default_value = static_cast<ConstantNode *>(expr)->value;
+				if (iscolor && u.default_value.get_type() == Variant::PLANE) {
 					Color c;
 					Plane p = u.default_value;
-					c=Color(p.normal.x,p.normal.y,p.normal.z,p.d);
-					u.default_value=c;
+					c = Color(p.normal.x, p.normal.y, p.normal.z, p.d);
+					u.default_value = c;
 				}
-				parser.program->uniforms[var->name]=u;
+				parser.program->uniforms[var->name] = u;
 			} else {
-				op->op=OP_ASSIGN;
+				op->op = OP_ASSIGN;
 				op->arguments.push_back(var);
 				op->arguments.push_back(expr);
-				Node *n=validate_operator(parser,op);
+				Node *n = validate_operator(parser, op);
 				if (!n) {
-					parser.set_error("Invalid initializer for variable: "+name);
+					parser.set_error("Invalid initializer for variable: " + name);
 					return ERR_PARSE_ERROR;
 				}
 				p_block->statements.push_back(n);
@@ -2262,80 +2227,76 @@ Error ShaderLanguage::parse_variable_declaration(Parser& parser,BlockNode *p_blo
 		} else {
 			//initialize it EMPTY
 
-			OperatorNode * op = parser.create_node<OperatorNode>(p_block);
-			VariableNode * var = parser.create_node<VariableNode>(op);
-			ConstantNode * con = parser.create_node<ConstantNode>(op);
+			OperatorNode *op = parser.create_node<OperatorNode>(p_block);
+			VariableNode *var = parser.create_node<VariableNode>(op);
+			ConstantNode *con = parser.create_node<ConstantNode>(op);
 
-			var->name=name;
-			var->datatype_cache=type;
-			var->uniform=uniform;
-			con->datatype=type;
+			var->name = name;
+			var->datatype_cache = type;
+			var->uniform = uniform;
+			con->datatype = type;
 
-			switch(type) {
-				case TYPE_BOOL: con->value=false; break;
-				case TYPE_FLOAT: con->value=0.0; break;
-				case TYPE_VEC2: con->value=Vector2(); break;
-				case TYPE_VEC3: con->value=Vector3(); break;
-				case TYPE_VEC4: con->value=iscolor?Variant(Color()):Variant(Plane()); break;
-				case TYPE_MAT2: con->value=Matrix32(); break;
-				case TYPE_MAT3: con->value=Matrix3(); break;
-				case TYPE_MAT4: con->value=Transform(); break;
+			switch (type) {
+				case TYPE_BOOL: con->value = false; break;
+				case TYPE_FLOAT: con->value = 0.0; break;
+				case TYPE_VEC2: con->value = Vector2(); break;
+				case TYPE_VEC3: con->value = Vector3(); break;
+				case TYPE_VEC4: con->value = iscolor ? Variant(Color()) : Variant(Plane()); break;
+				case TYPE_MAT2: con->value = Matrix32(); break;
+				case TYPE_MAT3: con->value = Matrix3(); break;
+				case TYPE_MAT4: con->value = Transform(); break;
 				case TYPE_TEXTURE:
-				case TYPE_CUBEMAP: con->value=RID(); break;
+				case TYPE_CUBEMAP: con->value = RID(); break;
 				default: {}
 			}
 
 			if (uniform) {
 				Uniform u;
-				u.type=type;
-				u.default_value=con->value;
-				u.order=parser.program->uniforms.size();
-				parser.program->uniforms[var->name]=u;
+				u.type = type;
+				u.default_value = con->value;
+				u.order = parser.program->uniforms.size();
+				parser.program->uniforms[var->name] = u;
 
 			} else {
-				op->op=OP_ASSIGN;
+				op->op = OP_ASSIGN;
 				op->arguments.push_back(var);
 				op->arguments.push_back(con);
 				p_block->statements.push_back(op);
 			}
-
 		}
 
 		if (!uniform)
-			p_block->variables[name]=type;
-
+			p_block->variables[name] = type;
 	}
 
-	if (parser.get_next_token_type()!=TK_SEMICOLON) {
+	if (parser.get_next_token_type() != TK_SEMICOLON) {
 		parser.set_error("Expected ';'");
 		return ERR_PARSE_ERROR;
 	}
 
-
 	return OK;
-
 }
 
-Error ShaderLanguage::parse_flow_if(Parser& parser,Node *p_parent,Node **r_statement) {
+Error ShaderLanguage::parse_flow_if(Parser &parser, Node *p_parent, Node **r_statement) {
 
 	ControlFlowNode *cf = parser.create_node<ControlFlowNode>(p_parent);
 
-	cf->flow_op=FLOW_OP_IF;
+	cf->flow_op = FLOW_OP_IF;
 
 	parser.advance();
 
-	if (parser.get_next_token_type()!=TK_PARENTHESIS_OPEN) {
+	if (parser.get_next_token_type() != TK_PARENTHESIS_OPEN) {
 		parser.set_error("Expected '(' after 'if'");
 		return ERR_PARSE_ERROR;
 	}
 	parser.advance();
 
-	Node *expression=NULL;
-	Error err = parse_expression(parser,cf,&expression);
+	Node *expression = NULL;
+	Error err = parse_expression(parser, cf, &expression);
 	if (err)
 		return err;
 
-	if (compute_node_type(expression)!=TYPE_BOOL) {
+	if (compute_node_type(expression) != TYPE_BOOL) {
 
 		parser.set_error("Expression for 'if' is not boolean");
 		return ERR_PARSE_ERROR;
@@ -2343,65 +2304,62 @@ Error ShaderLanguage::parse_flow_if(Parser& parser,Node *p_parent,Node **r_state
 
 	cf->statements.push_back(expression);
 
-	if (parser.get_next_token_type()!=TK_PARENTHESIS_CLOSE) {
+	if (parser.get_next_token_type() != TK_PARENTHESIS_CLOSE) {
 		parser.set_error("Expected ')' after expression");
 		return ERR_PARSE_ERROR;
 	}
 
 	parser.advance();
 
-	if (parser.get_next_token_type()!=TK_CURLY_BRACKET_OPEN) {
+	if (parser.get_next_token_type() != TK_CURLY_BRACKET_OPEN) {
 		parser.set_error("Expected statement block after 'if()'");
 		return ERR_PARSE_ERROR;
 	}
 
-	Node *substatement=NULL;
-	err = parse_statement(parser,cf,&substatement);
+	Node *substatement = NULL;
+	err = parse_statement(parser, cf, &substatement);
 	if (err)
 		return err;
 
 	cf->statements.push_back(substatement);
 
-	if (parser.get_next_token_type()==TK_CF_ELSE) {
+	if (parser.get_next_token_type() == TK_CF_ELSE) {
 
 		parser.advance();
 
-		if (parser.get_next_token_type()!=TK_CURLY_BRACKET_OPEN) {
+		if (parser.get_next_token_type() != TK_CURLY_BRACKET_OPEN) {
 			parser.set_error("Expected statement block after 'else'");
 			return ERR_PARSE_ERROR;
 		}
 
-		substatement=NULL;
-		err = parse_statement(parser,cf,&substatement);
+		substatement = NULL;
+		err = parse_statement(parser, cf, &substatement);
 		if (err)
 			return err;
 
 		cf->statements.push_back(substatement);
 	}
 
-
-
-	*r_statement=cf;
+	*r_statement = cf;
 
 	return OK;
 }
 
-Error ShaderLanguage::parse_flow_return(Parser& parser,Node *p_parent,Node **r_statement) {
-
+Error ShaderLanguage::parse_flow_return(Parser &parser, Node *p_parent, Node **r_statement) {
 
-	FunctionNode *function=NULL;
+	FunctionNode *function = NULL;
 
-	Node *parent=p_parent;
+	Node *parent = p_parent;
 
-	while(parent) {
+	while (parent) {
 
-		if (parent->type==Node::TYPE_FUNCTION) {
+		if (parent->type == Node::TYPE_FUNCTION) {
 
-			function=(FunctionNode*)parent;
+			function = (FunctionNode *)parent;
 			break;
 		}
 
-		parent=parent->parent;
+		parent = parent->parent;
 	}
 
 	if (!function) {
@@ -2412,29 +2370,28 @@ Error ShaderLanguage::parse_flow_return(Parser& parser,Node *p_parent,Node **r_s
 
 	ControlFlowNode *cf = parser.create_node<ControlFlowNode>(p_parent);
 
-	cf->flow_op=FLOW_OP_RETURN;
+	cf->flow_op = FLOW_OP_RETURN;
 
 	parser.advance();
 
-	if (function->return_type!=TYPE_VOID) {
+	if (function->return_type != TYPE_VOID) {
 		// should expect a return expression.
 
-		Node *expr=NULL;
-		Error err = parse_expression(parser,cf,&expr);
+		Node *expr = NULL;
+		Error err = parse_expression(parser, cf, &expr);
 		if (err)
 			return err;
 
-		if (compute_node_type(expr)!=function->return_type) {
+		if (compute_node_type(expr) != function->return_type) {
 			parser.set_error("Invalid type for 'return' expression");
 			return ERR_PARSE_ERROR;
 		}
 		cf->statements.push_back(expr);
 	}
 
-	*r_statement=cf;
+	*r_statement = cf;
 
-
-	if (parser.get_next_token_type()!=TK_SEMICOLON) {
+	if (parser.get_next_token_type() != TK_SEMICOLON) {
 		parser.set_error("Expected ';'");
 		return ERR_PARSE_ERROR;
 	}
@@ -2442,50 +2399,49 @@ Error ShaderLanguage::parse_flow_return(Parser& parser,Node *p_parent,Node **r_s
 	return OK;
 }
 
-Error ShaderLanguage::parse_statement(Parser& parser,Node *p_parent,Node **r_statement) {
+Error ShaderLanguage::parse_statement(Parser &parser, Node *p_parent, Node **r_statement) {
 
-	*r_statement=NULL;
+	*r_statement = NULL;
 
 	TokenType token_type = parser.get_next_token_type();
 
-	if (token_type==TK_CURLY_BRACKET_OPEN) {
+	if (token_type == TK_CURLY_BRACKET_OPEN) {
 		//sub-block
 		parser.advance();
 		BlockNode *block = parser.create_node<BlockNode>(p_parent);
 
-		*r_statement=block;
-		return parse_block(parser,block);
-	} else if (token_type==TK_SEMICOLON) {
+		*r_statement = block;
+		return parse_block(parser, block);
+	} else if (token_type == TK_SEMICOLON) {
 		// empty ;
 		parser.advance();
 		return OK;
-	} else if (token_type==TK_CF_IF) {
-		return parse_flow_if(parser,p_parent,r_statement);
+	} else if (token_type == TK_CF_IF) {
+		return parse_flow_if(parser, p_parent, r_statement);
 
-	} else if (token_type==TK_CF_RETURN) {
-		return parse_flow_return(parser,p_parent,r_statement);
+	} else if (token_type == TK_CF_RETURN) {
+		return parse_flow_return(parser, p_parent, r_statement);
 	} else {
-		Error err=parse_expression(parser,p_parent,r_statement);
+		Error err = parse_expression(parser, p_parent, r_statement);
 
 		if (err)
 			return err;
 
-		if (parser.get_next_token_type()!=TK_SEMICOLON) {
+		if (parser.get_next_token_type() != TK_SEMICOLON) {
 			parser.set_error("Expected ';'");
 			return ERR_PARSE_ERROR;
 		}
-
 	}
 
 	return OK;
 }
 
-Error ShaderLanguage::parse_block(Parser& parser,BlockNode *p_block) {
+Error ShaderLanguage::parse_block(Parser &parser, BlockNode *p_block) {
 
-	while(true) {
+	while (true) {
 
 		if (parser.is_at_end()) {
-			if (p_block->parent->type!=Node::TYPE_PROGRAM) {
+			if (p_block->parent->type != Node::TYPE_PROGRAM) {
 				parser.set_error("Unexpected End of File");
 				return ERR_PARSE_ERROR;
 			}
@@ -2494,33 +2450,33 @@ Error ShaderLanguage::parse_block(Parser& parser,BlockNode *p_block) {
 
 		TokenType token_type = parser.get_next_token_type();
 
-		if (token_type==TK_CURLY_BRACKET_CLOSE) {
-			if (p_block->parent->type==Node::TYPE_PROGRAM) {
+		if (token_type == TK_CURLY_BRACKET_CLOSE) {
+			if (p_block->parent->type == Node::TYPE_PROGRAM) {
 				parser.set_error("Unexpected '}'");
 				return ERR_PARSE_ERROR;
 			}
 			parser.advance();
 			return OK; // exit block
 
-		} else if (token_type==TK_UNIFORM) {
+		} else if (token_type == TK_UNIFORM) {
 
-			if (p_block!=parser.program->body) {
+			if (p_block != parser.program->body) {
 
 				parser.set_error("Uniform only allowed in main program body.");
 				return ERR_PARSE_ERROR;
 			}
 			parser.advance();
-			Error err=parse_variable_declaration(parser,p_block);
+			Error err = parse_variable_declaration(parser, p_block);
 			if (err)
 				return err;
 
 		} else if (is_token_datatype(token_type)) {
 
-			Error err=OK;
+			Error err = OK;
 			if (parser_is_at_function(parser))
-				err = parse_function(parser,p_block);
+				err = parse_function(parser, p_block);
 			else {
-				err = parse_variable_declaration(parser,p_block);
+				err = parse_variable_declaration(parser, p_block);
 			}
 
 			if (err)
@@ -2528,129 +2484,123 @@ Error ShaderLanguage::parse_block(Parser& parser,BlockNode *p_block) {
 
 		} else {
 			// must be a statement
-			Node *statement=NULL;
+			Node *statement = NULL;
 
-			Error err = parse_statement(parser,p_block,&statement);
+			Error err = parse_statement(parser, p_block, &statement);
 			if (err)
 				return err;
 			if (statement) {
 				p_block->statements.push_back(statement);
 			}
-
 		}
 	}
 
 	return OK;
 }
 
-
-
-Error ShaderLanguage::parse(const Vector<Token>& p_tokens,ShaderType p_type,CompileFunc p_compile_func,void *p_userdata,String *r_error,int *r_err_line,int *r_err_column) {
-
+Error ShaderLanguage::parse(const Vector<Token> &p_tokens, ShaderType p_type, CompileFunc p_compile_func, void *p_userdata, String *r_error, int *r_err_line, int *r_err_column) {
 
 	Parser parser(p_tokens);
 	parser.program = parser.create_node<ProgramNode>(NULL);
 	parser.program->body = parser.create_node<BlockNode>(parser.program);
 
-
 	//add builtins
-	switch(p_type)	{
+	switch (p_type) {
 		case SHADER_MATERIAL_VERTEX: {
-			int idx=0;
+			int idx = 0;
 			while (vertex_builtins_defs[idx].name) {
-				parser.program->builtin_variables[vertex_builtins_defs[idx].name]=vertex_builtins_defs[idx].type;
+				parser.program->builtin_variables[vertex_builtins_defs[idx].name] = vertex_builtins_defs[idx].type;
 				idx++;
 			}
 		} break;
 		case SHADER_MATERIAL_FRAGMENT: {
-			int idx=0;
+			int idx = 0;
 			while (fragment_builtins_defs[idx].name) {
-				parser.program->builtin_variables[fragment_builtins_defs[idx].name]=fragment_builtins_defs[idx].type;
+				parser.program->builtin_variables[fragment_builtins_defs[idx].name] = fragment_builtins_defs[idx].type;
 				idx++;
 			}
 		} break;
 		case SHADER_MATERIAL_LIGHT: {
-			int idx=0;
+			int idx = 0;
 			while (light_builtins_defs[idx].name) {
-				parser.program->builtin_variables[light_builtins_defs[idx].name]=light_builtins_defs[idx].type;
+				parser.program->builtin_variables[light_builtins_defs[idx].name] = light_builtins_defs[idx].type;
 				idx++;
 			}
 		} break;
 		case SHADER_CANVAS_ITEM_VERTEX: {
-			int idx=0;
+			int idx = 0;
 			while (ci_vertex_builtins_defs[idx].name) {
-				parser.program->builtin_variables[ci_vertex_builtins_defs[idx].name]=ci_vertex_builtins_defs[idx].type;
+				parser.program->builtin_variables[ci_vertex_builtins_defs[idx].name] = ci_vertex_builtins_defs[idx].type;
 				idx++;
 			}
 		} break;
 		case SHADER_CANVAS_ITEM_FRAGMENT: {
-			int idx=0;
+			int idx = 0;
 			while (ci_fragment_builtins_defs[idx].name) {
-				parser.program->builtin_variables[ci_fragment_builtins_defs[idx].name]=ci_fragment_builtins_defs[idx].type;
+				parser.program->builtin_variables[ci_fragment_builtins_defs[idx].name] = ci_fragment_builtins_defs[idx].type;
 				idx++;
 			}
 		} break;
 		case SHADER_CANVAS_ITEM_LIGHT: {
-			int idx=0;
+			int idx = 0;
 			while (ci_light_builtins_defs[idx].name) {
-				parser.program->builtin_variables[ci_light_builtins_defs[idx].name]=ci_light_builtins_defs[idx].type;
+				parser.program->builtin_variables[ci_light_builtins_defs[idx].name] = ci_light_builtins_defs[idx].type;
 				idx++;
 			}
 		} break;
 		case SHADER_POST_PROCESS: {
-			int idx=0;
+			int idx = 0;
 			while (postprocess_fragment_builtins_defs[idx].name) {
-				parser.program->builtin_variables[postprocess_fragment_builtins_defs[idx].name]=postprocess_fragment_builtins_defs[idx].type;
+				parser.program->builtin_variables[postprocess_fragment_builtins_defs[idx].name] = postprocess_fragment_builtins_defs[idx].type;
 				idx++;
 			}
 		} break;
 	}
 
-	Error err = parse_block(parser,parser.program->body);
+	Error err = parse_block(parser, parser.program->body);
 	if (err) {
-		parser.get_error(r_error,r_err_line,r_err_column);
+		parser.get_error(r_error, r_err_line, r_err_column);
 		return err;
 	}
 
 	if (p_compile_func) {
-		err = p_compile_func(p_userdata,parser.program);
+		err = p_compile_func(p_userdata, parser.program);
 	}
 
 	//clean up nodes created
-	while(parser.nodegc.size()) {
+	while (parser.nodegc.size()) {
 
-		memdelete( parser.nodegc.front()->get() );
+		memdelete(parser.nodegc.front()->get());
 		parser.nodegc.pop_front();
 	}
 	return err;
 }
 
-Error ShaderLanguage::compile(const String& p_code,ShaderType p_type,CompileFunc p_compile_func,void *p_userdata,String *r_error,int *r_err_line,int *r_err_column) {
+Error ShaderLanguage::compile(const String &p_code, ShaderType p_type, CompileFunc p_compile_func, void *p_userdata, String *r_error, int *r_err_line, int *r_err_column) {
 
-	*r_error="";
-	*r_err_line=0;
-	*r_err_column=0;
+	*r_error = "";
+	*r_err_line = 0;
+	*r_err_column = 0;
 	Vector<Token> tokens;
 
-	Error err = tokenize(p_code,&tokens,r_error,r_err_line,r_err_column);
-	if (err!=OK) {
+	Error err = tokenize(p_code, &tokens, r_error, r_err_line, r_err_column);
+	if (err != OK) {
 		print_line("tokenizer error!");
 	}
 
-	if (err!=OK) {
+	if (err != OK) {
 		return err;
 	}
-	err = parse(tokens,p_type,p_compile_func,p_userdata,r_error,r_err_line,r_err_column);
-	if (err!=OK) {
+	err = parse(tokens, p_type, p_compile_func, p_userdata, r_error, r_err_line, r_err_column);
+	if (err != OK) {
 		return err;
 	}
 	return OK;
 }
 
-
 void ShaderLanguage::get_keyword_list(ShaderType p_type, List<String> *p_keywords) {
 
-	int idx=0;
+	int idx = 0;
 
 	p_keywords->push_back("uniform");
 	p_keywords->push_back("texture");
@@ -2659,51 +2609,50 @@ void ShaderLanguage::get_keyword_list(ShaderType p_type, List<String> *p_keyword
 	p_keywords->push_back("if");
 	p_keywords->push_back("else");
 
-	while(intrinsic_func_defs[idx].name) {
+	while (intrinsic_func_defs[idx].name) {
 
 		p_keywords->push_back(intrinsic_func_defs[idx].name);
 		idx++;
 	}
 
-
-	switch(p_type)	{
+	switch (p_type) {
 		case SHADER_MATERIAL_VERTEX: {
-			idx=0;
+			idx = 0;
 			while (vertex_builtins_defs[idx].name) {
 				p_keywords->push_back(vertex_builtins_defs[idx].name);
 				idx++;
 			}
 		} break;
 		case SHADER_MATERIAL_FRAGMENT: {
-			idx=0;
+			idx = 0;
 			while (fragment_builtins_defs[idx].name) {
 				p_keywords->push_back(fragment_builtins_defs[idx].name);
 				idx++;
 			}
 		} break;
 		case SHADER_MATERIAL_LIGHT: {
-			idx=0;
+			idx = 0;
 			while (light_builtins_defs[idx].name) {
 				p_keywords->push_back(light_builtins_defs[idx].name);
 				idx++;
 			}
 		} break;
 		case SHADER_CANVAS_ITEM_VERTEX: {
-			idx=0;
+			idx = 0;
 			while (ci_vertex_builtins_defs[idx].name) {
 				p_keywords->push_back(ci_vertex_builtins_defs[idx].name);
 				idx++;
 			}
 		} break;
 		case SHADER_CANVAS_ITEM_FRAGMENT: {
-			idx=0;
+			idx = 0;
 			while (ci_fragment_builtins_defs[idx].name) {
 				p_keywords->push_back(ci_fragment_builtins_defs[idx].name);
 				idx++;
 			}
 		} break;
 		case SHADER_CANVAS_ITEM_LIGHT: {
-			idx=0;
+			idx = 0;
 			while (ci_light_builtins_defs[idx].name) {
 				p_keywords->push_back(ci_light_builtins_defs[idx].name);
 				idx++;
@@ -2711,13 +2660,11 @@ void ShaderLanguage::get_keyword_list(ShaderType p_type, List<String> *p_keyword
 		} break;
 
 		case SHADER_POST_PROCESS: {
-			idx=0;
+			idx = 0;
 			while (postprocess_fragment_builtins_defs[idx].name) {
 				p_keywords->push_back(postprocess_fragment_builtins_defs[idx].name);
 				idx++;
 			}
 		} break;
-
 	}
-
 }
diff --git a/servers/visual/shader_language.h b/servers/visual/shader_language.h
index 207c3272c..10c69d822 100644
--- a/servers/visual/shader_language.h
+++ b/servers/visual/shader_language.h
@@ -29,20 +29,16 @@
 #ifndef SHADER_LANGUAGE_H
 #define SHADER_LANGUAGE_H
 
-#include "typedefs.h"
-#include "ustring.h"
 #include "list.h"
-#include "string_db.h"
 #include "map.h"
+#include "string_db.h"
+#include "typedefs.h"
+#include "ustring.h"
 #include "variant.h"
 
-
-class ShaderLanguage  {
-
-
+class ShaderLanguage {
 
 public:
-
 	enum TokenType {
 
 		TK_EMPTY,
@@ -98,8 +94,6 @@ public:
 		TK_MAX
 	};
 
-
-
 	/* COMPILER */
 
 	enum ShaderType {
@@ -175,7 +169,7 @@ public:
 			TYPE_MEMBER
 		};
 
-		Node * parent;
+		Node *parent;
 		Type type;
 
 		virtual DataType get_datatype() const { return TYPE_VOID; }
@@ -183,15 +177,17 @@ public:
 		virtual ~Node() {}
 	};
 
-
 	struct OperatorNode : public Node {
 
 		DataType return_cache;
 		Operator op;
-		Vector<Node*> arguments;
+		Vector<Node *> arguments;
 		virtual DataType get_datatype() const { return return_cache; }
 
-		OperatorNode() { type=TYPE_OPERATOR; return_cache=TYPE_VOID; }
+		OperatorNode() {
+			type = TYPE_OPERATOR;
+			return_cache = TYPE_VOID;
+		}
 	};
 
 	struct VariableNode : public Node {
@@ -200,7 +196,11 @@ public:
 		StringName name;
 		virtual DataType get_datatype() const { return datatype_cache; }
 
-		VariableNode() { type=TYPE_VARIABLE; datatype_cache=TYPE_VOID; uniform=false; }
+		VariableNode() {
+			type = TYPE_VARIABLE;
+			datatype_cache = TYPE_VOID;
+			uniform = false;
+		}
 	};
 
 	struct ConstantNode : public Node {
@@ -209,21 +209,24 @@ public:
 		Variant value;
 		virtual DataType get_datatype() const { return datatype; }
 
-		ConstantNode() { type=TYPE_CONSTANT; }
+		ConstantNode() { type = TYPE_CONSTANT; }
 	};
 
 	struct BlockNode : public Node {
 
-		Map<StringName,DataType> variables;
-		List<Node*> statements;
-		BlockNode() { type=TYPE_BLOCK; }
+		Map<StringName, DataType> variables;
+		List<Node *> statements;
+		BlockNode() { type = TYPE_BLOCK; }
 	};
 
 	struct ControlFlowNode : public Node {
 
 		FlowOperation flow_op;
-		Vector<Node*> statements;
-		ControlFlowNode() { type=TYPE_CONTROL_FLOW; flow_op=FLOW_OP_IF;}
+		Vector<Node *> statements;
+		ControlFlowNode() {
+			type = TYPE_CONTROL_FLOW;
+			flow_op = FLOW_OP_IF;
+		}
 	};
 
 	struct MemberNode : public Node {
@@ -231,15 +234,13 @@ public:
 		DataType basetype;
 		DataType datatype;
 		StringName name;
-		Node* owner;
+		Node *owner;
 		virtual DataType get_datatype() const { return datatype; }
-		MemberNode() { type=TYPE_MEMBER; }
+		MemberNode() { type = TYPE_MEMBER; }
 	};
 
-
 	struct FunctionNode : public Node {
 
-
 		struct Argument {
 
 			StringName name;
@@ -251,8 +252,7 @@ public:
 		Vector<Argument> arguments;
 		BlockNode *body;
 
-		FunctionNode() { type=TYPE_FUNCTION;  }
-
+		FunctionNode() { type = TYPE_FUNCTION; }
 	};
 
 	struct Uniform {
@@ -266,20 +266,18 @@ public:
 
 		struct Function {
 			StringName name;
-			FunctionNode*function;
+			FunctionNode *function;
 		};
 
-
-		Map<StringName,DataType> builtin_variables;
-		Map<StringName,Uniform> uniforms;
+		Map<StringName, DataType> builtin_variables;
+		Map<StringName, Uniform> uniforms;
 
 		Vector<Function> functions;
 		BlockNode *body;
 
-		ProgramNode() { type=TYPE_PROGRAM; }
+		ProgramNode() { type = TYPE_PROGRAM; }
 	};
 
-
 	struct Expression {
 
 		bool is_op;
@@ -289,7 +287,7 @@ public:
 		};
 	};
 
-	typedef Error (*CompileFunc)(void*,ProgramNode*);
+	typedef Error (*CompileFunc)(void *, ProgramNode *);
 
 	struct VarInfo {
 
@@ -298,73 +296,82 @@ public:
 	};
 
 private:
-
-
-
-	static const char * token_names[TK_MAX];
+	static const char *token_names[TK_MAX];
 
 	struct Token {
 
 		TokenType type;
 		StringName text;
-		uint16_t line,col;
+		uint16_t line, col;
 
-		Token(TokenType p_type=TK_EMPTY,const String& p_text=String()) { type=p_type; text=p_text; line=0; col=0; }
+		Token(TokenType p_type = TK_EMPTY, const String &p_text = String()) {
+			type = p_type;
+			text = p_text;
+			line = 0;
+			col = 0;
+		}
 	};
 
-
-
-	static Token read_token(const CharType* p_text,int p_len,int &r_line,int &r_chars);
-	static Error tokenize(const String& p_text,Vector<Token> *p_tokens,String *r_error,int *r_err_line,int *r_err_column);
-
-
-
+	static Token read_token(const CharType *p_text, int p_len, int &r_line, int &r_chars);
+	static Error tokenize(const String &p_text, Vector<Token> *p_tokens, String *r_error, int *r_err_line, int *r_err_column);
 
 	class Parser {
 
 		Vector<Token> tokens;
 		int pos;
 		String error;
-	public:
 
-
-		void set_error(const String& p_error) { error=p_error; }
+	public:
+		void set_error(const String &p_error) { error = p_error; }
 		void get_error(String *r_error, int *r_line, int *r_column) {
 
-			*r_error=error;
-			*r_line=get_next_token(0).line;
-			*r_column=get_next_token(0).col;
+			*r_error = error;
+			*r_line = get_next_token(0).line;
+			*r_column = get_next_token(0).col;
 		}
 
-
-
-		Token get_next_token(int ofs=0) const { int idx=pos+ofs; if (idx<0 || idx>=tokens.size()) return Token(TK_ERROR); return tokens[idx]; }
-		TokenType get_next_token_type(int ofs=0) const { int idx=pos+ofs;  if (idx<0 || idx>=tokens.size()) return TK_ERROR; return tokens[idx].type; }
-		void advance(int p_amount=1) { pos+=p_amount; }
-		bool is_at_end() const { return pos>=tokens.size(); }
+		Token get_next_token(int ofs = 0) const {
+			int idx = pos + ofs;
+			if (idx < 0 || idx >= tokens.size()) return Token(TK_ERROR);
+			return tokens[idx];
+		}
+		TokenType get_next_token_type(int ofs = 0) const {
+			int idx = pos + ofs;
+			if (idx < 0 || idx >= tokens.size()) return TK_ERROR;
+			return tokens[idx].type;
+		}
+		void advance(int p_amount = 1) { pos += p_amount; }
+		bool is_at_end() const { return pos >= tokens.size(); }
 
 		ProgramNode *program;
-		template<class T>
-		T* create_node(Node *p_parent) { T*n=memnew( T ); nodegc.push_back(n); n->parent=p_parent; return n; }
-		List<Node*> nodegc;
+		template <class T>
+		T *create_node(Node *p_parent) {
+			T *n = memnew(T);
+			nodegc.push_back(n);
+			n->parent = p_parent;
+			return n;
+		}
+		List<Node *> nodegc;
 
-		Parser(const Vector<Token>& p_tokens) { tokens=p_tokens; pos=0;}
+		Parser(const Vector<Token> &p_tokens) {
+			tokens = p_tokens;
+			pos = 0;
+		}
 	};
 
 	struct IntrinsicFuncDef {
 
-		enum { MAX_ARGS=5 };
-		const char* name;
+		enum { MAX_ARGS = 5 };
+		const char *name;
 		DataType rettype;
 		const DataType args[MAX_ARGS];
-
 	};
 
 	static const IntrinsicFuncDef intrinsic_func_defs[];
 
 	struct OperatorDef {
 
-		enum { MAX_ARGS=2 };
+		enum { MAX_ARGS = 2 };
 		Operator op;
 		DataType rettype;
 		const DataType args[MAX_ARGS];
@@ -374,7 +381,7 @@ private:
 
 	struct BuiltinsDef {
 
-		const char* name;
+		const char *name;
 		DataType type;
 	};
 
@@ -386,7 +393,6 @@ private:
 	static const BuiltinsDef ci_fragment_builtins_defs[];
 	static const BuiltinsDef ci_light_builtins_defs[];
 
-
 	static const BuiltinsDef postprocess_fragment_builtins_defs[];
 
 	static DataType get_token_datatype(TokenType p_type);
@@ -394,37 +400,34 @@ private:
 	static bool is_token_datatype(TokenType p_type);
 	static bool is_token_nonvoid_datatype(TokenType p_type);
 
-	static bool test_existing_identifier(Node *p_node,const StringName p_identifier,bool p_func=true,bool p_var=true,bool p_builtin=true);
+	static bool test_existing_identifier(Node *p_node, const StringName p_identifier, bool p_func = true, bool p_var = true, bool p_builtin = true);
 
-	static bool parser_is_at_function(Parser& parser);
+	static bool parser_is_at_function(Parser &parser);
 	static DataType compute_node_type(Node *p_node);
 
-	static Node* validate_function_call(Parser&parser, OperatorNode *p_func);
-	static Node* validate_operator(Parser& parser,OperatorNode *p_func);
+	static Node *validate_function_call(Parser &parser, OperatorNode *p_func);
+	static Node *validate_operator(Parser &parser, OperatorNode *p_func);
 	static bool is_token_operator(TokenType p_type);
 	static Operator get_token_operator(TokenType p_type);
 
-	static Error parse_expression(Parser& parser,Node *p_parent,Node **r_expr);
+	static Error parse_expression(Parser &parser, Node *p_parent, Node **r_expr);
 
-	static Error parse_variable_declaration(Parser& parser,BlockNode *p_block);
-	static Error parse_function(Parser& parser,BlockNode *p_block);
-	static Error parse_flow_if(Parser& parser,Node *p_parent,Node **r_statement);
-	static Error parse_flow_return(Parser& parser,Node *p_parent,Node **r_statement);
-	static Error parse_statement(Parser& parser,Node *p_parent,Node **r_statement);
-	static Error parse_block(Parser& parser,BlockNode *p_block);
+	static Error parse_variable_declaration(Parser &parser, BlockNode *p_block);
+	static Error parse_function(Parser &parser, BlockNode *p_block);
+	static Error parse_flow_if(Parser &parser, Node *p_parent, Node **r_statement);
+	static Error parse_flow_return(Parser &parser, Node *p_parent, Node **r_statement);
+	static Error parse_statement(Parser &parser, Node *p_parent, Node **r_statement);
+	static Error parse_block(Parser &parser, BlockNode *p_block);
 
+	static Error parse(const Vector<Token> &p_tokens, ShaderType p_type, CompileFunc p_compile_func, void *p_userdata, String *r_error, int *r_err_line, int *r_err_column);
 
-	static Error parse(const Vector<Token> &p_tokens,ShaderType p_type,CompileFunc p_compile_func,void *p_userdata,String *r_error,int *r_err_line,int *r_err_column);
+	;
 
-;
 public:
+	static void get_keyword_list(ShaderType p_type, List<String> *p_keywords);
 
-	static void get_keyword_list(ShaderType p_type,List<String> *p_keywords);
-
-	static Error compile(const String& p_code,ShaderType p_type, CompileFunc p_compile_func,void *p_userdata,String *r_error,int *r_err_line,int *r_err_column);
-	static String lex_debug(const String& p_code);
-
+	static Error compile(const String &p_code, ShaderType p_type, CompileFunc p_compile_func, void *p_userdata, String *r_error, int *r_err_line, int *r_err_column);
+	static String lex_debug(const String &p_code);
 };
 
-
 #endif // SHADER_LANGUAGE_H
diff --git a/servers/visual/visual_server_raster.cpp b/servers/visual/visual_server_raster.cpp
index f77f17317..568e81b9f 100644
--- a/servers/visual/visual_server_raster.cpp
+++ b/servers/visual/visual_server_raster.cpp
@@ -27,65 +27,54 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "visual_server_raster.h"
-#include "os/os.h"
-#include "globals.h"
 #include "default_mouse_cursor.xpm"
-#include "sort.h"
+#include "globals.h"
 #include "io/marshalls.h"
+#include "os/os.h"
+#include "sort.h"
 // careful, these may run in different threads than the visual server
 
-BalloonAllocator<> *VisualServerRaster::OctreeAllocator::allocator=NULL;
+BalloonAllocator<> *VisualServerRaster::OctreeAllocator::allocator = NULL;
 
-#define VS_CHANGED\
-	changes++;\
+#define VS_CHANGED \
+	changes++;
 
 //	print_line(__FUNCTION__);
 
-
-
-
 RID VisualServerRaster::texture_create() {
 
 	return rasterizer->texture_create();
 }
 
+void VisualServerRaster::texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags) {
 
-void VisualServerRaster::texture_allocate(RID p_texture, int p_width, int p_height,Image::Format p_format,uint32_t p_flags) {
-
-	rasterizer->texture_allocate(p_texture,p_width,p_height,p_format,p_flags);
+	rasterizer->texture_allocate(p_texture, p_width, p_height, p_format, p_flags);
 }
 
-void VisualServerRaster::texture_set_flags(RID p_texture,uint32_t p_flags)  {
+void VisualServerRaster::texture_set_flags(RID p_texture, uint32_t p_flags) {
 
 	VS_CHANGED;
-	rasterizer->texture_set_flags(p_texture,p_flags);
+	rasterizer->texture_set_flags(p_texture, p_flags);
 }
 
-
-void VisualServerRaster::texture_set_data(RID p_texture,const Image& p_image,CubeMapSide p_cube_side) {
+void VisualServerRaster::texture_set_data(RID p_texture, const Image &p_image, CubeMapSide p_cube_side) {
 
 	VS_CHANGED;
-	rasterizer->texture_set_data(p_texture,p_image,p_cube_side);
-
-
+	rasterizer->texture_set_data(p_texture, p_image, p_cube_side);
 }
 
-Image VisualServerRaster::texture_get_data(RID p_texture,CubeMapSide p_cube_side) const {
-
+Image VisualServerRaster::texture_get_data(RID p_texture, CubeMapSide p_cube_side) const {
 
-	return rasterizer->texture_get_data(p_texture,p_cube_side);
+	return rasterizer->texture_get_data(p_texture, p_cube_side);
 }
 
-
 uint32_t VisualServerRaster::texture_get_flags(RID p_texture) const {
 
 	return rasterizer->texture_get_flags(p_texture);
-
 }
 Image::Format VisualServerRaster::texture_get_format(RID p_texture) const {
 
 	return rasterizer->texture_get_format(p_texture);
-
 }
 uint32_t VisualServerRaster::texture_get_width(RID p_texture) const {
 
@@ -97,9 +86,9 @@ uint32_t VisualServerRaster::texture_get_height(RID p_texture) const {
 	return rasterizer->texture_get_height(p_texture);
 }
 
-void VisualServerRaster::texture_set_size_override(RID p_texture,int p_width, int p_height) {
+void VisualServerRaster::texture_set_size_override(RID p_texture, int p_width, int p_height) {
 
-	rasterizer->texture_set_size_override(p_texture,p_width,p_height);
+	rasterizer->texture_set_size_override(p_texture, p_width, p_height);
 }
 
 bool VisualServerRaster::texture_can_stream(RID p_texture) const {
@@ -107,22 +96,22 @@ bool VisualServerRaster::texture_can_stream(RID p_texture) const {
 	return false;
 }
 
-void VisualServerRaster::texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName& p_function) const {
+void VisualServerRaster::texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function) const {
 
-	rasterizer->texture_set_reload_hook(p_texture,p_owner,p_function);
+	rasterizer->texture_set_reload_hook(p_texture, p_owner, p_function);
 }
 
-void VisualServerRaster::texture_set_path(RID p_texture,const String& p_path) {
+void VisualServerRaster::texture_set_path(RID p_texture, const String &p_path) {
 
-	rasterizer->texture_set_path(p_texture,p_path);
+	rasterizer->texture_set_path(p_texture, p_path);
 }
 
-String VisualServerRaster::texture_get_path(RID p_texture) const{
+String VisualServerRaster::texture_get_path(RID p_texture) const {
 
 	return rasterizer->texture_get_path(p_texture);
 }
 
-void VisualServerRaster::texture_debug_usage(List<TextureInfo> *r_info){
+void VisualServerRaster::texture_debug_usage(List<TextureInfo> *r_info) {
 
 	rasterizer->texture_debug_usage(r_info);
 }
@@ -139,55 +128,52 @@ RID VisualServerRaster::shader_create(ShaderMode p_mode) {
 	return rasterizer->shader_create(p_mode);
 }
 
-void VisualServerRaster::shader_set_mode(RID p_shader,ShaderMode p_mode){
+void VisualServerRaster::shader_set_mode(RID p_shader, ShaderMode p_mode) {
 
 	VS_CHANGED;
-	rasterizer->shader_set_mode(p_shader,p_mode);
+	rasterizer->shader_set_mode(p_shader, p_mode);
 }
-VisualServer::ShaderMode VisualServerRaster::shader_get_mode(RID p_shader) const{
+VisualServer::ShaderMode VisualServerRaster::shader_get_mode(RID p_shader) const {
 
 	return rasterizer->shader_get_mode(p_shader);
 }
 
-
-void VisualServerRaster::shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs,int p_fragment_ofs,int p_light_ofs) {
+void VisualServerRaster::shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs, int p_fragment_ofs, int p_light_ofs) {
 
 	VS_CHANGED;
-	rasterizer->shader_set_code(p_shader,p_vertex,p_fragment,p_light,p_vertex_ofs,p_fragment_ofs,p_light_ofs);
+	rasterizer->shader_set_code(p_shader, p_vertex, p_fragment, p_light, p_vertex_ofs, p_fragment_ofs, p_light_ofs);
 }
 
-String VisualServerRaster::shader_get_vertex_code(RID p_shader) const{
+String VisualServerRaster::shader_get_vertex_code(RID p_shader) const {
 
 	return rasterizer->shader_get_vertex_code(p_shader);
 }
 
-String VisualServerRaster::shader_get_fragment_code(RID p_shader) const{
+String VisualServerRaster::shader_get_fragment_code(RID p_shader) const {
 
 	return rasterizer->shader_get_fragment_code(p_shader);
 }
 
-String VisualServerRaster::shader_get_light_code(RID p_shader) const{
+String VisualServerRaster::shader_get_light_code(RID p_shader) const {
 
 	return rasterizer->shader_get_light_code(p_shader);
 }
 
 void VisualServerRaster::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
 
-	return rasterizer->shader_get_param_list(p_shader,p_param_list);
+	return rasterizer->shader_get_param_list(p_shader, p_param_list);
 }
 
+void VisualServerRaster::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
 
-void VisualServerRaster::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture) {
-
-	rasterizer->shader_set_default_texture_param(p_shader,p_name,p_texture);
+	rasterizer->shader_set_default_texture_param(p_shader, p_name, p_texture);
 }
 
-RID VisualServerRaster::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{
+RID VisualServerRaster::shader_get_default_texture_param(RID p_shader, const StringName &p_name) const {
 
-	return rasterizer->shader_get_default_texture_param(p_shader,p_name);
+	return rasterizer->shader_get_default_texture_param(p_shader, p_name);
 }
 
-
 /* Material */
 
 RID VisualServerRaster::material_create() {
@@ -198,7 +184,7 @@ RID VisualServerRaster::material_create() {
 void VisualServerRaster::material_set_shader(RID p_material, RID p_shader) {
 
 	VS_CHANGED;
-	rasterizer->material_set_shader(p_material, p_shader );
+	rasterizer->material_set_shader(p_material, p_shader);
 }
 
 RID VisualServerRaster::material_get_shader(RID p_material) const {
@@ -206,27 +192,26 @@ RID VisualServerRaster::material_get_shader(RID p_material) const {
 	return rasterizer->material_get_shader(p_material);
 }
 
-void VisualServerRaster::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value) {
+void VisualServerRaster::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
 
 	VS_CHANGED;
-	rasterizer->material_set_param(p_material, p_param,p_value );
+	rasterizer->material_set_param(p_material, p_param, p_value);
 }
 
-Variant VisualServerRaster::material_get_param(RID p_material, const StringName& p_param) const {
+Variant VisualServerRaster::material_get_param(RID p_material, const StringName &p_param) const {
 
-	return rasterizer->material_get_param(p_material,p_param);
+	return rasterizer->material_get_param(p_material, p_param);
 }
 
-void VisualServerRaster::material_set_flag(RID p_material, MaterialFlag p_flag,bool p_enabled) {
+void VisualServerRaster::material_set_flag(RID p_material, MaterialFlag p_flag, bool p_enabled) {
 	VS_CHANGED;
-	rasterizer->material_set_flag(p_material,p_flag,p_enabled);
+	rasterizer->material_set_flag(p_material, p_flag, p_enabled);
 }
 
 void VisualServerRaster::material_set_depth_draw_mode(RID p_material, MaterialDepthDrawMode p_mode) {
 
 	VS_CHANGED;
-	rasterizer->material_set_depth_draw_mode(p_material,p_mode);
-
+	rasterizer->material_set_depth_draw_mode(p_material, p_mode);
 }
 
 VS::MaterialDepthDrawMode VisualServerRaster::material_get_depth_draw_mode(RID p_material) const {
@@ -234,24 +219,23 @@ VS::MaterialDepthDrawMode VisualServerRaster::material_get_depth_draw_mode(RID p
 	return rasterizer->material_get_depth_draw_mode(p_material);
 }
 
+bool VisualServerRaster::material_get_flag(RID p_material, MaterialFlag p_flag) const {
 
-bool VisualServerRaster::material_get_flag(RID p_material,MaterialFlag p_flag) const {
-
-	return rasterizer->material_get_flag(p_material,p_flag);
+	return rasterizer->material_get_flag(p_material, p_flag);
 }
 
-void VisualServerRaster::material_set_blend_mode(RID p_material,MaterialBlendMode p_mode) {
+void VisualServerRaster::material_set_blend_mode(RID p_material, MaterialBlendMode p_mode) {
 	VS_CHANGED;
-	rasterizer->material_set_blend_mode(p_material,p_mode);
+	rasterizer->material_set_blend_mode(p_material, p_mode);
 }
 VS::MaterialBlendMode VisualServerRaster::material_get_blend_mode(RID p_material) const {
 
 	return rasterizer->material_get_blend_mode(p_material);
 }
 
-void VisualServerRaster::material_set_line_width(RID p_material,float p_line_width) {
+void VisualServerRaster::material_set_line_width(RID p_material, float p_line_width) {
 	VS_CHANGED;
-	rasterizer->material_set_line_width(p_material,p_line_width);
+	rasterizer->material_set_line_width(p_material, p_line_width);
 }
 float VisualServerRaster::material_get_line_width(RID p_material) const {
 
@@ -267,63 +251,58 @@ RID VisualServerRaster::fixed_material_create() {
 
 void VisualServerRaster::fixed_material_set_flag(RID p_material, FixedMaterialFlags p_flag, bool p_enabled) {
 
-	rasterizer->fixed_material_set_flag(p_material,p_flag,p_enabled);
+	rasterizer->fixed_material_set_flag(p_material, p_flag, p_enabled);
 }
 
 bool VisualServerRaster::fixed_material_get_flag(RID p_material, FixedMaterialFlags p_flag) const {
 
-	return rasterizer->fixed_material_get_flag(p_material,p_flag);
+	return rasterizer->fixed_material_get_flag(p_material, p_flag);
 }
 
-void VisualServerRaster::fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant& p_value) {
+void VisualServerRaster::fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant &p_value) {
 	VS_CHANGED;
-	rasterizer->fixed_material_set_parameter(p_material,p_parameter,p_value);
+	rasterizer->fixed_material_set_parameter(p_material, p_parameter, p_value);
 }
 
-Variant VisualServerRaster::fixed_material_get_param(RID p_material,FixedMaterialParam p_parameter) const {
+Variant VisualServerRaster::fixed_material_get_param(RID p_material, FixedMaterialParam p_parameter) const {
 
-	return rasterizer->fixed_material_get_parameter(p_material,p_parameter);
+	return rasterizer->fixed_material_get_parameter(p_material, p_parameter);
 }
 
-
-void VisualServerRaster::fixed_material_set_texture(RID p_material,FixedMaterialParam p_parameter, RID p_texture) {
+void VisualServerRaster::fixed_material_set_texture(RID p_material, FixedMaterialParam p_parameter, RID p_texture) {
 	VS_CHANGED;
-	rasterizer->fixed_material_set_texture(p_material,p_parameter,p_texture);
+	rasterizer->fixed_material_set_texture(p_material, p_parameter, p_texture);
 }
 
-RID VisualServerRaster::fixed_material_get_texture(RID p_material,FixedMaterialParam p_parameter) const {
+RID VisualServerRaster::fixed_material_get_texture(RID p_material, FixedMaterialParam p_parameter) const {
 
-	return rasterizer->fixed_material_get_texture(p_material,p_parameter);
+	return rasterizer->fixed_material_get_texture(p_material, p_parameter);
 }
 
-
-
-
-void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material,FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode) {
+void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material, FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode) {
 	VS_CHANGED;
-	rasterizer->fixed_material_set_texcoord_mode(p_material,p_parameter,p_mode);
+	rasterizer->fixed_material_set_texcoord_mode(p_material, p_parameter, p_mode);
 }
 
-VS::FixedMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material,FixedMaterialParam p_parameter) const {
+VS::FixedMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material, FixedMaterialParam p_parameter) const {
 
-	return rasterizer->fixed_material_get_texcoord_mode(p_material,p_parameter);
+	return rasterizer->fixed_material_get_texcoord_mode(p_material, p_parameter);
 }
 
-void VisualServerRaster::fixed_material_set_point_size(RID p_material,float p_size) {
+void VisualServerRaster::fixed_material_set_point_size(RID p_material, float p_size) {
 	VS_CHANGED
 
-	rasterizer->fixed_material_set_point_size(p_material,p_size);
+	rasterizer->fixed_material_set_point_size(p_material, p_size);
 }
 
-float VisualServerRaster::fixed_material_get_point_size(RID p_material) const{
+float VisualServerRaster::fixed_material_get_point_size(RID p_material) const {
 
 	return rasterizer->fixed_material_get_point_size(p_material);
 }
 
-
-void VisualServerRaster::fixed_material_set_uv_transform(RID p_material,const Transform& p_transform) {
+void VisualServerRaster::fixed_material_set_uv_transform(RID p_material, const Transform &p_transform) {
 	VS_CHANGED;
-	rasterizer->fixed_material_set_uv_transform(p_material,p_transform);
+	rasterizer->fixed_material_set_uv_transform(p_material, p_transform);
 }
 
 Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material) const {
@@ -331,20 +310,17 @@ Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material) co
 	return rasterizer->fixed_material_get_uv_transform(p_material);
 }
 
-void VisualServerRaster::fixed_material_set_light_shader(RID p_material,FixedMaterialLightShader p_shader) {
+void VisualServerRaster::fixed_material_set_light_shader(RID p_material, FixedMaterialLightShader p_shader) {
 
 	VS_CHANGED;
-	rasterizer->fixed_material_set_light_shader(p_material,p_shader);
-
+	rasterizer->fixed_material_set_light_shader(p_material, p_shader);
 }
 
-VisualServerRaster::FixedMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material) const{
+VisualServerRaster::FixedMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material) const {
 
 	return rasterizer->fixed_material_get_light_shader(p_material);
 }
 
-
-
 /* MESH API */
 
 RID VisualServerRaster::mesh_create() {
@@ -352,23 +328,21 @@ RID VisualServerRaster::mesh_create() {
 	return rasterizer->mesh_create();
 }
 
-void VisualServerRaster::mesh_set_morph_target_count(RID p_mesh,int p_amount) {
+void VisualServerRaster::mesh_set_morph_target_count(RID p_mesh, int p_amount) {
 
-	rasterizer->mesh_set_morph_target_count(p_mesh,p_amount);
+	rasterizer->mesh_set_morph_target_count(p_mesh, p_amount);
 	int amount = rasterizer->mesh_get_morph_target_count(p_mesh);
 
-
-	Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_mesh );
+	Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(p_mesh);
 
 	if (!E)
 		return;
 
-
 	Set<RID>::Element *I = E->get().front();
 
-	while(I) {
+	while (I) {
 
-		Instance *ins = instance_owner.get( I->get() );
+		Instance *ins = instance_owner.get(I->get());
 		ins->data.morph_values.resize(amount);
 		I = I->next();
 	}
@@ -379,95 +353,81 @@ int VisualServerRaster::mesh_get_morph_target_count(RID p_mesh) const {
 	return rasterizer->mesh_get_morph_target_count(p_mesh);
 }
 
-void VisualServerRaster::mesh_set_morph_target_mode(RID p_mesh,MorphTargetMode p_mode) {
+void VisualServerRaster::mesh_set_morph_target_mode(RID p_mesh, MorphTargetMode p_mode) {
 
-	rasterizer->mesh_set_morph_target_mode(p_mesh,p_mode);
+	rasterizer->mesh_set_morph_target_mode(p_mesh, p_mode);
 }
 
-VisualServer::MorphTargetMode VisualServerRaster::mesh_get_morph_target_mode(RID p_mesh) const{
+VisualServer::MorphTargetMode VisualServerRaster::mesh_get_morph_target_mode(RID p_mesh) const {
 
 	return rasterizer->mesh_get_morph_target_mode(p_mesh);
 }
 
-void VisualServerRaster::mesh_add_custom_surface(RID p_mesh,const Variant& p_dat) {
-
-
+void VisualServerRaster::mesh_add_custom_surface(RID p_mesh, const Variant &p_dat) {
 }
 
-
-void VisualServerRaster::mesh_add_surface(RID p_mesh,PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes,bool p_alpha_sort) {
+void VisualServerRaster::mesh_add_surface(RID p_mesh, PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes, bool p_alpha_sort) {
 
 	VS_CHANGED;
-	_dependency_queue_update(p_mesh,true,true);
-	rasterizer->mesh_add_surface(p_mesh,p_primitive,p_arrays,p_blend_shapes,p_alpha_sort);
-
+	_dependency_queue_update(p_mesh, true, true);
+	rasterizer->mesh_add_surface(p_mesh, p_primitive, p_arrays, p_blend_shapes, p_alpha_sort);
 }
 
-Array VisualServerRaster::mesh_get_surface_arrays(RID p_mesh,int p_surface) const {
+Array VisualServerRaster::mesh_get_surface_arrays(RID p_mesh, int p_surface) const {
 
-	return rasterizer->mesh_get_surface_arrays(p_mesh,p_surface);
+	return rasterizer->mesh_get_surface_arrays(p_mesh, p_surface);
 }
-Array VisualServerRaster::mesh_get_surface_morph_arrays(RID p_mesh,int p_surface) const {
+Array VisualServerRaster::mesh_get_surface_morph_arrays(RID p_mesh, int p_surface) const {
 
-	return rasterizer->mesh_get_surface_morph_arrays(p_mesh,p_surface);
+	return rasterizer->mesh_get_surface_morph_arrays(p_mesh, p_surface);
 }
 
-
-
-
-void VisualServerRaster::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material,bool p_owned){
+void VisualServerRaster::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned) {
 	VS_CHANGED;
-	rasterizer->mesh_surface_set_material(p_mesh,p_surface,p_material,p_owned);
+	rasterizer->mesh_surface_set_material(p_mesh, p_surface, p_material, p_owned);
 }
 
-RID VisualServerRaster::mesh_surface_get_material(RID p_mesh,int p_surface) const {
-
-	return rasterizer->mesh_surface_get_material(p_mesh,p_surface);
+RID VisualServerRaster::mesh_surface_get_material(RID p_mesh, int p_surface) const {
 
+	return rasterizer->mesh_surface_get_material(p_mesh, p_surface);
 }
 
+int VisualServerRaster::mesh_surface_get_array_len(RID p_mesh, int p_surface) const {
 
-int VisualServerRaster::mesh_surface_get_array_len(RID p_mesh, int p_surface) const{
-
-	return rasterizer->mesh_surface_get_array_len(p_mesh,p_surface);
+	return rasterizer->mesh_surface_get_array_len(p_mesh, p_surface);
 }
 
-int VisualServerRaster::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const{
-
+int VisualServerRaster::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const {
 
-	return rasterizer->mesh_surface_get_array_index_len(p_mesh,p_surface);
+	return rasterizer->mesh_surface_get_array_index_len(p_mesh, p_surface);
 }
 
-uint32_t VisualServerRaster::mesh_surface_get_format(RID p_mesh, int p_surface) const{
+uint32_t VisualServerRaster::mesh_surface_get_format(RID p_mesh, int p_surface) const {
 
-	return rasterizer->mesh_surface_get_format(p_mesh,p_surface);
+	return rasterizer->mesh_surface_get_format(p_mesh, p_surface);
 }
 
-VisualServer::PrimitiveType VisualServerRaster::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const{
+VisualServer::PrimitiveType VisualServerRaster::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const {
 
-	return rasterizer->mesh_surface_get_primitive_type(p_mesh,p_surface);
+	return rasterizer->mesh_surface_get_primitive_type(p_mesh, p_surface);
 }
 
+void VisualServerRaster::mesh_remove_surface(RID p_mesh, int p_surface) {
 
-void VisualServerRaster::mesh_remove_surface(RID p_mesh,int p_surface){
-
-	rasterizer->mesh_remove_surface(p_mesh,p_surface);
-	_dependency_queue_update(p_mesh,true,true);
+	rasterizer->mesh_remove_surface(p_mesh, p_surface);
+	_dependency_queue_update(p_mesh, true, true);
 }
 
-int VisualServerRaster::mesh_get_surface_count(RID p_mesh) const{
+int VisualServerRaster::mesh_get_surface_count(RID p_mesh) const {
 
 	return rasterizer->mesh_get_surface_count(p_mesh);
-
 }
 
-
-void VisualServerRaster::mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb) {
+void VisualServerRaster::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) {
 
 	VS_CHANGED;
-	_dependency_queue_update(p_mesh,true);
-	rasterizer->mesh_set_custom_aabb(p_mesh,p_aabb);
-
+	_dependency_queue_update(p_mesh, true);
+	rasterizer->mesh_set_custom_aabb(p_mesh, p_aabb);
 }
 
 AABB VisualServerRaster::mesh_get_custom_aabb(RID p_mesh) const {
@@ -478,14 +438,13 @@ AABB VisualServerRaster::mesh_get_custom_aabb(RID p_mesh) const {
 void VisualServerRaster::mesh_clear(RID p_mesh) {
 
 	ERR_FAIL_COND(!rasterizer->is_mesh(p_mesh));
-	while(rasterizer->mesh_get_surface_count(p_mesh)) {
-		rasterizer->mesh_remove_surface(p_mesh,0);
+	while (rasterizer->mesh_get_surface_count(p_mesh)) {
+		rasterizer->mesh_remove_surface(p_mesh, 0);
 	}
 
-	_dependency_queue_update(p_mesh,true,true);
+	_dependency_queue_update(p_mesh, true, true);
 }
 
-
 /* MULTIMESH */
 
 RID VisualServerRaster::multimesh_create() {
@@ -493,9 +452,9 @@ RID VisualServerRaster::multimesh_create() {
 	return rasterizer->multimesh_create();
 }
 
-void VisualServerRaster::multimesh_set_instance_count(RID p_multimesh,int p_count) {
+void VisualServerRaster::multimesh_set_instance_count(RID p_multimesh, int p_count) {
 	VS_CHANGED;
-	rasterizer->multimesh_set_instance_count(p_multimesh,p_count);
+	rasterizer->multimesh_set_instance_count(p_multimesh, p_count);
 }
 
 int VisualServerRaster::multimesh_get_instance_count(RID p_multimesh) const {
@@ -503,51 +462,45 @@ int VisualServerRaster::multimesh_get_instance_count(RID p_multimesh) const {
 	return rasterizer->multimesh_get_instance_count(p_multimesh);
 }
 
-void VisualServerRaster::multimesh_set_mesh(RID p_multimesh,RID p_mesh) {
+void VisualServerRaster::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
 	VS_CHANGED;
-	rasterizer->multimesh_set_mesh(p_multimesh,p_mesh);
-
+	rasterizer->multimesh_set_mesh(p_multimesh, p_mesh);
 }
-void VisualServerRaster::multimesh_set_aabb(RID p_multimesh,const AABB& p_aabb) {
+void VisualServerRaster::multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb) {
 	VS_CHANGED;
-	rasterizer->multimesh_set_aabb(p_multimesh,p_aabb);
-	_dependency_queue_update(p_multimesh,true);
-
+	rasterizer->multimesh_set_aabb(p_multimesh, p_aabb);
+	_dependency_queue_update(p_multimesh, true);
 }
 
-void VisualServerRaster::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform) {
+void VisualServerRaster::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) {
 	VS_CHANGED;
-	rasterizer->multimesh_instance_set_transform(p_multimesh,p_index,p_transform);
-
+	rasterizer->multimesh_instance_set_transform(p_multimesh, p_index, p_transform);
 }
-void VisualServerRaster::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color) {
+void VisualServerRaster::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
 	VS_CHANGED;
-	rasterizer->multimesh_instance_set_color(p_multimesh,p_index,p_color);
-
+	rasterizer->multimesh_instance_set_color(p_multimesh, p_index, p_color);
 }
 RID VisualServerRaster::multimesh_get_mesh(RID p_multimesh) const {
 
 	return rasterizer->multimesh_get_mesh(p_multimesh);
 }
-AABB VisualServerRaster::multimesh_get_aabb(RID p_multimesh,const AABB& p_aabb) const {
-
+AABB VisualServerRaster::multimesh_get_aabb(RID p_multimesh, const AABB &p_aabb) const {
 
 	return rasterizer->multimesh_get_aabb(p_multimesh);
 }
 
-Transform VisualServerRaster::multimesh_instance_get_transform(RID p_multimesh,int p_index) const {
+Transform VisualServerRaster::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
 
-	return rasterizer->multimesh_instance_get_transform(p_multimesh,p_index);
+	return rasterizer->multimesh_instance_get_transform(p_multimesh, p_index);
 }
-Color VisualServerRaster::multimesh_instance_get_color(RID p_multimesh,int p_index) const {
+Color VisualServerRaster::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
 
-	return rasterizer->multimesh_instance_get_color(p_multimesh,p_index);
+	return rasterizer->multimesh_instance_get_color(p_multimesh, p_index);
 }
 
-void VisualServerRaster::multimesh_set_visible_instances(RID p_multimesh,int p_visible) {
-
-	rasterizer->multimesh_set_visible_instances(p_multimesh,p_visible);
+void VisualServerRaster::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
 
+	rasterizer->multimesh_set_visible_instances(p_multimesh, p_visible);
 }
 
 int VisualServerRaster::multimesh_get_visible_instances(RID p_multimesh) const {
@@ -555,67 +508,57 @@ int VisualServerRaster::multimesh_get_visible_instances(RID p_multimesh) const {
 	return rasterizer->multimesh_get_visible_instances(p_multimesh);
 }
 
-
 /* IMMEDIATE API */
 
-
 RID VisualServerRaster::immediate_create() {
 
 	return rasterizer->immediate_create();
 }
 
-void VisualServerRaster::immediate_begin(RID p_immediate,PrimitiveType p_primitive,RID p_texture){
+void VisualServerRaster::immediate_begin(RID p_immediate, PrimitiveType p_primitive, RID p_texture) {
 
-	rasterizer->immediate_begin(p_immediate,p_primitive,p_texture);
+	rasterizer->immediate_begin(p_immediate, p_primitive, p_texture);
 }
-void VisualServerRaster::immediate_vertex(RID p_immediate,const Vector3& p_vertex){
-
-	rasterizer->immediate_vertex(p_immediate,p_vertex);
+void VisualServerRaster::immediate_vertex(RID p_immediate, const Vector3 &p_vertex) {
 
+	rasterizer->immediate_vertex(p_immediate, p_vertex);
 }
-void VisualServerRaster::immediate_normal(RID p_immediate,const Vector3& p_normal){
-
-	rasterizer->immediate_normal(p_immediate,p_normal);
+void VisualServerRaster::immediate_normal(RID p_immediate, const Vector3 &p_normal) {
 
+	rasterizer->immediate_normal(p_immediate, p_normal);
 }
-void VisualServerRaster::immediate_tangent(RID p_immediate,const Plane& p_tangent){
-
-	rasterizer->immediate_tangent(p_immediate,p_tangent);
+void VisualServerRaster::immediate_tangent(RID p_immediate, const Plane &p_tangent) {
 
+	rasterizer->immediate_tangent(p_immediate, p_tangent);
 }
-void VisualServerRaster::immediate_color(RID p_immediate,const Color& p_color){
-
-	rasterizer->immediate_color(p_immediate,p_color);
+void VisualServerRaster::immediate_color(RID p_immediate, const Color &p_color) {
 
+	rasterizer->immediate_color(p_immediate, p_color);
 }
-void VisualServerRaster::immediate_uv(RID p_immediate,const Vector2& p_uv){
-
-	rasterizer->immediate_uv(p_immediate,p_uv);
+void VisualServerRaster::immediate_uv(RID p_immediate, const Vector2 &p_uv) {
 
+	rasterizer->immediate_uv(p_immediate, p_uv);
 }
-void VisualServerRaster::immediate_uv2(RID p_immediate,const Vector2& p_uv2){
-
-	rasterizer->immediate_uv2(p_immediate,p_uv2);
+void VisualServerRaster::immediate_uv2(RID p_immediate, const Vector2 &p_uv2) {
 
+	rasterizer->immediate_uv2(p_immediate, p_uv2);
 }
-void VisualServerRaster::immediate_end(RID p_immediate){
+void VisualServerRaster::immediate_end(RID p_immediate) {
 
 	VS_CHANGED;
-	_dependency_queue_update(p_immediate,true);
+	_dependency_queue_update(p_immediate, true);
 	rasterizer->immediate_end(p_immediate);
-
 }
-void VisualServerRaster::immediate_clear(RID p_immediate){
+void VisualServerRaster::immediate_clear(RID p_immediate) {
 
 	VS_CHANGED;
-	_dependency_queue_update(p_immediate,true);
+	_dependency_queue_update(p_immediate, true);
 	rasterizer->immediate_clear(p_immediate);
-
 }
 
-void VisualServerRaster::immediate_set_material(RID p_immediate,RID p_material) {
+void VisualServerRaster::immediate_set_material(RID p_immediate, RID p_material) {
 
-	rasterizer->immediate_set_material(p_immediate,p_material);
+	rasterizer->immediate_set_material(p_immediate, p_material);
 }
 
 RID VisualServerRaster::immediate_get_material(RID p_immediate) const {
@@ -623,7 +566,6 @@ RID VisualServerRaster::immediate_get_material(RID p_immediate) const {
 	return rasterizer->immediate_get_material(p_immediate);
 }
 
-
 /* PARTICLES API */
 
 RID VisualServerRaster::particles_create() {
@@ -633,7 +575,7 @@ RID VisualServerRaster::particles_create() {
 
 void VisualServerRaster::particles_set_amount(RID p_particles, int p_amount) {
 	VS_CHANGED;
-	rasterizer->particles_set_amount(p_particles,p_amount);
+	rasterizer->particles_set_amount(p_particles, p_amount);
 }
 
 int VisualServerRaster::particles_get_amount(RID p_particles) const {
@@ -643,14 +585,14 @@ int VisualServerRaster::particles_get_amount(RID p_particles) const {
 
 void VisualServerRaster::particles_set_emitting(RID p_particles, bool p_emitting) {
 	VS_CHANGED;
-	rasterizer->particles_set_emitting(p_particles,p_emitting);
+	rasterizer->particles_set_emitting(p_particles, p_emitting);
 }
 bool VisualServerRaster::particles_is_emitting(RID p_particles) const {
 
 	return rasterizer->particles_is_emitting(p_particles);
 }
 
-void VisualServerRaster::particles_set_visibility_aabb(RID p_particles, const AABB& p_visibility) {
+void VisualServerRaster::particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility) {
 	VS_CHANGED;
 	rasterizer->particles_set_visibility_aabb(p_particles, p_visibility);
 }
@@ -659,28 +601,28 @@ AABB VisualServerRaster::particles_get_visibility_aabb(RID p_particles) const {
 	return rasterizer->particles_get_visibility_aabb(p_particles);
 }
 
-void VisualServerRaster::particles_set_emission_half_extents(RID p_particles, const Vector3& p_half_extents) {
+void VisualServerRaster::particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents) {
 	VS_CHANGED;
-	rasterizer->particles_set_emission_half_extents(p_particles,p_half_extents);
+	rasterizer->particles_set_emission_half_extents(p_particles, p_half_extents);
 }
 Vector3 VisualServerRaster::particles_get_emission_half_extents(RID p_particles) const {
 
 	return rasterizer->particles_get_emission_half_extents(p_particles);
 }
 
-void VisualServerRaster::particles_set_emission_base_velocity(RID p_particles, const Vector3& p_base_velocity) {
+void VisualServerRaster::particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity) {
 	VS_CHANGED;
-	rasterizer->particles_set_emission_base_velocity(p_particles,p_base_velocity);
+	rasterizer->particles_set_emission_base_velocity(p_particles, p_base_velocity);
 }
 Vector3 VisualServerRaster::particles_get_emission_base_velocity(RID p_particles) const {
 
 	return rasterizer->particles_get_emission_base_velocity(p_particles);
 }
 
-void VisualServerRaster::particles_set_emission_points(RID p_particles, const DVector<Vector3>& p_points) {
+void VisualServerRaster::particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points) {
 
 	VS_CHANGED;
-	rasterizer->particles_set_emission_points(p_particles,p_points);
+	rasterizer->particles_set_emission_points(p_particles, p_points);
 }
 
 DVector<Vector3> VisualServerRaster::particles_get_emission_points(RID p_particles) const {
@@ -688,36 +630,36 @@ DVector<Vector3> VisualServerRaster::particles_get_emission_points(RID p_particl
 	return rasterizer->particles_get_emission_points(p_particles);
 }
 
-void VisualServerRaster::particles_set_gravity_normal(RID p_particles, const Vector3& p_normal) {
+void VisualServerRaster::particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal) {
 	VS_CHANGED;
-	rasterizer->particles_set_gravity_normal(p_particles,p_normal);
+	rasterizer->particles_set_gravity_normal(p_particles, p_normal);
 }
 Vector3 VisualServerRaster::particles_get_gravity_normal(RID p_particles) const {
 
 	return rasterizer->particles_get_gravity_normal(p_particles);
 }
 
-void VisualServerRaster::particles_set_variable(RID p_particles, ParticleVariable p_variable,float p_value) {
+void VisualServerRaster::particles_set_variable(RID p_particles, ParticleVariable p_variable, float p_value) {
 	VS_CHANGED;
-	rasterizer->particles_set_variable(p_particles,p_variable,p_value);
+	rasterizer->particles_set_variable(p_particles, p_variable, p_value);
 }
 float VisualServerRaster::particles_get_variable(RID p_particles, ParticleVariable p_variable) const {
 
-	return rasterizer->particles_get_variable(p_particles,p_variable);
+	return rasterizer->particles_get_variable(p_particles, p_variable);
 }
 
-void VisualServerRaster::particles_set_randomness(RID p_particles, ParticleVariable p_variable,float p_randomness) {
+void VisualServerRaster::particles_set_randomness(RID p_particles, ParticleVariable p_variable, float p_randomness) {
 	VS_CHANGED;
-	rasterizer->particles_set_randomness(p_particles,p_variable,p_randomness);
+	rasterizer->particles_set_randomness(p_particles, p_variable, p_randomness);
 }
 float VisualServerRaster::particles_get_randomness(RID p_particles, ParticleVariable p_variable) const {
 
-	return rasterizer->particles_get_randomness(p_particles,p_variable);
+	return rasterizer->particles_get_randomness(p_particles, p_variable);
 }
 
 void VisualServerRaster::particles_set_color_phases(RID p_particles, int p_phases) {
 	VS_CHANGED;
-	rasterizer->particles_set_color_phases(p_particles,p_phases);
+	rasterizer->particles_set_color_phases(p_particles, p_phases);
 }
 int VisualServerRaster::particles_get_color_phases(RID p_particles) const {
 
@@ -726,65 +668,63 @@ int VisualServerRaster::particles_get_color_phases(RID p_particles) const {
 
 void VisualServerRaster::particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos) {
 	VS_CHANGED;
-	rasterizer->particles_set_color_phase_pos(p_particles,p_phase,p_pos);
+	rasterizer->particles_set_color_phase_pos(p_particles, p_phase, p_pos);
 }
 float VisualServerRaster::particles_get_color_phase_pos(RID p_particles, int p_phase) const {
 
-	return rasterizer->particles_get_color_phase_pos(p_particles,p_phase);
+	return rasterizer->particles_get_color_phase_pos(p_particles, p_phase);
 }
 
 void VisualServerRaster::particles_set_attractors(RID p_particles, int p_attractors) {
 	VS_CHANGED;
-	rasterizer->particles_set_attractors(p_particles,p_attractors);
+	rasterizer->particles_set_attractors(p_particles, p_attractors);
 }
 int VisualServerRaster::particles_get_attractors(RID p_particles) const {
 
 	return rasterizer->particles_get_attractors(p_particles);
 }
 
-void VisualServerRaster::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3& p_pos) {
+void VisualServerRaster::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos) {
 	VS_CHANGED;
-	rasterizer->particles_set_attractor_pos(p_particles,p_attractor,p_pos);
+	rasterizer->particles_set_attractor_pos(p_particles, p_attractor, p_pos);
 }
-Vector3 VisualServerRaster::particles_get_attractor_pos(RID p_particles,int p_attractor) const {
+Vector3 VisualServerRaster::particles_get_attractor_pos(RID p_particles, int p_attractor) const {
 
-	return rasterizer->particles_get_attractor_pos(p_particles,p_attractor);
+	return rasterizer->particles_get_attractor_pos(p_particles, p_attractor);
 }
 
 void VisualServerRaster::particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force) {
 	VS_CHANGED;
-	rasterizer->particles_set_attractor_strength(p_particles,p_attractor,p_force);
+	rasterizer->particles_set_attractor_strength(p_particles, p_attractor, p_force);
 }
 
-float VisualServerRaster::particles_get_attractor_strength(RID p_particles,int p_attractor) const {
+float VisualServerRaster::particles_get_attractor_strength(RID p_particles, int p_attractor) const {
 
-	return rasterizer->particles_get_attractor_strength(p_particles,p_attractor);
+	return rasterizer->particles_get_attractor_strength(p_particles, p_attractor);
 }
 
-void VisualServerRaster::particles_set_color_phase_color(RID p_particles, int p_phase, const Color& p_color) {
+void VisualServerRaster::particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color) {
 	VS_CHANGED;
-	rasterizer->particles_set_color_phase_color(p_particles,p_phase,p_color);
+	rasterizer->particles_set_color_phase_color(p_particles, p_phase, p_color);
 }
 Color VisualServerRaster::particles_get_color_phase_color(RID p_particles, int p_phase) const {
 
-	return rasterizer->particles_get_color_phase_color(p_particles,p_phase);
+	return rasterizer->particles_get_color_phase_color(p_particles, p_phase);
 }
 
-void VisualServerRaster::particles_set_material(RID p_particles, RID p_material,bool p_owned) {
+void VisualServerRaster::particles_set_material(RID p_particles, RID p_material, bool p_owned) {
 	VS_CHANGED;
-	rasterizer->particles_set_material(p_particles,p_material,p_owned);
+	rasterizer->particles_set_material(p_particles, p_material, p_owned);
 }
 RID VisualServerRaster::particles_get_material(RID p_particles) const {
 
 	return rasterizer->particles_get_material(p_particles);
 }
 
-
 void VisualServerRaster::particles_set_height_from_velocity(RID p_particles, bool p_enable) {
 
 	VS_CHANGED;
-	rasterizer->particles_set_height_from_velocity(p_particles,p_enable);
-
+	rasterizer->particles_set_height_from_velocity(p_particles, p_enable);
 }
 
 bool VisualServerRaster::particles_has_height_from_velocity(RID p_particles) const {
@@ -794,7 +734,7 @@ bool VisualServerRaster::particles_has_height_from_velocity(RID p_particles) con
 
 void VisualServerRaster::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
 
-	rasterizer->particles_set_use_local_coordinates(p_particles,p_enable);
+	rasterizer->particles_set_use_local_coordinates(p_particles, p_enable);
 }
 
 bool VisualServerRaster::particles_is_using_local_coordinates(RID p_particles) const {
@@ -802,7 +742,6 @@ bool VisualServerRaster::particles_is_using_local_coordinates(RID p_particles) c
 	return rasterizer->particles_is_using_local_coordinates(p_particles);
 }
 
-
 /* Light API */
 
 RID VisualServerRaster::light_create(LightType p_type) {
@@ -814,21 +753,18 @@ VisualServer::LightType VisualServerRaster::light_get_type(RID p_light) const {
 	return rasterizer->light_get_type(p_light);
 }
 
-void VisualServerRaster::light_set_color(RID p_light,LightColor p_type, const Color& p_color) {
+void VisualServerRaster::light_set_color(RID p_light, LightColor p_type, const Color &p_color) {
 	VS_CHANGED;
-	rasterizer->light_set_color(p_light,p_type,p_color);
-
+	rasterizer->light_set_color(p_light, p_type, p_color);
 }
-Color VisualServerRaster::light_get_color(RID p_light,LightColor p_type) const {
-
-	return rasterizer->light_get_color(p_light,p_type);
+Color VisualServerRaster::light_get_color(RID p_light, LightColor p_type) const {
 
+	return rasterizer->light_get_color(p_light, p_type);
 }
 
-
-void VisualServerRaster::light_set_shadow(RID p_light,bool p_enabled) {
+void VisualServerRaster::light_set_shadow(RID p_light, bool p_enabled) {
 	VS_CHANGED;
-	rasterizer->light_set_shadow(p_light,p_enabled);
+	rasterizer->light_set_shadow(p_light, p_enabled);
 }
 
 bool VisualServerRaster::light_has_shadow(RID p_light) const {
@@ -836,11 +772,9 @@ bool VisualServerRaster::light_has_shadow(RID p_light) const {
 	return rasterizer->light_has_shadow(p_light);
 }
 
-
-
-void VisualServerRaster::light_set_volumetric(RID p_light,bool p_enabled) {
+void VisualServerRaster::light_set_volumetric(RID p_light, bool p_enabled) {
 	VS_CHANGED;
-	rasterizer->light_set_volumetric(p_light,p_enabled);
+	rasterizer->light_set_volumetric(p_light, p_enabled);
 }
 
 bool VisualServerRaster::light_is_volumetric(RID p_light) const {
@@ -848,9 +782,9 @@ bool VisualServerRaster::light_is_volumetric(RID p_light) const {
 	return rasterizer->light_is_volumetric(p_light);
 }
 
-void VisualServerRaster::light_set_projector(RID p_light,RID p_texture) {
+void VisualServerRaster::light_set_projector(RID p_light, RID p_texture) {
 	VS_CHANGED;
-	rasterizer->light_set_projector(p_light,p_texture);
+	rasterizer->light_set_projector(p_light, p_texture);
 }
 
 RID VisualServerRaster::light_get_projector(RID p_light) const {
@@ -860,20 +794,18 @@ RID VisualServerRaster::light_get_projector(RID p_light) const {
 
 void VisualServerRaster::light_set_param(RID p_light, LightParam p_var, float p_value) {
 	VS_CHANGED;
-	rasterizer->light_set_var(p_light,p_var,p_value);
-	_dependency_queue_update(p_light,true);
-
+	rasterizer->light_set_var(p_light, p_var, p_value);
+	_dependency_queue_update(p_light, true);
 }
 
 float VisualServerRaster::light_get_param(RID p_light, LightParam p_var) const {
 
-
-	return rasterizer->light_get_var(p_light,p_var);
+	return rasterizer->light_get_var(p_light, p_var);
 }
 
-void VisualServerRaster::light_set_operator(RID p_light,LightOp p_op) {
+void VisualServerRaster::light_set_operator(RID p_light, LightOp p_op) {
 	VS_CHANGED;
-	rasterizer->light_set_operator(p_light,p_op);
+	rasterizer->light_set_operator(p_light, p_op);
 }
 
 VisualServerRaster::LightOp VisualServerRaster::light_get_operator(RID p_light) const {
@@ -881,9 +813,9 @@ VisualServerRaster::LightOp VisualServerRaster::light_get_operator(RID p_light)
 	return rasterizer->light_get_operator(p_light);
 }
 
-void VisualServerRaster::light_omni_set_shadow_mode(RID p_light,LightOmniShadowMode p_mode) {
+void VisualServerRaster::light_omni_set_shadow_mode(RID p_light, LightOmniShadowMode p_mode) {
 	VS_CHANGED;
-	rasterizer->light_omni_set_shadow_mode(p_light,p_mode);
+	rasterizer->light_omni_set_shadow_mode(p_light, p_mode);
 }
 
 VisualServerRaster::LightOmniShadowMode VisualServerRaster::light_omni_get_shadow_mode(RID p_light) const {
@@ -891,35 +823,34 @@ VisualServerRaster::LightOmniShadowMode VisualServerRaster::light_omni_get_shado
 	return rasterizer->light_omni_get_shadow_mode(p_light);
 }
 
-void VisualServerRaster::light_directional_set_shadow_mode(RID p_light,LightDirectionalShadowMode p_mode){
+void VisualServerRaster::light_directional_set_shadow_mode(RID p_light, LightDirectionalShadowMode p_mode) {
 	VS_CHANGED;
-	rasterizer->light_directional_set_shadow_mode(p_light,p_mode);
+	rasterizer->light_directional_set_shadow_mode(p_light, p_mode);
 }
 
-VS::LightDirectionalShadowMode VisualServerRaster::light_directional_get_shadow_mode(RID p_light) const{
+VS::LightDirectionalShadowMode VisualServerRaster::light_directional_get_shadow_mode(RID p_light) const {
 
 	return rasterizer->light_directional_get_shadow_mode(p_light);
 }
 
-void VisualServerRaster::light_directional_set_shadow_param(RID p_light,LightDirectionalShadowParam p_param, float p_value) {
+void VisualServerRaster::light_directional_set_shadow_param(RID p_light, LightDirectionalShadowParam p_param, float p_value) {
 	VS_CHANGED;
-	rasterizer->light_directional_set_shadow_param(p_light,p_param,p_value);
+	rasterizer->light_directional_set_shadow_param(p_light, p_param, p_value);
 }
 
-float VisualServerRaster::light_directional_get_shadow_param(RID p_light,LightDirectionalShadowParam p_param) const {
+float VisualServerRaster::light_directional_get_shadow_param(RID p_light, LightDirectionalShadowParam p_param) const {
 
-	return rasterizer->light_directional_get_shadow_param(p_light,p_param);
+	return rasterizer->light_directional_get_shadow_param(p_light, p_param);
 }
 
-
 RID VisualServerRaster::skeleton_create() {
 
 	return rasterizer->skeleton_create();
 }
 
-void VisualServerRaster::skeleton_resize(RID p_skeleton,int p_bones) {
+void VisualServerRaster::skeleton_resize(RID p_skeleton, int p_bones) {
 	VS_CHANGED;
-	rasterizer->skeleton_resize(p_skeleton,p_bones);
+	rasterizer->skeleton_resize(p_skeleton, p_bones);
 }
 
 int VisualServerRaster::skeleton_get_bone_count(RID p_skeleton) const {
@@ -927,48 +858,43 @@ int VisualServerRaster::skeleton_get_bone_count(RID p_skeleton) const {
 	return rasterizer->skeleton_get_bone_count(p_skeleton);
 }
 
-void VisualServerRaster::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform) {
+void VisualServerRaster::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) {
 	VS_CHANGED;
-	rasterizer->skeleton_bone_set_transform(p_skeleton,p_bone,p_transform);
+	rasterizer->skeleton_bone_set_transform(p_skeleton, p_bone, p_transform);
 
-	Map< RID, Set<Instance*> >::Element *E=skeleton_dependency_map.find(p_skeleton);
+	Map<RID, Set<Instance *> >::Element *E = skeleton_dependency_map.find(p_skeleton);
 
 	if (E) {
 		//detach skeletons
-		for (Set<Instance*>::Element *F=E->get().front();F;F=F->next()) {
+		for (Set<Instance *>::Element *F = E->get().front(); F; F = F->next()) {
 
-			_instance_queue_update( F->get() , true);
+			_instance_queue_update(F->get(), true);
 		}
 	}
 }
 
-Transform VisualServerRaster::skeleton_bone_get_transform(RID p_skeleton,int p_bone) {
-
-
-	return rasterizer->skeleton_bone_get_transform(p_skeleton,p_bone);
+Transform VisualServerRaster::skeleton_bone_get_transform(RID p_skeleton, int p_bone) {
 
+	return rasterizer->skeleton_bone_get_transform(p_skeleton, p_bone);
 }
 
-
 /* VISIBILITY API */
 
 /* ROOM API */
 
 RID VisualServerRaster::room_create() {
 
-	Room *room = memnew( Room );
-	ERR_FAIL_COND_V(!room,RID());
-	return room_owner.make_rid( room );
-
+	Room *room = memnew(Room);
+	ERR_FAIL_COND_V(!room, RID());
+	return room_owner.make_rid(room);
 }
 
-void VisualServerRaster::room_set_bounds(RID p_room, const BSP_Tree& p_bounds) {
+void VisualServerRaster::room_set_bounds(RID p_room, const BSP_Tree &p_bounds) {
 	VS_CHANGED;
 	Room *room = room_owner.get(p_room);
 	ERR_FAIL_COND(!room);
-	room->bounds=p_bounds;
-	_dependency_queue_update(p_room,true);
-
+	room->bounds = p_bounds;
+	_dependency_queue_update(p_room, true);
 }
 
 BSP_Tree VisualServerRaster::room_get_bounds(RID p_room) const {
@@ -976,56 +902,48 @@ BSP_Tree VisualServerRaster::room_get_bounds(RID p_room) const {
 	Room *room = room_owner.get(p_room);
 	ERR_FAIL_COND_V(!room, BSP_Tree());
 	return room->bounds;
-
 }
 
 /* PORTAL API */
 
 RID VisualServerRaster::portal_create() {
 	VS_CHANGED;
-	Portal *portal = memnew( Portal );
-	ERR_FAIL_COND_V(!portal,RID());
-	return portal_owner.make_rid( portal );
-
-
+	Portal *portal = memnew(Portal);
+	ERR_FAIL_COND_V(!portal, RID());
+	return portal_owner.make_rid(portal);
 }
 
-
-void VisualServerRaster::portal_set_shape(RID p_portal, const Vector<Point2>& p_shape) {
+void VisualServerRaster::portal_set_shape(RID p_portal, const Vector<Point2> &p_shape) {
 	VS_CHANGED;
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND(!portal);
-	portal->shape=p_shape;
+	portal->shape = p_shape;
 
-	portal->bounds=Rect2();
+	portal->bounds = Rect2();
 
-	for(int i=0;i<p_shape.size();i++) {
+	for (int i = 0; i < p_shape.size(); i++) {
 
-		if (i==0)
-			portal->bounds.pos=p_shape[i];
+		if (i == 0)
+			portal->bounds.pos = p_shape[i];
 		else
 			portal->bounds.expand_to(p_shape[i]);
 	}
 
-	_dependency_queue_update(p_portal,true);
+	_dependency_queue_update(p_portal, true);
 }
 
-
 Vector<Point2> VisualServerRaster::portal_get_shape(RID p_portal) const {
 
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND_V(!portal, Vector<Point2>());
 	return portal->shape;
-
-
 }
 
 void VisualServerRaster::portal_set_enabled(RID p_portal, bool p_enabled) {
 	VS_CHANGED;
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND(!portal);
-	portal->enabled=p_enabled;
-
+	portal->enabled = p_enabled;
 }
 
 bool VisualServerRaster::portal_is_enabled(RID p_portal) const {
@@ -1033,28 +951,24 @@ bool VisualServerRaster::portal_is_enabled(RID p_portal) const {
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND_V(!portal, false);
 	return portal->enabled;
-
 }
 void VisualServerRaster::portal_set_disable_distance(RID p_portal, float p_distance) {
 	VS_CHANGED;
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND(!portal);
-	portal->disable_distance=p_distance;
-
+	portal->disable_distance = p_distance;
 }
 float VisualServerRaster::portal_get_disable_distance(RID p_portal) const {
 
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND_V(!portal, -1);
 	return portal->disable_distance;
-
 }
-void VisualServerRaster::portal_set_disabled_color(RID p_portal, const Color& p_color) {
+void VisualServerRaster::portal_set_disabled_color(RID p_portal, const Color &p_color) {
 	VS_CHANGED;
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND(!portal);
-	portal->disable_color=p_color;
-
+	portal->disable_color = p_color;
 }
 Color VisualServerRaster::portal_get_disabled_color(RID p_portal) const {
 
@@ -1067,88 +981,80 @@ void VisualServerRaster::portal_set_connect_range(RID p_portal, float p_range) {
 	VS_CHANGED;
 	Portal *portal = portal_owner.get(p_portal);
 	ERR_FAIL_COND(!portal);
-	portal->connect_range=p_range;
-	_dependency_queue_update(p_portal,true);
+	portal->connect_range = p_range;
+	_dependency_queue_update(p_portal, true);
 }
 
 float VisualServerRaster::portal_get_connect_range(RID p_portal) const {
 
 	Portal *portal = portal_owner.get(p_portal);
-	ERR_FAIL_COND_V(!portal,0);
+	ERR_FAIL_COND_V(!portal, 0);
 	return portal->connect_range;
 }
 
-
 RID VisualServerRaster::baked_light_create() {
 
-	BakedLight *baked_light = memnew( BakedLight );
-	ERR_FAIL_COND_V(!baked_light,RID());
-	baked_light->data.mode=BAKED_LIGHT_OCTREE;
+	BakedLight *baked_light = memnew(BakedLight);
+	ERR_FAIL_COND_V(!baked_light, RID());
+	baked_light->data.mode = BAKED_LIGHT_OCTREE;
 
-	baked_light->data.octree_lattice_size=0;
-	baked_light->data.octree_lattice_divide=0;
-	baked_light->data.octree_steps=1;
-	baked_light->data.lightmap_multiplier=1.0;
-	baked_light->data.realtime_color_enabled=false;
-	baked_light->data.realtime_color=Color(1.0, 1.0, 1.0);
+	baked_light->data.octree_lattice_size = 0;
+	baked_light->data.octree_lattice_divide = 0;
+	baked_light->data.octree_steps = 1;
+	baked_light->data.lightmap_multiplier = 1.0;
+	baked_light->data.realtime_color_enabled = false;
+	baked_light->data.realtime_color = Color(1.0, 1.0, 1.0);
 	baked_light->data.realtime_energy = 1.0;
 
-	return baked_light_owner.make_rid( baked_light );
-
+	return baked_light_owner.make_rid(baked_light);
 }
 
-void VisualServerRaster::baked_light_set_mode(RID p_baked_light,BakedLightMode p_mode){
+void VisualServerRaster::baked_light_set_mode(RID p_baked_light, BakedLightMode p_mode) {
 
 	VS_CHANGED;
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
-	baked_light->data.mode=p_mode;
-	baked_light->data.color_multiplier=1.0;
-	_dependency_queue_update(p_baked_light,true);
-
-
+	baked_light->data.mode = p_mode;
+	baked_light->data.color_multiplier = 1.0;
+	_dependency_queue_update(p_baked_light, true);
 }
 
-VisualServer::BakedLightMode VisualServerRaster::baked_light_get_mode(RID p_baked_light) const{
+VisualServer::BakedLightMode VisualServerRaster::baked_light_get_mode(RID p_baked_light) const {
 
 	const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
-	ERR_FAIL_COND_V(!baked_light,BAKED_LIGHT_OCTREE);
+	ERR_FAIL_COND_V(!baked_light, BAKED_LIGHT_OCTREE);
 	return baked_light->data.mode;
-
 }
 
-void VisualServerRaster::baked_light_set_lightmap_multiplier(RID p_baked_light,float p_multiplier) {
+void VisualServerRaster::baked_light_set_lightmap_multiplier(RID p_baked_light, float p_multiplier) {
 
 	VS_CHANGED;
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
 
-	baked_light->data.lightmap_multiplier=p_multiplier;
-
+	baked_light->data.lightmap_multiplier = p_multiplier;
 }
 
-float VisualServerRaster::baked_light_get_lightmap_multiplier(RID p_baked_light) const{
+float VisualServerRaster::baked_light_get_lightmap_multiplier(RID p_baked_light) const {
 
 	const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
-	ERR_FAIL_COND_V(!baked_light,0);
+	ERR_FAIL_COND_V(!baked_light, 0);
 
 	return baked_light->data.lightmap_multiplier;
-
 }
 
-
-void VisualServerRaster::baked_light_set_octree(RID p_baked_light,const DVector<uint8_t> p_octree){
+void VisualServerRaster::baked_light_set_octree(RID p_baked_light, const DVector<uint8_t> p_octree) {
 
 	VS_CHANGED;
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
 
-	if (p_octree.size()==0) {
+	if (p_octree.size() == 0) {
 		if (baked_light->data.octree_texture.is_valid())
 			rasterizer->free(baked_light->data.octree_texture);
-		baked_light->data.octree_texture=RID();
-		baked_light->octree_aabb=AABB();
-		baked_light->octree_tex_size=Size2();
+		baked_light->data.octree_texture = RID();
+		baked_light->octree_aabb = AABB();
+		baked_light->octree_tex_size = Size2();
 	} else {
 
 		int tex_w;
@@ -1156,99 +1062,88 @@ void VisualServerRaster::baked_light_set_octree(RID p_baked_light,const DVector<
 		int light_tex_w;
 		int light_tex_h;
 		bool is16;
-		bool has_light_tex=false;
+		bool has_light_tex = false;
 		{
 
-			DVector<uint8_t>::Read r=p_octree.read();
+			DVector<uint8_t>::Read r = p_octree.read();
 			tex_w = decode_uint32(&r[0]);
 			tex_h = decode_uint32(&r[4]);
-			print_line("TEX W: "+itos(tex_w)+" TEX H:"+itos(tex_h)+" LEN: "+itos(p_octree.size()));
-			is16=decode_uint32(&r[8]);
-			baked_light->data.octree_lattice_size=decode_float(&r[12]);
-			baked_light->data.octree_lattice_divide=tex_w/4.0;
-			print_line("LATTICE SIZE: "+rtos(baked_light->data.octree_lattice_size));
-			print_line("LATTICE DIVIDE: "+rtos(baked_light->data.octree_lattice_divide));
-			baked_light->data.octree_steps=decode_uint32(&r[16]);
-			baked_light->data.octree_tex_pixel_size.x=1.0/tex_w;
-			baked_light->data.octree_tex_pixel_size.y=1.0/tex_h;
+			print_line("TEX W: " + itos(tex_w) + " TEX H:" + itos(tex_h) + " LEN: " + itos(p_octree.size()));
+			is16 = decode_uint32(&r[8]);
+			baked_light->data.octree_lattice_size = decode_float(&r[12]);
+			baked_light->data.octree_lattice_divide = tex_w / 4.0;
+			print_line("LATTICE SIZE: " + rtos(baked_light->data.octree_lattice_size));
+			print_line("LATTICE DIVIDE: " + rtos(baked_light->data.octree_lattice_divide));
+			baked_light->data.octree_steps = decode_uint32(&r[16]);
+			baked_light->data.octree_tex_pixel_size.x = 1.0 / tex_w;
+			baked_light->data.octree_tex_pixel_size.y = 1.0 / tex_h;
 
-			baked_light->data.texture_multiplier=decode_uint32(&r[20]);
-			light_tex_w=decode_uint16(&r[24]);
-			light_tex_h=decode_uint16(&r[26]);
-			print_line("ltexw "+itos(light_tex_w));
-			print_line("ltexh "+itos(light_tex_h));
+			baked_light->data.texture_multiplier = decode_uint32(&r[20]);
+			light_tex_w = decode_uint16(&r[24]);
+			light_tex_h = decode_uint16(&r[26]);
+			print_line("ltexw " + itos(light_tex_w));
+			print_line("ltexh " + itos(light_tex_h));
 
-			if (light_tex_w>0 && light_tex_h>0) {
-				baked_light->data.light_tex_pixel_size.x=1.0/light_tex_w;
-				baked_light->data.light_tex_pixel_size.y=1.0/light_tex_h;
-				has_light_tex=true;
+			if (light_tex_w > 0 && light_tex_h > 0) {
+				baked_light->data.light_tex_pixel_size.x = 1.0 / light_tex_w;
+				baked_light->data.light_tex_pixel_size.y = 1.0 / light_tex_h;
+				has_light_tex = true;
 			} else {
-				baked_light->data.light_tex_pixel_size=baked_light->data.octree_tex_pixel_size;
-
+				baked_light->data.light_tex_pixel_size = baked_light->data.octree_tex_pixel_size;
 			}
 
-
-
-			baked_light->octree_aabb.pos.x=decode_float(&r[32]);
-			baked_light->octree_aabb.pos.y=decode_float(&r[36]);
-			baked_light->octree_aabb.pos.z=decode_float(&r[40]);
-			baked_light->octree_aabb.size.x=decode_float(&r[44]);
-			baked_light->octree_aabb.size.y=decode_float(&r[48]);
-			baked_light->octree_aabb.size.z=decode_float(&r[52]);
-
-
+			baked_light->octree_aabb.pos.x = decode_float(&r[32]);
+			baked_light->octree_aabb.pos.y = decode_float(&r[36]);
+			baked_light->octree_aabb.pos.z = decode_float(&r[40]);
+			baked_light->octree_aabb.size.x = decode_float(&r[44]);
+			baked_light->octree_aabb.size.y = decode_float(&r[48]);
+			baked_light->octree_aabb.size.z = decode_float(&r[52]);
 		}
 
 		if (baked_light->data.octree_texture.is_valid()) {
-			if (tex_w!=baked_light->octree_tex_size.x || tex_h!=baked_light->octree_tex_size.y) {
+			if (tex_w != baked_light->octree_tex_size.x || tex_h != baked_light->octree_tex_size.y) {
 
 				rasterizer->free(baked_light->data.octree_texture);
-				baked_light->data.octree_texture=RID();
-				baked_light->octree_tex_size.x=0;
-				baked_light->octree_tex_size.y=0;
+				baked_light->data.octree_texture = RID();
+				baked_light->octree_tex_size.x = 0;
+				baked_light->octree_tex_size.y = 0;
 			}
 		}
 
 		if (baked_light->data.light_texture.is_valid()) {
-			if (!has_light_tex || light_tex_w!=baked_light->light_tex_size.x || light_tex_h!=baked_light->light_tex_size.y) {
+			if (!has_light_tex || light_tex_w != baked_light->light_tex_size.x || light_tex_h != baked_light->light_tex_size.y) {
 				rasterizer->free(baked_light->data.light_texture);
-				baked_light->data.light_texture=RID();
-				baked_light->light_tex_size.x=0;
-				baked_light->light_tex_size.y=0;
+				baked_light->data.light_texture = RID();
+				baked_light->light_tex_size.x = 0;
+				baked_light->light_tex_size.y = 0;
 			}
 		}
 
 		if (!baked_light->data.octree_texture.is_valid()) {
-			baked_light->data.octree_texture=rasterizer->texture_create();
-			rasterizer->texture_allocate(baked_light->data.octree_texture,tex_w,tex_h,Image::FORMAT_RGBA,TEXTURE_FLAG_FILTER);
-			baked_light->octree_tex_size.x=tex_w;
-			baked_light->octree_tex_size.y=tex_h;
+			baked_light->data.octree_texture = rasterizer->texture_create();
+			rasterizer->texture_allocate(baked_light->data.octree_texture, tex_w, tex_h, Image::FORMAT_RGBA, TEXTURE_FLAG_FILTER);
+			baked_light->octree_tex_size.x = tex_w;
+			baked_light->octree_tex_size.y = tex_h;
 		}
 
 		if (!baked_light->data.light_texture.is_valid() && has_light_tex) {
-			baked_light->data.light_texture=rasterizer->texture_create();
-			rasterizer->texture_allocate(baked_light->data.light_texture,light_tex_w,light_tex_h,Image::FORMAT_RGBA,TEXTURE_FLAG_FILTER);
-			baked_light->light_tex_size.x=light_tex_w;
-			baked_light->light_tex_size.y=light_tex_h;
-
+			baked_light->data.light_texture = rasterizer->texture_create();
+			rasterizer->texture_allocate(baked_light->data.light_texture, light_tex_w, light_tex_h, Image::FORMAT_RGBA, TEXTURE_FLAG_FILTER);
+			baked_light->light_tex_size.x = light_tex_w;
+			baked_light->light_tex_size.y = light_tex_h;
 		}
 
-		Image img(tex_w,tex_h,0,Image::FORMAT_RGBA,p_octree);
-		rasterizer->texture_set_data(baked_light->data.octree_texture,img);
-
+		Image img(tex_w, tex_h, 0, Image::FORMAT_RGBA, p_octree);
+		rasterizer->texture_set_data(baked_light->data.octree_texture, img);
 	}
 
-
-	_dependency_queue_update(p_baked_light,true);
-
+	_dependency_queue_update(p_baked_light, true);
 }
 
-
-DVector<uint8_t> VisualServerRaster::baked_light_get_octree(RID p_baked_light) const{
-
+DVector<uint8_t> VisualServerRaster::baked_light_get_octree(RID p_baked_light) const {
 
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
-	ERR_FAIL_COND_V(!baked_light,DVector<uint8_t>());
+	ERR_FAIL_COND_V(!baked_light, DVector<uint8_t>());
 
 	if (rasterizer->is_texture(baked_light->data.octree_texture)) {
 
@@ -1259,34 +1154,29 @@ DVector<uint8_t> VisualServerRaster::baked_light_get_octree(RID p_baked_light) c
 	}
 }
 
-void VisualServerRaster::baked_light_set_light(RID p_baked_light,const DVector<uint8_t> p_light) {
+void VisualServerRaster::baked_light_set_light(RID p_baked_light, const DVector<uint8_t> p_light) {
 
 	VS_CHANGED;
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
-	ERR_FAIL_COND(p_light.size()==0);
+	ERR_FAIL_COND(p_light.size() == 0);
 
-	int tex_w=baked_light->light_tex_size.x;
-	int tex_h=baked_light->light_tex_size.y;
+	int tex_w = baked_light->light_tex_size.x;
+	int tex_h = baked_light->light_tex_size.y;
 
-	ERR_FAIL_COND(tex_w==0 && tex_h==0);
+	ERR_FAIL_COND(tex_w == 0 && tex_h == 0);
 	ERR_FAIL_COND(!baked_light->data.light_texture.is_valid());
 
+	print_line("w: " + itos(tex_w) + " h: " + itos(tex_h) + " lightsize: " + itos(p_light.size()));
 
-
-	print_line("w: "+itos(tex_w)+" h: "+itos(tex_h)+" lightsize: "+itos(p_light.size()));
-
-	Image img(tex_w,tex_h,0,Image::FORMAT_RGBA,p_light);
-	rasterizer->texture_set_data(baked_light->data.light_texture,img);
-
-
-
+	Image img(tex_w, tex_h, 0, Image::FORMAT_RGBA, p_light);
+	rasterizer->texture_set_data(baked_light->data.light_texture, img);
 }
 
-DVector<uint8_t> VisualServerRaster::baked_light_get_light(RID p_baked_light) const{
+DVector<uint8_t> VisualServerRaster::baked_light_get_light(RID p_baked_light) const {
 
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
-	ERR_FAIL_COND_V(!baked_light,DVector<uint8_t>());
+	ERR_FAIL_COND_V(!baked_light, DVector<uint8_t>());
 
 	if (rasterizer->is_texture(baked_light->data.light_texture)) {
 
@@ -1297,44 +1187,35 @@ DVector<uint8_t> VisualServerRaster::baked_light_get_light(RID p_baked_light) co
 	}
 }
 
-
-
 void VisualServerRaster::baked_light_set_sampler_octree(RID p_baked_light, const DVector<int> &p_sampler) {
 
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
 
-	baked_light->sampler=p_sampler;
-
-
-
+	baked_light->sampler = p_sampler;
 }
 
 DVector<int> VisualServerRaster::baked_light_get_sampler_octree(RID p_baked_light) const {
 
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
-	ERR_FAIL_COND_V(!baked_light,DVector<int>());
+	ERR_FAIL_COND_V(!baked_light, DVector<int>());
 
 	return baked_light->sampler;
-
 }
 
-
-void VisualServerRaster::baked_light_add_lightmap(RID p_baked_light,const RID p_texture,int p_id){
+void VisualServerRaster::baked_light_add_lightmap(RID p_baked_light, const RID p_texture, int p_id) {
 
 	VS_CHANGED;
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
-	baked_light->data.lightmaps.insert(p_id,p_texture);
-
+	baked_light->data.lightmaps.insert(p_id, p_texture);
 }
-void VisualServerRaster::baked_light_clear_lightmaps(RID p_baked_light){
+void VisualServerRaster::baked_light_clear_lightmaps(RID p_baked_light) {
 
 	VS_CHANGED;
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
 	baked_light->data.lightmaps.clear();
-
 }
 
 void VisualServerRaster::baked_light_set_realtime_color_enabled(RID p_baked_light, const bool p_enabled) {
@@ -1344,35 +1225,31 @@ void VisualServerRaster::baked_light_set_realtime_color_enabled(RID p_baked_ligh
 	ERR_FAIL_COND(!baked_light);
 
 	baked_light->data.realtime_color_enabled = p_enabled;
-
 }
 
-bool VisualServerRaster::baked_light_get_realtime_color_enabled(RID p_baked_light) const{
+bool VisualServerRaster::baked_light_get_realtime_color_enabled(RID p_baked_light) const {
 
 	const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND_V(!baked_light, false);
 
 	return baked_light->data.realtime_color_enabled;
-
 }
 
-void VisualServerRaster::baked_light_set_realtime_color(RID p_baked_light, const Color& p_color) {
+void VisualServerRaster::baked_light_set_realtime_color(RID p_baked_light, const Color &p_color) {
 
 	VS_CHANGED;
 	BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND(!baked_light);
 
 	baked_light->data.realtime_color = p_color;
-
 }
 
-Color VisualServerRaster::baked_light_get_realtime_color(RID p_baked_light) const{
+Color VisualServerRaster::baked_light_get_realtime_color(RID p_baked_light) const {
 
 	const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND_V(!baked_light, Color(1.0, 1.0, 1.0));
 
 	return baked_light->data.realtime_color;
-
 }
 
 void VisualServerRaster::baked_light_set_realtime_energy(RID p_baked_light, const float p_energy) {
@@ -1382,94 +1259,87 @@ void VisualServerRaster::baked_light_set_realtime_energy(RID p_baked_light, cons
 	ERR_FAIL_COND(!baked_light);
 
 	baked_light->data.realtime_energy = p_energy;
-
 }
 
-float VisualServerRaster::baked_light_get_realtime_energy(RID p_baked_light) const{
+float VisualServerRaster::baked_light_get_realtime_energy(RID p_baked_light) const {
 
 	const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
 	ERR_FAIL_COND_V(!baked_light, 1.0f);
 
 	return baked_light->data.realtime_energy;
-
 }
 
-
 /* BAKED LIGHT SAMPLER */
 
 RID VisualServerRaster::baked_light_sampler_create() {
 
-	BakedLightSampler * blsamp = memnew( BakedLightSampler );
+	BakedLightSampler *blsamp = memnew(BakedLightSampler);
 	RID rid = baked_light_sampler_owner.make_rid(blsamp);
 	_update_baked_light_sampler_dp_cache(blsamp);
 	return rid;
 }
 
-void VisualServerRaster::baked_light_sampler_set_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param,float p_value){
+void VisualServerRaster::baked_light_sampler_set_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param, float p_value) {
 
 	VS_CHANGED;
-	BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
+	BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
 	ERR_FAIL_COND(!blsamp);
-	ERR_FAIL_INDEX(p_param,BAKED_LIGHT_SAMPLER_MAX);
-	blsamp->params[p_param]=p_value;
-	_dependency_queue_update(p_baked_light_sampler,true);
+	ERR_FAIL_INDEX(p_param, BAKED_LIGHT_SAMPLER_MAX);
+	blsamp->params[p_param] = p_value;
+	_dependency_queue_update(p_baked_light_sampler, true);
 }
 
-float VisualServerRaster::baked_light_sampler_get_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param) const{
-
+float VisualServerRaster::baked_light_sampler_get_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param) const {
 
-	BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
-	ERR_FAIL_COND_V(!blsamp,0);
-	ERR_FAIL_INDEX_V(p_param,BAKED_LIGHT_SAMPLER_MAX,0);
+	BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
+	ERR_FAIL_COND_V(!blsamp, 0);
+	ERR_FAIL_INDEX_V(p_param, BAKED_LIGHT_SAMPLER_MAX, 0);
 	return blsamp->params[p_param];
 }
 
-void VisualServerRaster::_update_baked_light_sampler_dp_cache(BakedLightSampler * blsamp) {
+void VisualServerRaster::_update_baked_light_sampler_dp_cache(BakedLightSampler *blsamp) {
 
 	int res = blsamp->resolution;
-	blsamp->dp_cache.resize(res*res*2);
-	Vector3 *dp_normals=blsamp->dp_cache.ptr();
+	blsamp->dp_cache.resize(res * res * 2);
+	Vector3 *dp_normals = blsamp->dp_cache.ptr();
 
-	for(int p=0;p<2;p++) {
-		float sign = p==0?1:-1;
-		int ofs = res*res*p;
-		for(int i=0;i<res;i++) {
-			for(int j=0;j<res;j++) {
+	for (int p = 0; p < 2; p++) {
+		float sign = p == 0 ? 1 : -1;
+		int ofs = res * res * p;
+		for (int i = 0; i < res; i++) {
+			for (int j = 0; j < res; j++) {
 
 				Vector2 v(
-					(i/float(res))*2.0-1.0,
-					(j/float(res))*2.0-1.0
-				);
+						(i / float(res)) * 2.0 - 1.0,
+						(j / float(res)) * 2.0 - 1.0);
 
-				float l=v.length();
-				if (l>1.0) {
-					v/=l;
-					l=1.0; //clamp to avoid imaginary
+				float l = v.length();
+				if (l > 1.0) {
+					v /= l;
+					l = 1.0; //clamp to avoid imaginary
 				}
-				v*=(2*l)/(l*l+1); //inverse of the dual paraboloid function
-				Vector3 n = Vector3(v.x,v.y,sign*sqrtf(MAX(1 - v.dot(v),0))); //reconstruction of z
-				n.y*=sign;
-				dp_normals[j*res+i+ofs]=n;
+				v *= (2 * l) / (l * l + 1); //inverse of the dual paraboloid function
+				Vector3 n = Vector3(v.x, v.y, sign * sqrtf(MAX(1 - v.dot(v), 0))); //reconstruction of z
+				n.y *= sign;
+				dp_normals[j * res + i + ofs] = n;
 			}
 		}
 	}
-
 }
 
-void VisualServerRaster::baked_light_sampler_set_resolution(RID p_baked_light_sampler,int p_resolution){
+void VisualServerRaster::baked_light_sampler_set_resolution(RID p_baked_light_sampler, int p_resolution) {
 
-    ERR_FAIL_COND(p_resolution<4 || p_resolution>64);
+	ERR_FAIL_COND(p_resolution < 4 || p_resolution > 64);
 	VS_CHANGED;
-	BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
+	BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
 	ERR_FAIL_COND(!blsamp);
-	blsamp->resolution=p_resolution;
+	blsamp->resolution = p_resolution;
 	_update_baked_light_sampler_dp_cache(blsamp);
-
 }
-int VisualServerRaster::baked_light_sampler_get_resolution(RID p_baked_light_sampler) const{
+int VisualServerRaster::baked_light_sampler_get_resolution(RID p_baked_light_sampler) const {
 
-	BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
-	ERR_FAIL_COND_V(!blsamp,0);
+	BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
+	ERR_FAIL_COND_V(!blsamp, 0);
 	return blsamp->resolution;
 }
 
@@ -1477,623 +1347,568 @@ int VisualServerRaster::baked_light_sampler_get_resolution(RID p_baked_light_sam
 
 RID VisualServerRaster::camera_create() {
 
-	Camera * camera = memnew( Camera );
-	return camera_owner.make_rid( camera );
-
+	Camera *camera = memnew(Camera);
+	return camera_owner.make_rid(camera);
 }
 
-void VisualServerRaster::camera_set_perspective(RID p_camera,float p_fovy_degrees, float p_z_near, float p_z_far) {
+void VisualServerRaster::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) {
 	VS_CHANGED
-	Camera *camera = camera_owner.get( p_camera );
+	Camera *camera = camera_owner.get(p_camera);
 	ERR_FAIL_COND(!camera);
-	camera->type=Camera::PERSPECTIVE;
-	camera->fov=p_fovy_degrees;
-	camera->znear=p_z_near;
-	camera->zfar=p_z_far;
-
+	camera->type = Camera::PERSPECTIVE;
+	camera->fov = p_fovy_degrees;
+	camera->znear = p_z_near;
+	camera->zfar = p_z_far;
 }
 
-void VisualServerRaster::camera_set_orthogonal(RID p_camera,float p_size, float p_z_near, float p_z_far) {
+void VisualServerRaster::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) {
 	VS_CHANGED;
-	Camera *camera = camera_owner.get( p_camera );
+	Camera *camera = camera_owner.get(p_camera);
 	ERR_FAIL_COND(!camera);
-	camera->type=Camera::ORTHOGONAL;
-	camera->size=p_size;
-	camera->znear=p_z_near;
-	camera->zfar=p_z_far;
+	camera->type = Camera::ORTHOGONAL;
+	camera->size = p_size;
+	camera->znear = p_z_near;
+	camera->zfar = p_z_far;
 }
 
-void VisualServerRaster::camera_set_transform(RID p_camera,const Transform& p_transform) {
+void VisualServerRaster::camera_set_transform(RID p_camera, const Transform &p_transform) {
 	VS_CHANGED;
-	Camera *camera = camera_owner.get( p_camera );
+	Camera *camera = camera_owner.get(p_camera);
 	ERR_FAIL_COND(!camera);
-	camera->transform=p_transform.orthonormalized();
-
-
+	camera->transform = p_transform.orthonormalized();
 }
 
-void VisualServerRaster::camera_set_visible_layers(RID p_camera,uint32_t p_layers) {
+void VisualServerRaster::camera_set_visible_layers(RID p_camera, uint32_t p_layers) {
 
 	VS_CHANGED;
-	Camera *camera = camera_owner.get( p_camera );
+	Camera *camera = camera_owner.get(p_camera);
 	ERR_FAIL_COND(!camera);
 
-	camera->visible_layers=p_layers;
-
+	camera->visible_layers = p_layers;
 }
 
-uint32_t VisualServerRaster::camera_get_visible_layers(RID p_camera) const{
+uint32_t VisualServerRaster::camera_get_visible_layers(RID p_camera) const {
 
-	const Camera *camera = camera_owner.get( p_camera );
-	ERR_FAIL_COND_V(!camera,0);
+	const Camera *camera = camera_owner.get(p_camera);
+	ERR_FAIL_COND_V(!camera, 0);
 
 	return camera->visible_layers;
 }
 
-void VisualServerRaster::camera_set_environment(RID p_camera,RID p_env) {
+void VisualServerRaster::camera_set_environment(RID p_camera, RID p_env) {
 
-	Camera *camera = camera_owner.get( p_camera );
+	Camera *camera = camera_owner.get(p_camera);
 	ERR_FAIL_COND(!camera);
-	camera->env=p_env;
-
+	camera->env = p_env;
 }
 
 RID VisualServerRaster::camera_get_environment(RID p_camera) const {
 
-	const Camera *camera = camera_owner.get( p_camera );
-	ERR_FAIL_COND_V(!camera,RID());
+	const Camera *camera = camera_owner.get(p_camera);
+	ERR_FAIL_COND_V(!camera, RID());
 	return camera->env;
-
 }
 
-void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera,bool p_enable) {
+void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) {
 
-	Camera *camera = camera_owner.get( p_camera );
+	Camera *camera = camera_owner.get(p_camera);
 	ERR_FAIL_COND(!camera);
-	camera->vaspect=p_enable;
-
+	camera->vaspect = p_enable;
 }
-bool VisualServerRaster::camera_is_using_vertical_aspect(RID p_camera,bool p_enable) const{
+bool VisualServerRaster::camera_is_using_vertical_aspect(RID p_camera, bool p_enable) const {
 
-	const Camera *camera = camera_owner.get( p_camera );
-	ERR_FAIL_COND_V(!camera,false);
+	const Camera *camera = camera_owner.get(p_camera);
+	ERR_FAIL_COND_V(!camera, false);
 	return camera->vaspect;
-
 }
 
-
 /* VIEWPORT API */
 
-
 RID VisualServerRaster::viewport_create() {
 
-	Viewport *viewport = memnew( Viewport );
-	RID rid = viewport_owner.make_rid( viewport );
-	ERR_FAIL_COND_V( !rid.is_valid(), rid );
+	Viewport *viewport = memnew(Viewport);
+	RID rid = viewport_owner.make_rid(viewport);
+	ERR_FAIL_COND_V(!rid.is_valid(), rid);
 
-	viewport->self=rid;
-	viewport->hide_scenario=false;
-	viewport->hide_canvas=false;
-	viewport->viewport_data=rasterizer->viewport_data_create();
+	viewport->self = rid;
+	viewport->hide_scenario = false;
+	viewport->hide_canvas = false;
+	viewport->viewport_data = rasterizer->viewport_data_create();
 
 	return rid;
 }
 
-void VisualServerRaster::viewport_attach_to_screen(RID p_viewport,int p_screen) {
+void VisualServerRaster::viewport_attach_to_screen(RID p_viewport, int p_screen) {
 
 	VS_CHANGED;
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-
-	screen_viewports[p_viewport]=p_screen;
+	screen_viewports[p_viewport] = p_screen;
 }
 
 void VisualServerRaster::viewport_detach(RID p_viewport) {
 
 	VS_CHANGED;
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	ERR_FAIL_COND(!screen_viewports.has(p_viewport));
 	screen_viewports.erase(p_viewport);
-
 }
 
-void VisualServerRaster::viewport_set_as_render_target(RID p_viewport,bool p_enable) {
+void VisualServerRaster::viewport_set_as_render_target(RID p_viewport, bool p_enable) {
 
 	VS_CHANGED;
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	if (viewport->render_target.is_valid()==p_enable)
+	if (viewport->render_target.is_valid() == p_enable)
 		return;
 	if (!p_enable) {
 
 		rasterizer->free(viewport->render_target);
-		viewport->render_target=RID();
-		viewport->render_target_texture=RID();
+		viewport->render_target = RID();
+		viewport->render_target_texture = RID();
 		if (viewport->update_list.in_list())
 			viewport_update_list.remove(&viewport->update_list);
 
 	} else {
 
-		viewport->render_target=rasterizer->render_target_create();
-		rasterizer->render_target_set_size(viewport->render_target,viewport->rect.width,viewport->rect.height);
-		viewport->render_target_texture=rasterizer->render_target_get_texture(viewport->render_target);
-		if (viewport->render_target_update_mode!=RENDER_TARGET_UPDATE_DISABLED)
+		viewport->render_target = rasterizer->render_target_create();
+		rasterizer->render_target_set_size(viewport->render_target, viewport->rect.width, viewport->rect.height);
+		viewport->render_target_texture = rasterizer->render_target_get_texture(viewport->render_target);
+		if (viewport->render_target_update_mode != RENDER_TARGET_UPDATE_DISABLED)
 			viewport_update_list.add(&viewport->update_list);
 	}
-
 }
 
-void VisualServerRaster::viewport_set_render_target_update_mode(RID p_viewport,RenderTargetUpdateMode p_mode){
+void VisualServerRaster::viewport_set_render_target_update_mode(RID p_viewport, RenderTargetUpdateMode p_mode) {
 
 	VS_CHANGED;
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->render_target.is_valid() && viewport->update_list.in_list())
 		viewport_update_list.remove(&viewport->update_list);
 
-	viewport->render_target_update_mode=p_mode;
+	viewport->render_target_update_mode = p_mode;
 
-	if (viewport->render_target.is_valid() &&viewport->render_target_update_mode!=RENDER_TARGET_UPDATE_DISABLED)
+	if (viewport->render_target.is_valid() && viewport->render_target_update_mode != RENDER_TARGET_UPDATE_DISABLED)
 		viewport_update_list.add(&viewport->update_list);
-
 }
-VisualServer::RenderTargetUpdateMode VisualServerRaster::viewport_get_render_target_update_mode(RID p_viewport) const{
+VisualServer::RenderTargetUpdateMode VisualServerRaster::viewport_get_render_target_update_mode(RID p_viewport) const {
 
-	const Viewport *viewport = viewport_owner.get( p_viewport );
-	ERR_FAIL_COND_V(!viewport,RENDER_TARGET_UPDATE_DISABLED);
+	const Viewport *viewport = viewport_owner.get(p_viewport);
+	ERR_FAIL_COND_V(!viewport, RENDER_TARGET_UPDATE_DISABLED);
 
 	return viewport->render_target_update_mode;
 }
-RID VisualServerRaster::viewport_get_render_target_texture(RID p_viewport) const{
+RID VisualServerRaster::viewport_get_render_target_texture(RID p_viewport) const {
 
-	Viewport *viewport = viewport_owner.get( p_viewport );
-	ERR_FAIL_COND_V(!viewport,RID());
+	Viewport *viewport = viewport_owner.get(p_viewport);
+	ERR_FAIL_COND_V(!viewport, RID());
 
 	return viewport->render_target_texture;
-
 }
 
-void VisualServerRaster::viewport_set_render_target_vflip(RID p_viewport,bool p_enable) {
+void VisualServerRaster::viewport_set_render_target_vflip(RID p_viewport, bool p_enable) {
 
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->render_target_vflip=p_enable;
-
+	viewport->render_target_vflip = p_enable;
 }
 
-void VisualServerRaster::viewport_set_render_target_clear_on_new_frame(RID p_viewport,bool p_enable) {
+void VisualServerRaster::viewport_set_render_target_clear_on_new_frame(RID p_viewport, bool p_enable) {
 
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->render_target_clear_on_new_frame=p_enable;
-
+	viewport->render_target_clear_on_new_frame = p_enable;
 }
 
-void VisualServerRaster::viewport_set_render_target_to_screen_rect(RID p_viewport,const Rect2& p_rect) {
+void VisualServerRaster::viewport_set_render_target_to_screen_rect(RID p_viewport, const Rect2 &p_rect) {
 
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->rt_to_screen_rect=p_rect;
-
+	viewport->rt_to_screen_rect = p_rect;
 }
 
-bool VisualServerRaster::viewport_get_render_target_vflip(RID p_viewport) const{
+bool VisualServerRaster::viewport_get_render_target_vflip(RID p_viewport) const {
 
-	const Viewport *viewport = viewport_owner.get( p_viewport );
-	ERR_FAIL_COND_V(!viewport,false);
+	const Viewport *viewport = viewport_owner.get(p_viewport);
+	ERR_FAIL_COND_V(!viewport, false);
 
 	return viewport->render_target_vflip;
-
 }
 
-bool VisualServerRaster::viewport_get_render_target_clear_on_new_frame(RID p_viewport) const{
+bool VisualServerRaster::viewport_get_render_target_clear_on_new_frame(RID p_viewport) const {
 
-	const Viewport *viewport = viewport_owner.get( p_viewport );
-	ERR_FAIL_COND_V(!viewport,false);
+	const Viewport *viewport = viewport_owner.get(p_viewport);
+	ERR_FAIL_COND_V(!viewport, false);
 
 	return viewport->render_target_clear_on_new_frame;
-
 }
 
 void VisualServerRaster::viewport_render_target_clear(RID p_viewport) {
 
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->render_target_clear=true;
-
+	viewport->render_target_clear = true;
 }
 
 void VisualServerRaster::viewport_queue_screen_capture(RID p_viewport) {
 
 	VS_CHANGED;
-	Viewport *viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
-	viewport->queue_capture=true;
-
+	viewport->queue_capture = true;
 }
 
 Image VisualServerRaster::viewport_get_screen_capture(RID p_viewport) const {
 
-	Viewport *viewport = (Viewport*)viewport_owner.get( p_viewport );
-	ERR_FAIL_COND_V(!viewport,Image());
+	Viewport *viewport = (Viewport *)viewport_owner.get(p_viewport);
+	ERR_FAIL_COND_V(!viewport, Image());
 
 	Image ret = viewport->capture;
-	viewport->capture=Image();
+	viewport->capture = Image();
 	return ret;
 }
 
-void VisualServerRaster::viewport_set_rect(RID p_viewport,const ViewportRect& p_rect) {
+void VisualServerRaster::viewport_set_rect(RID p_viewport, const ViewportRect &p_rect) {
 	VS_CHANGED;
-	Viewport *viewport=NULL;
+	Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 
 	ERR_FAIL_COND(!viewport);
 
-	viewport->rect=p_rect;
+	viewport->rect = p_rect;
 	if (viewport->render_target.is_valid()) {
-		rasterizer->render_target_set_size(viewport->render_target,viewport->rect.width,viewport->rect.height);
+		rasterizer->render_target_set_size(viewport->render_target, viewport->rect.width, viewport->rect.height);
 	}
 }
 
-
 VisualServer::ViewportRect VisualServerRaster::viewport_get_rect(RID p_viewport) const {
 
-	const Viewport *viewport=NULL;
+	const Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND_V(!viewport, ViewportRect());
 
 	return viewport->rect;
 }
 
-void VisualServerRaster::viewport_set_hide_scenario(RID p_viewport,bool p_hide) {
+void VisualServerRaster::viewport_set_hide_scenario(RID p_viewport, bool p_hide) {
 
 	VS_CHANGED;
 
-	Viewport *viewport=NULL;
+	Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->hide_scenario=p_hide;
-
-
+	viewport->hide_scenario = p_hide;
 }
 
-void VisualServerRaster::viewport_set_hide_canvas(RID p_viewport,bool p_hide) {
+void VisualServerRaster::viewport_set_hide_canvas(RID p_viewport, bool p_hide) {
 
 	VS_CHANGED;
 
-	Viewport *viewport=NULL;
+	Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->hide_canvas=p_hide;
-
-
+	viewport->hide_canvas = p_hide;
 }
 
-void VisualServerRaster::viewport_set_disable_environment(RID p_viewport,bool p_disable) {
+void VisualServerRaster::viewport_set_disable_environment(RID p_viewport, bool p_disable) {
 
 	VS_CHANGED;
 
-	Viewport *viewport=NULL;
-	viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = NULL;
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
-	viewport->disable_environment=p_disable;
-
+	viewport->disable_environment = p_disable;
 }
 
-void VisualServerRaster::viewport_attach_camera(RID p_viewport,RID p_camera) {
+void VisualServerRaster::viewport_attach_camera(RID p_viewport, RID p_camera) {
 	VS_CHANGED;
 
-	Viewport *viewport=NULL;
-	viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = NULL;
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-
-
-
 	if (p_camera.is_valid()) {
 
 		ERR_FAIL_COND(!camera_owner.owns(p_camera));
 		// a camera
-		viewport->camera=p_camera;
+		viewport->camera = p_camera;
 	} else {
-		viewport->camera=RID();
+		viewport->camera = RID();
 	}
-
 }
 
-void VisualServerRaster::viewport_set_scenario(RID p_viewport,RID p_scenario) {
+void VisualServerRaster::viewport_set_scenario(RID p_viewport, RID p_scenario) {
 
 	VS_CHANGED;
 
-	Viewport *viewport=NULL;
-	viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = NULL;
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (p_scenario.is_valid()) {
 
 		ERR_FAIL_COND(!scenario_owner.owns(p_scenario));
 		// a camera
-		viewport->scenario=p_scenario;
+		viewport->scenario = p_scenario;
 	} else {
-		viewport->scenario=RID();
+		viewport->scenario = RID();
 	}
-
 }
 
 RID VisualServerRaster::viewport_get_attached_camera(RID p_viewport) const {
 
-	const Viewport *viewport=NULL;
+	const Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND_V(!viewport, RID());
 
 	return viewport->camera;
 }
 
-void VisualServerRaster::viewport_attach_canvas(RID p_viewport,RID p_canvas) {
+void VisualServerRaster::viewport_attach_canvas(RID p_viewport, RID p_canvas) {
 	VS_CHANGED;
-	Viewport *viewport=NULL;
+	Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	Canvas *canvas = canvas_owner.get( p_canvas );
+	Canvas *canvas = canvas_owner.get(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
 	ERR_EXPLAIN("Canvas already attached.");
 	ERR_FAIL_COND(viewport->canvas_map.has(p_canvas));
 
-
 	Viewport::CanvasData cd;
-	cd.canvas=canvas;
-	cd.layer=0;
+	cd.canvas = canvas;
+	cd.layer = 0;
 
-	viewport->canvas_map[p_canvas]=cd;
+	viewport->canvas_map[p_canvas] = cd;
 	canvas->viewports.insert(p_viewport);
-
 }
 
-
-void VisualServerRaster::viewport_set_canvas_transform(RID p_viewport,RID p_canvas,const Matrix32& p_transform) {
+void VisualServerRaster::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Matrix32 &p_transform) {
 
 	VS_CHANGED;
-	Viewport *viewport=NULL;
-	viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = NULL;
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
+	Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
 	if (!E) {
 		ERR_EXPLAIN("Viewport does not contain the canvas");
 		ERR_FAIL_COND(!E);
 	}
 
-	E->get().transform=p_transform;
-
+	E->get().transform = p_transform;
 }
 
-Matrix32 VisualServerRaster::viewport_get_canvas_transform(RID p_viewport,RID p_canvas) const {
+Matrix32 VisualServerRaster::viewport_get_canvas_transform(RID p_viewport, RID p_canvas) const {
 
-	Viewport *viewport=NULL;
-	viewport = viewport_owner.get( p_viewport );
-	ERR_FAIL_COND_V(!viewport,Matrix32());
+	Viewport *viewport = NULL;
+	viewport = viewport_owner.get(p_viewport);
+	ERR_FAIL_COND_V(!viewport, Matrix32());
 
-	Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
+	Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
 	if (!E) {
 		ERR_EXPLAIN("Viewport does not contain the canvas");
-		ERR_FAIL_COND_V(!E,Matrix32());
+		ERR_FAIL_COND_V(!E, Matrix32());
 	}
 
-
 	return E->get().transform;
 }
 
-
-void VisualServerRaster::viewport_set_global_canvas_transform(RID p_viewport,const Matrix32& p_transform) {
+void VisualServerRaster::viewport_set_global_canvas_transform(RID p_viewport, const Matrix32 &p_transform) {
 
 	VS_CHANGED
-	Viewport *viewport=NULL;
-	viewport = viewport_owner.get( p_viewport );
+	Viewport *viewport = NULL;
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->global_transform=p_transform;
-
+	viewport->global_transform = p_transform;
 }
 
-Matrix32 VisualServerRaster::viewport_get_global_canvas_transform(RID p_viewport) const{
+Matrix32 VisualServerRaster::viewport_get_global_canvas_transform(RID p_viewport) const {
 
-	Viewport *viewport=NULL;
-	viewport = viewport_owner.get( p_viewport );
-	ERR_FAIL_COND_V(!viewport,Matrix32());
+	Viewport *viewport = NULL;
+	viewport = viewport_owner.get(p_viewport);
+	ERR_FAIL_COND_V(!viewport, Matrix32());
 	return viewport->global_transform;
 }
 
-void VisualServerRaster::viewport_remove_canvas(RID p_viewport,RID p_canvas) {
+void VisualServerRaster::viewport_remove_canvas(RID p_viewport, RID p_canvas) {
 
 	VS_CHANGED;
-	Viewport *viewport=NULL;
+	Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	Canvas *canvas = canvas_owner.get( p_canvas );
+	Canvas *canvas = canvas_owner.get(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
-
-	Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
+	Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
 	if (!E) {
 		ERR_EXPLAIN("Viewport does not contain the canvas");
 		ERR_FAIL_COND(!E);
 	}
 
-
 	canvas->viewports.erase(p_viewport);
 	viewport->canvas_map.erase(E);
-
 }
 
-
-void VisualServerRaster::viewport_set_canvas_layer(RID p_viewport,RID p_canvas,int p_layer) {
+void VisualServerRaster::viewport_set_canvas_layer(RID p_viewport, RID p_canvas, int p_layer) {
 
 	VS_CHANGED;
-	Viewport *viewport=NULL;
+	Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
+	Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
 	if (!E) {
 		ERR_EXPLAIN("Viewport does not contain the canvas");
 		ERR_FAIL_COND(!E);
 	}
 
-	E->get().layer=p_layer;
-
+	E->get().layer = p_layer;
 }
 
-void VisualServerRaster::viewport_set_transparent_background(RID p_viewport,bool p_enabled) {
+void VisualServerRaster::viewport_set_transparent_background(RID p_viewport, bool p_enabled) {
 
 	VS_CHANGED;
-	Viewport *viewport=viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->transparent_bg=p_enabled;
+	viewport->transparent_bg = p_enabled;
 }
 
 bool VisualServerRaster::viewport_has_transparent_background(RID p_viewport) const {
 
-	Viewport *viewport=viewport_owner.get( p_viewport );
+	Viewport *viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND_V(!viewport, false);
 
 	return viewport->transparent_bg;
 }
 
+RID VisualServerRaster::viewport_get_scenario(RID p_viewport) const {
 
-RID VisualServerRaster::viewport_get_scenario(RID  p_viewport) const {
-
-	const Viewport *viewport=NULL;
+	const Viewport *viewport = NULL;
 
-	viewport = viewport_owner.get( p_viewport );
+	viewport = viewport_owner.get(p_viewport);
 	ERR_FAIL_COND_V(!viewport, RID());
 
 	return viewport->scenario;
 }
 
-
 RID VisualServerRaster::environment_create() {
 
 	return rasterizer->environment_create();
 }
 
-void VisualServerRaster::environment_set_background(RID p_env,EnvironmentBG p_bg){
+void VisualServerRaster::environment_set_background(RID p_env, EnvironmentBG p_bg) {
 
-	rasterizer->environment_set_background(p_env,p_bg);
+	rasterizer->environment_set_background(p_env, p_bg);
 }
-VisualServer::EnvironmentBG VisualServerRaster::environment_get_background(RID p_env) const{
+VisualServer::EnvironmentBG VisualServerRaster::environment_get_background(RID p_env) const {
 
 	return rasterizer->environment_get_background(p_env);
 }
 
-void VisualServerRaster::environment_set_background_param(RID p_env,EnvironmentBGParam p_param, const Variant& p_value){
+void VisualServerRaster::environment_set_background_param(RID p_env, EnvironmentBGParam p_param, const Variant &p_value) {
 
-
-	rasterizer->environment_set_background_param(p_env,p_param,p_value);
+	rasterizer->environment_set_background_param(p_env, p_param, p_value);
 }
-Variant VisualServerRaster::environment_get_background_param(RID p_env,EnvironmentBGParam p_param) const{
+Variant VisualServerRaster::environment_get_background_param(RID p_env, EnvironmentBGParam p_param) const {
 
-	return rasterizer->environment_get_background_param(p_env,p_param);
+	return rasterizer->environment_get_background_param(p_env, p_param);
 }
 
-void VisualServerRaster::environment_set_enable_fx(RID p_env,EnvironmentFx p_effect,bool p_enabled){
+void VisualServerRaster::environment_set_enable_fx(RID p_env, EnvironmentFx p_effect, bool p_enabled) {
 
-	rasterizer->environment_set_enable_fx(p_env,p_effect,p_enabled);
+	rasterizer->environment_set_enable_fx(p_env, p_effect, p_enabled);
 }
-bool VisualServerRaster::environment_is_fx_enabled(RID p_env,EnvironmentFx p_effect) const{
+bool VisualServerRaster::environment_is_fx_enabled(RID p_env, EnvironmentFx p_effect) const {
 
-	return rasterizer->environment_is_fx_enabled(p_env,p_effect);
+	return rasterizer->environment_is_fx_enabled(p_env, p_effect);
 }
 
+void VisualServerRaster::environment_fx_set_param(RID p_env, EnvironmentFxParam p_param, const Variant &p_value) {
 
-void VisualServerRaster::environment_fx_set_param(RID p_env,EnvironmentFxParam p_param,const Variant& p_value){
-
-	rasterizer->environment_fx_set_param(p_env,p_param,p_value);
+	rasterizer->environment_fx_set_param(p_env, p_param, p_value);
 }
-Variant VisualServerRaster::environment_fx_get_param(RID p_env,EnvironmentFxParam p_param) const {
+Variant VisualServerRaster::environment_fx_get_param(RID p_env, EnvironmentFxParam p_param) const {
 
-	return environment_fx_get_param(p_env,p_param);
+	return environment_fx_get_param(p_env, p_param);
 }
 
-
-
 /* SCENARIO API */
 
-void VisualServerRaster::_dependency_queue_update(RID p_rid,bool p_update_aabb,bool p_update_materials) {
+void VisualServerRaster::_dependency_queue_update(RID p_rid, bool p_update_aabb, bool p_update_materials) {
 
-	Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_rid );
+	Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(p_rid);
 
 	if (!E)
 		return;
 
-
 	Set<RID>::Element *I = E->get().front();
 
-	while(I) {
+	while (I) {
 
-		Instance *ins = instance_owner.get( I->get() );
-		_instance_queue_update( ins , p_update_aabb, p_update_materials );
+		Instance *ins = instance_owner.get(I->get());
+		_instance_queue_update(ins, p_update_aabb, p_update_materials);
 
 		I = I->next();
 	}
-
 }
 
-void VisualServerRaster::_instance_queue_update(Instance *p_instance,bool p_update_aabb,bool p_update_materials) {
+void VisualServerRaster::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_materials) {
 
 	if (p_update_aabb)
-		p_instance->update_aabb=true;
+		p_instance->update_aabb = true;
 	if (p_update_materials)
-		p_instance->update_materials=true;
+		p_instance->update_materials = true;
 
 	if (p_instance->update)
 		return;
-	p_instance->update_next=instance_update_list;
-	instance_update_list=p_instance;
-	p_instance->update=true;
-
+	p_instance->update_next = instance_update_list;
+	instance_update_list = p_instance;
+	p_instance->update = true;
 }
 
 RID VisualServerRaster::scenario_create() {
 
-	Scenario *scenario = memnew( Scenario );
-	ERR_FAIL_COND_V(!scenario,RID());
-	RID scenario_rid = scenario_owner.make_rid( scenario );
-	scenario->self=scenario_rid;
-	scenario->octree.set_pair_callback(instance_pair,this);
-	scenario->octree.set_unpair_callback(instance_unpair,this);
+	Scenario *scenario = memnew(Scenario);
+	ERR_FAIL_COND_V(!scenario, RID());
+	RID scenario_rid = scenario_owner.make_rid(scenario);
+	scenario->self = scenario_rid;
+	scenario->octree.set_pair_callback(instance_pair, this);
+	scenario->octree.set_unpair_callback(instance_unpair, this);
 
 	return scenario_rid;
 }
 
-void VisualServerRaster::scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode) {
+void VisualServerRaster::scenario_set_debug(RID p_scenario, ScenarioDebugMode p_debug_mode) {
 	VS_CHANGED;
 
 	Scenario *scenario = scenario_owner.get(p_scenario);
 	ERR_FAIL_COND(!scenario);
-	scenario->debug=p_debug_mode;
+	scenario->debug = p_debug_mode;
 }
 
 void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environment) {
@@ -2102,8 +1917,7 @@ void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environm
 
 	Scenario *scenario = scenario_owner.get(p_scenario);
 	ERR_FAIL_COND(!scenario);
-	scenario->environment=p_environment;
-
+	scenario->environment = p_environment;
 }
 
 void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
@@ -2112,32 +1926,27 @@ void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p
 
 	Scenario *scenario = scenario_owner.get(p_scenario);
 	ERR_FAIL_COND(!scenario);
-	scenario->fallback_environment=p_environment;
-
-
+	scenario->fallback_environment = p_environment;
 }
 
-RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment) const{
+RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment) const {
 
 	const Scenario *scenario = scenario_owner.get(p_scenario);
-	ERR_FAIL_COND_V(!scenario,RID());
+	ERR_FAIL_COND_V(!scenario, RID());
 	return scenario->environment;
-
 }
 
-
 /* INSTANCING API */
 
-
 RID VisualServerRaster::instance_create() {
 
-	Instance *instance = memnew( Instance );
-	ERR_FAIL_COND_V(!instance,RID());
+	Instance *instance = memnew(Instance);
+	ERR_FAIL_COND_V(!instance, RID());
 
 	RID instance_rid = instance_owner.make_rid(instance);
-	instance->self=instance_rid;
-	instance->base_type=INSTANCE_NONE;
-	instance->scenario=NULL;
+	instance->self = instance_rid;
+	instance->base_type = INSTANCE_NONE;
+	instance->scenario = NULL;
 
 	return instance_rid;
 }
@@ -2145,26 +1954,26 @@ RID VisualServerRaster::instance_create() {
 void VisualServerRaster::instance_set_base(RID p_instance, RID p_base) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
-	if (instance->base_type!=INSTANCE_NONE) {
+	if (instance->base_type != INSTANCE_NONE) {
 		//free anything related to that base
 
-		Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( instance->base_rid );
+		Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(instance->base_rid);
 
 		if (E) {
 			// wtf, no E?
-			E->get().erase( instance->self );
+			E->get().erase(instance->self);
 
 		} else {
 
 			ERR_PRINT("no base E? Bug?");
 		}
 
-		if ( instance->room ) {
+		if (instance->room) {
 
-			instance_set_room(p_instance,RID());
+			instance_set_room(p_instance, RID());
 			/*
 			if((1<<instance->base_type)&INSTANCE_GEOMETRY_MASK)
 				instance->room->room_info->owned_geometry_instances.erase(instance->RE);
@@ -2179,161 +1988,147 @@ void VisualServerRaster::instance_set_base(RID p_instance, RID p_base) {
 			instance->RE=NULL;*/
 		}
 
-
-
-
-
 		if (instance->light_info) {
 
 			if (instance->scenario && instance->light_info->D)
-				instance->scenario->directional_lights.erase( instance->light_info->D );
+				instance->scenario->directional_lights.erase(instance->light_info->D);
 			rasterizer->free(instance->light_info->instance);
 			memdelete(instance->light_info);
-			instance->light_info=NULL;
+			instance->light_info = NULL;
 		}
 
-
 		if (instance->portal_info) {
 
-			_portal_disconnect(instance,true);
+			_portal_disconnect(instance, true);
 			memdelete(instance->portal_info);
-			instance->portal_info=NULL;
-
+			instance->portal_info = NULL;
 		}
 
 		if (instance->baked_light_info) {
 
-			while(instance->baked_light_info->owned_instances.size()) {
+			while (instance->baked_light_info->owned_instances.size()) {
 
-				Instance *owned=instance->baked_light_info->owned_instances.front()->get();
-				owned->baked_light=NULL;
-				owned->data.baked_light=NULL;
-				owned->data.baked_light_octree_xform=NULL;
-				owned->BLE=NULL;
+				Instance *owned = instance->baked_light_info->owned_instances.front()->get();
+				owned->baked_light = NULL;
+				owned->data.baked_light = NULL;
+				owned->data.baked_light_octree_xform = NULL;
+				owned->BLE = NULL;
 				instance->baked_light_info->owned_instances.pop_front();
 			}
 
 			memdelete(instance->baked_light_info);
-			instance->baked_light_info=NULL;
-
+			instance->baked_light_info = NULL;
 		}
 
 		if (instance->scenario && instance->octree_id) {
-			instance->scenario->octree.erase( instance->octree_id );
-			instance->octree_id=0;
+			instance->scenario->octree.erase(instance->octree_id);
+			instance->octree_id = 0;
 		}
 
-
 		if (instance->room_info) {
 
-			for(List<Instance*>::Element *E=instance->room_info->owned_geometry_instances.front();E;E=E->next()) {
+			for (List<Instance *>::Element *E = instance->room_info->owned_geometry_instances.front(); E; E = E->next()) {
 
 				Instance *owned = E->get();
-				owned->room=NULL;
-				owned->RE=NULL;
+				owned->room = NULL;
+				owned->RE = NULL;
 			}
-			for(List<Instance*>::Element *E=instance->room_info->owned_portal_instances.front();E;E=E->next()) {
+			for (List<Instance *>::Element *E = instance->room_info->owned_portal_instances.front(); E; E = E->next()) {
 
-				_portal_disconnect(E->get(),true);
+				_portal_disconnect(E->get(), true);
 				Instance *owned = E->get();
-				owned->room=NULL;
-				owned->RE=NULL;
+				owned->room = NULL;
+				owned->RE = NULL;
 			}
 
-			for(List<Instance*>::Element *E=instance->room_info->owned_room_instances.front();E;E=E->next()) {
+			for (List<Instance *>::Element *E = instance->room_info->owned_room_instances.front(); E; E = E->next()) {
 
 				Instance *owned = E->get();
-				owned->room=NULL;
-				owned->RE=NULL;
+				owned->room = NULL;
+				owned->RE = NULL;
 			}
 
 			if (instance->room_info->disconnected_child_portals.size()) {
 				ERR_PRINT("BUG: Disconnected portals remain!");
 			}
 			memdelete(instance->room_info);
-			instance->room_info=NULL;
-
+			instance->room_info = NULL;
 		}
 
 		if (instance->particles_info) {
 
-			rasterizer->free( instance->particles_info->instance );
+			rasterizer->free(instance->particles_info->instance);
 			memdelete(instance->particles_info);
-			instance->particles_info=NULL;
-
+			instance->particles_info = NULL;
 		}
 
 		if (instance->baked_light_sampler_info) {
 
 			while (instance->baked_light_sampler_info->owned_instances.size()) {
 
-				instance_geometry_set_baked_light_sampler(instance->baked_light_sampler_info->owned_instances.front()->get()->self,RID());
+				instance_geometry_set_baked_light_sampler(instance->baked_light_sampler_info->owned_instances.front()->get()->self, RID());
 			}
 
 			if (instance->baked_light_sampler_info->sampled_light.is_valid()) {
 				rasterizer->free(instance->baked_light_sampler_info->sampled_light);
 			}
-			memdelete( instance->baked_light_sampler_info );
-			instance->baked_light_sampler_info=NULL;
+			memdelete(instance->baked_light_sampler_info);
+			instance->baked_light_sampler_info = NULL;
 		}
 
 		instance->data.morph_values.clear();
 		instance->data.materials.clear();
-
 	}
 
-
-	instance->base_type=INSTANCE_NONE;
-	instance->base_rid=RID();
-
+	instance->base_type = INSTANCE_NONE;
+	instance->base_rid = RID();
 
 	if (p_base.is_valid()) {
 
 		if (rasterizer->is_mesh(p_base)) {
-			instance->base_type=INSTANCE_MESH;
-			instance->data.morph_values.resize( rasterizer->mesh_get_morph_target_count(p_base));
-			instance->data.materials.resize( rasterizer->mesh_get_surface_count(p_base));
+			instance->base_type = INSTANCE_MESH;
+			instance->data.morph_values.resize(rasterizer->mesh_get_morph_target_count(p_base));
+			instance->data.materials.resize(rasterizer->mesh_get_surface_count(p_base));
 		} else if (rasterizer->is_multimesh(p_base)) {
-			instance->base_type=INSTANCE_MULTIMESH;
+			instance->base_type = INSTANCE_MULTIMESH;
 		} else if (rasterizer->is_immediate(p_base)) {
-			instance->base_type=INSTANCE_IMMEDIATE;
+			instance->base_type = INSTANCE_IMMEDIATE;
 		} else if (rasterizer->is_particles(p_base)) {
-			instance->base_type=INSTANCE_PARTICLES;
-			instance->particles_info=memnew( Instance::ParticlesInfo );
-			instance->particles_info->instance = rasterizer->particles_instance_create( p_base );
+			instance->base_type = INSTANCE_PARTICLES;
+			instance->particles_info = memnew(Instance::ParticlesInfo);
+			instance->particles_info->instance = rasterizer->particles_instance_create(p_base);
 		} else if (rasterizer->is_light(p_base)) {
 
-			instance->base_type=INSTANCE_LIGHT;
-			instance->light_info = memnew( Instance::LightInfo );
+			instance->base_type = INSTANCE_LIGHT;
+			instance->light_info = memnew(Instance::LightInfo);
 			instance->light_info->instance = rasterizer->light_instance_create(p_base);
-			if (instance->scenario && rasterizer->light_get_type(p_base)==LIGHT_DIRECTIONAL) {
+			if (instance->scenario && rasterizer->light_get_type(p_base) == LIGHT_DIRECTIONAL) {
 
 				instance->light_info->D = instance->scenario->directional_lights.push_back(instance->self);
 			}
 
 		} else if (room_owner.owns(p_base)) {
-			instance->base_type=INSTANCE_ROOM;
-			instance->room_info  = memnew( Instance::RoomInfo );
-			instance->room_info->room=room_owner.get(p_base);
+			instance->base_type = INSTANCE_ROOM;
+			instance->room_info = memnew(Instance::RoomInfo);
+			instance->room_info->room = room_owner.get(p_base);
 		} else if (portal_owner.owns(p_base)) {
 
-			instance->base_type=INSTANCE_PORTAL;
+			instance->base_type = INSTANCE_PORTAL;
 			instance->portal_info = memnew(Instance::PortalInfo);
-			instance->portal_info->portal=portal_owner.get(p_base);
+			instance->portal_info->portal = portal_owner.get(p_base);
 		} else if (baked_light_owner.owns(p_base)) {
 
-			instance->base_type=INSTANCE_BAKED_LIGHT;
-			instance->baked_light_info=memnew(Instance::BakedLightInfo);
-			instance->baked_light_info->baked_light=baked_light_owner.get(p_base);
+			instance->base_type = INSTANCE_BAKED_LIGHT;
+			instance->baked_light_info = memnew(Instance::BakedLightInfo);
+			instance->baked_light_info->baked_light = baked_light_owner.get(p_base);
 
 			//instance->portal_info = memnew(Instance::PortalInfo);
 			//instance->portal_info->portal=portal_owner.get(p_base);
 		} else if (baked_light_sampler_owner.owns(p_base)) {
 
-
-			instance->base_type=INSTANCE_BAKED_LIGHT_SAMPLER;
-			instance->baked_light_sampler_info=memnew( Instance::BakedLightSamplerInfo);
-			instance->baked_light_sampler_info->sampler=baked_light_sampler_owner.get(p_base);
+			instance->base_type = INSTANCE_BAKED_LIGHT_SAMPLER;
+			instance->baked_light_sampler_info = memnew(Instance::BakedLightSamplerInfo);
+			instance->baked_light_sampler_info->sampler = baked_light_sampler_owner.get(p_base);
 
 			//instance->portal_info = memnew(Instance::PortalInfo);
 			//instance->portal_info->portal=portal_owner.get(p_base);
@@ -2343,38 +2138,36 @@ void VisualServerRaster::instance_set_base(RID p_instance, RID p_base) {
 			ERR_FAIL();
 		}
 
-		instance_dependency_map[ p_base ].insert( instance->self );
+		instance_dependency_map[p_base].insert(instance->self);
 
-		instance->base_rid=p_base;
+		instance->base_rid = p_base;
 
 		if (instance->scenario)
-			_instance_queue_update(instance,true);
+			_instance_queue_update(instance, true);
 	}
-
 }
 
 RID VisualServerRaster::instance_get_base(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, RID() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, RID());
 	return instance->base_rid;
-
 }
 
 void VisualServerRaster::instance_set_scenario(RID p_instance, RID p_scenario) {
 
 	VS_CHANGED;
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
 	if (instance->scenario) {
 
-		Map< RID, Set<RID> >::Element *E = instance_dependency_map.find( instance->scenario->self );
+		Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(instance->scenario->self);
 
 		if (E) {
 			// wtf, no E?
-			E->get().erase( instance->self );
+			E->get().erase(instance->self);
 
 		} else {
 
@@ -2384,310 +2177,286 @@ void VisualServerRaster::instance_set_scenario(RID p_instance, RID p_scenario) {
 		if (instance->light_info) {
 
 			if (instance->light_info->D)
-				instance->scenario->directional_lights.erase( instance->light_info->D );
+				instance->scenario->directional_lights.erase(instance->light_info->D);
 		}
 
 		if (instance->portal_info) {
 
-			_portal_disconnect(instance,true);
+			_portal_disconnect(instance, true);
 		}
 
 		if (instance->octree_id) {
-			instance->scenario->octree.erase( instance->octree_id );
-			instance->octree_id=0;
+			instance->scenario->octree.erase(instance->octree_id);
+			instance->octree_id = 0;
 		}
 
-		instance->scenario=NULL;
+		instance->scenario = NULL;
 	}
 
-
 	if (p_scenario.is_valid()) {
-		Scenario *scenario = scenario_owner.get( p_scenario );
+		Scenario *scenario = scenario_owner.get(p_scenario);
 		ERR_FAIL_COND(!scenario);
 
-		instance->scenario=scenario;
+		instance->scenario = scenario;
 
-		instance_dependency_map[ p_scenario ].insert( instance->self );
-		instance->scenario=scenario;
+		instance_dependency_map[p_scenario].insert(instance->self);
+		instance->scenario = scenario;
 
-		if (instance->base_type==INSTANCE_LIGHT && rasterizer->light_get_type(instance->base_rid)==LIGHT_DIRECTIONAL) {
+		if (instance->base_type == INSTANCE_LIGHT && rasterizer->light_get_type(instance->base_rid) == LIGHT_DIRECTIONAL) {
 
 			instance->light_info->D = instance->scenario->directional_lights.push_back(instance->self);
 		}
 
-		_instance_queue_update(instance,true);
+		_instance_queue_update(instance, true);
 	}
-
 }
 RID VisualServerRaster::instance_get_scenario(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, RID() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, RID());
 	if (instance->scenario)
 		return instance->scenario->self;
 	else
 		return RID();
-
-
 }
 
-
 void VisualServerRaster::instance_set_layer_mask(RID p_instance, uint32_t p_mask) {
 
 	VS_CHANGED;
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-
-	instance->layer_mask=p_mask;
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
+	instance->layer_mask = p_mask;
 }
 
-uint32_t VisualServerRaster::instance_get_layer_mask(RID p_instance) const{
+uint32_t VisualServerRaster::instance_get_layer_mask(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, 0 );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, 0);
 
 	return instance->layer_mask;
 }
 
-
 AABB VisualServerRaster::instance_get_base_aabb(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, AABB() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, AABB());
 	return instance->aabb;
-
 }
 
-void VisualServerRaster::instance_attach_object_instance_ID(RID p_instance,uint32_t p_ID) {
+void VisualServerRaster::instance_attach_object_instance_ID(RID p_instance, uint32_t p_ID) {
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
-	instance->object_ID=p_ID;
+	instance->object_ID = p_ID;
 }
 uint32_t VisualServerRaster::instance_get_object_instance_ID(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, 0 );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, 0);
 	return instance->object_ID;
-
 }
 
-void VisualServerRaster::instance_attach_skeleton(RID p_instance,RID p_skeleton) {
+void VisualServerRaster::instance_attach_skeleton(RID p_instance, RID p_skeleton) {
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
 	if (instance->data.skeleton.is_valid()) {
 		skeleton_dependency_map[instance->data.skeleton].erase(instance);
 	}
 
-	instance->data.skeleton=p_skeleton;
+	instance->data.skeleton = p_skeleton;
 
 	if (instance->data.skeleton.is_valid()) {
 		skeleton_dependency_map[instance->data.skeleton].insert(instance);
 	}
-
 }
 
 RID VisualServerRaster::instance_get_skeleton(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, RID() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, RID());
 	return instance->data.skeleton;
-
 }
 
-void VisualServerRaster::instance_set_morph_target_weight(RID p_instance,int p_shape, float p_weight) {
+void VisualServerRaster::instance_set_morph_target_weight(RID p_instance, int p_shape, float p_weight) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-	ERR_FAIL_INDEX( p_shape, instance->data.morph_values.size() );
-	instance->data.morph_values[p_shape]=p_weight;
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
+	ERR_FAIL_INDEX(p_shape, instance->data.morph_values.size());
+	instance->data.morph_values[p_shape] = p_weight;
 }
 
-float VisualServerRaster::instance_get_morph_target_weight(RID p_instance,int p_shape) const {
+float VisualServerRaster::instance_get_morph_target_weight(RID p_instance, int p_shape) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, 0 );
-	ERR_FAIL_INDEX_V( p_shape, instance->data.morph_values.size(), 0 );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, 0);
+	ERR_FAIL_INDEX_V(p_shape, instance->data.morph_values.size(), 0);
 	return instance->data.morph_values[p_shape];
 }
 
-void VisualServerRaster::instance_set_surface_material(RID p_instance,int p_surface, RID p_material) {
+void VisualServerRaster::instance_set_surface_material(RID p_instance, int p_surface, RID p_material) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance);
-	ERR_FAIL_INDEX( p_surface, instance->data.materials.size() );
-	instance->data.materials[p_surface]=p_material;
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
+	ERR_FAIL_INDEX(p_surface, instance->data.materials.size());
+	instance->data.materials[p_surface] = p_material;
 }
 
-
-void VisualServerRaster::instance_set_transform(RID p_instance, const Transform& p_transform) {
+void VisualServerRaster::instance_set_transform(RID p_instance, const Transform &p_transform) {
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
-	if (p_transform==instance->data.transform) // must improve somehow
+	if (p_transform == instance->data.transform) // must improve somehow
 		return;
 
-	instance->data.transform=p_transform;
-	if (instance->base_type==INSTANCE_LIGHT)
+	instance->data.transform = p_transform;
+	if (instance->base_type == INSTANCE_LIGHT)
 		instance->data.transform.orthonormalize();
 	_instance_queue_update(instance);
-
 }
 
 Transform VisualServerRaster::instance_get_transform(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, Transform() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, Transform());
 
 	return instance->data.transform;
-
 }
 
-void VisualServerRaster::instance_set_exterior( RID p_instance, bool p_enabled ) {
+void VisualServerRaster::instance_set_exterior(RID p_instance, bool p_enabled) {
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
 	ERR_EXPLAIN("Portals can't be assigned to be exterior");
 
-	ERR_FAIL_COND( instance->base_type == INSTANCE_PORTAL );
-	if (instance->exterior==p_enabled)
+	ERR_FAIL_COND(instance->base_type == INSTANCE_PORTAL);
+	if (instance->exterior == p_enabled)
 		return;
-	instance->exterior=p_enabled;
-	_instance_queue_update( instance );
-
-
+	instance->exterior = p_enabled;
+	_instance_queue_update(instance);
 }
 
-bool VisualServerRaster::instance_is_exterior( RID p_instance) const {
+bool VisualServerRaster::instance_is_exterior(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, false );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, false);
 
 	return instance->exterior;
 }
 
-
-void VisualServerRaster::instance_set_room( RID p_instance, RID p_room ) {
+void VisualServerRaster::instance_set_room(RID p_instance, RID p_room) {
 	VS_CHANGED;
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
 	if (instance->room && instance->RE) {
 
 		//instance already havs a room, remove it from there
 
-		if ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK ) {
+		if ((1 << instance->base_type) & INSTANCE_GEOMETRY_MASK) {
 
 			instance->room->room_info->owned_geometry_instances.erase(instance->RE);
 
 			if (!p_room.is_valid() && instance->octree_id) {
 				//remove from the octree, so it's re-added with different flags
-				instance->scenario->octree.erase( instance->octree_id );
-				instance->octree_id=0;
-				_instance_queue_update( instance,true );
+				instance->scenario->octree.erase(instance->octree_id);
+				instance->octree_id = 0;
+				_instance_queue_update(instance, true);
 			}
 
-
-		} else if ( instance->base_type==INSTANCE_ROOM ) {
+		} else if (instance->base_type == INSTANCE_ROOM) {
 
 			instance->room->room_info->owned_room_instances.erase(instance->RE);
 
-			for(List<Instance*>::Element *E=instance->room_info->owned_portal_instances.front();E;E=E->next()) {
+			for (List<Instance *>::Element *E = instance->room_info->owned_portal_instances.front(); E; E = E->next()) {
 				_portal_disconnect(E->get());
-				_instance_queue_update( E->get(),false );
+				_instance_queue_update(E->get(), false);
 			}
 
-		} else if ( instance->base_type==INSTANCE_PORTAL ) {
+		} else if (instance->base_type == INSTANCE_PORTAL) {
 
-			_portal_disconnect(instance,true);
+			_portal_disconnect(instance, true);
 			bool ss = instance->room->room_info->owned_portal_instances.erase(instance->RE);
 
-		} else if ( instance->base_type==INSTANCE_LIGHT ) {
+		} else if (instance->base_type == INSTANCE_LIGHT) {
 
 			instance->room->room_info->owned_light_instances.erase(instance->RE);
 		} else {
 
 			ERR_FAIL();
-
 		}
 
-		instance->RE=NULL;
-		instance->room=NULL;
-
+		instance->RE = NULL;
+		instance->room = NULL;
 
 	} else {
 
 		if (p_room.is_valid() && instance->octree_id) {
 			//remove from the octree, so it's re-added with different flags
-			instance->scenario->octree.erase( instance->octree_id );
-			instance->octree_id=0;
-			_instance_queue_update( instance,true );
+			instance->scenario->octree.erase(instance->octree_id);
+			instance->octree_id = 0;
+			_instance_queue_update(instance, true);
 		}
-
 	}
 
 	if (!p_room.is_valid())
 		return; // just clearning the room
 
-	Instance *room = instance_owner.get( p_room );
-
-	ERR_FAIL_COND( !room );
-	ERR_FAIL_COND( room->base_type!=INSTANCE_ROOM );
+	Instance *room = instance_owner.get(p_room);
 
+	ERR_FAIL_COND(!room);
+	ERR_FAIL_COND(room->base_type != INSTANCE_ROOM);
 
-	if (instance->base_type==INSTANCE_ROOM) {
+	if (instance->base_type == INSTANCE_ROOM) {
 
 		//perform cycle test
 
 		Instance *parent = instance;
 
-		while(parent) {
+		while (parent) {
 
 			ERR_EXPLAIN("Cycle in room assignment");
-			ERR_FAIL_COND( parent == room );
-			parent=parent->room;
+			ERR_FAIL_COND(parent == room);
+			parent = parent->room;
 		}
 	}
 
-	if ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK ) {
+	if ((1 << instance->base_type) & INSTANCE_GEOMETRY_MASK) {
 
 		instance->RE = room->room_info->owned_geometry_instances.push_back(instance);
-	} else if ( instance->base_type==INSTANCE_ROOM ) {
+	} else if (instance->base_type == INSTANCE_ROOM) {
 
 		instance->RE = room->room_info->owned_room_instances.push_back(instance);
-		for(List<Instance*>::Element *E=instance->room_info->owned_portal_instances.front();E;E=E->next())
-			_instance_queue_update( E->get(),false );
-
+		for (List<Instance *>::Element *E = instance->room_info->owned_portal_instances.front(); E; E = E->next())
+			_instance_queue_update(E->get(), false);
 
-	} else if ( instance->base_type==INSTANCE_PORTAL ) {
+	} else if (instance->base_type == INSTANCE_PORTAL) {
 
 		instance->RE = room->room_info->owned_portal_instances.push_back(instance);
-	} else if ( instance->base_type==INSTANCE_LIGHT ) {
+	} else if (instance->base_type == INSTANCE_LIGHT) {
 
 		instance->RE = room->room_info->owned_light_instances.push_back(instance);
 	} else {
 
 		ERR_FAIL();
-
 	}
 
-	instance->room=room;
+	instance->room = room;
 }
 
-RID VisualServerRaster::instance_get_room( RID p_instance ) const  {
+RID VisualServerRaster::instance_get_room(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, RID() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, RID());
 
 	if (instance->room)
 		return instance->room->self;
@@ -2695,152 +2464,142 @@ RID VisualServerRaster::instance_get_room( RID p_instance ) const  {
 		return RID();
 }
 
-void VisualServerRaster::instance_set_extra_visibility_margin( RID p_instance, real_t p_margin ) {
+void VisualServerRaster::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) {
 
 	VS_CHANGED;
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
-	instance->extra_margin=p_margin;
+	instance->extra_margin = p_margin;
 }
-real_t VisualServerRaster::instance_get_extra_visibility_margin( RID p_instance ) const{
-
+real_t VisualServerRaster::instance_get_extra_visibility_margin(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, 0 );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, 0);
 
 	return instance->extra_margin;
 }
 
-
-Vector<RID> VisualServerRaster::instances_cull_aabb(const AABB& p_aabb, RID p_scenario) const {
-
+Vector<RID> VisualServerRaster::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const {
 
 	Vector<RID> instances;
-	Scenario *scenario=scenario_owner.get(p_scenario);
-	ERR_FAIL_COND_V(!scenario,instances);
+	Scenario *scenario = scenario_owner.get(p_scenario);
+	ERR_FAIL_COND_V(!scenario, instances);
 
-	const_cast<VisualServerRaster*>(this)->_update_instances(); // check dirty instances before culling
+	const_cast<VisualServerRaster *>(this)->_update_instances(); // check dirty instances before culling
 
-	int culled=0;
+	int culled = 0;
 	Instance *cull[1024];
-	culled=scenario->octree.cull_AABB(p_aabb,cull,1024);
+	culled = scenario->octree.cull_AABB(p_aabb, cull, 1024);
 
-	for (int i=0;i<culled;i++) {
+	for (int i = 0; i < culled; i++) {
 
-		Instance *instance=cull[i];
+		Instance *instance = cull[i];
 		ERR_CONTINUE(!instance);
 		instances.push_back(instance->self);
 	}
 
 	return instances;
 }
-Vector<RID> VisualServerRaster::instances_cull_ray(const Vector3& p_from, const Vector3& p_to, RID p_scenario) const{
+Vector<RID> VisualServerRaster::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const {
 
 	Vector<RID> instances;
-	Scenario *scenario=scenario_owner.get(p_scenario);
-	ERR_FAIL_COND_V(!scenario,instances);
-	const_cast<VisualServerRaster*>(this)->_update_instances(); // check dirty instances before culling
+	Scenario *scenario = scenario_owner.get(p_scenario);
+	ERR_FAIL_COND_V(!scenario, instances);
+	const_cast<VisualServerRaster *>(this)->_update_instances(); // check dirty instances before culling
 
-	int culled=0;
+	int culled = 0;
 	Instance *cull[1024];
-	culled=scenario->octree.cull_segment(p_from,p_to*10000,cull,1024);
+	culled = scenario->octree.cull_segment(p_from, p_to * 10000, cull, 1024);
 
+	for (int i = 0; i < culled; i++) {
 
-	for (int i=0;i<culled;i++) {
-
-		Instance *instance=cull[i];
+		Instance *instance = cull[i];
 		ERR_CONTINUE(!instance);
 		instances.push_back(instance->self);
 	}
 
 	return instances;
-
 }
-Vector<RID> VisualServerRaster::instances_cull_convex(const Vector<Plane>& p_convex,  RID p_scenario) const{
+Vector<RID> VisualServerRaster::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario) const {
 
 	Vector<RID> instances;
-	Scenario *scenario=scenario_owner.get(p_scenario);
-	ERR_FAIL_COND_V(!scenario,instances);
-	const_cast<VisualServerRaster*>(this)->_update_instances(); // check dirty instances before culling
+	Scenario *scenario = scenario_owner.get(p_scenario);
+	ERR_FAIL_COND_V(!scenario, instances);
+	const_cast<VisualServerRaster *>(this)->_update_instances(); // check dirty instances before culling
 
-	int culled=0;
+	int culled = 0;
 	Instance *cull[1024];
 
+	culled = scenario->octree.cull_convex(p_convex, cull, 1024);
 
-	culled=scenario->octree.cull_convex(p_convex,cull,1024);
-
-	for (int i=0;i<culled;i++) {
+	for (int i = 0; i < culled; i++) {
 
-		Instance *instance=cull[i];
+		Instance *instance = cull[i];
 		ERR_CONTINUE(!instance);
 		instances.push_back(instance->self);
 	}
 
 	return instances;
-
 }
 
-void VisualServerRaster::instance_geometry_set_flag(RID p_instance,InstanceFlags p_flags,bool p_enabled) {
+void VisualServerRaster::instance_geometry_set_flag(RID p_instance, InstanceFlags p_flags, bool p_enabled) {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-//	ERR_FAIL_COND( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK) );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
+	//	ERR_FAIL_COND( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK) );
 
-	switch(p_flags) {
+	switch (p_flags) {
 
 		case INSTANCE_FLAG_VISIBLE: {
 
-			instance->visible=p_enabled;
+			instance->visible = p_enabled;
 
 		} break;
 		case INSTANCE_FLAG_BILLBOARD: {
 
-			instance->data.billboard=p_enabled;
+			instance->data.billboard = p_enabled;
 
 		} break;
 		case INSTANCE_FLAG_BILLBOARD_FIX_Y: {
 
-			instance->data.billboard_y=p_enabled;
+			instance->data.billboard_y = p_enabled;
 
 		} break;
 		case INSTANCE_FLAG_CAST_SHADOW: {
 			if (p_enabled == true) {
 				instance->data.cast_shadows = SHADOW_CASTING_SETTING_ON;
-			}
-			else {
+			} else {
 				instance->data.cast_shadows = SHADOW_CASTING_SETTING_OFF;
 			}
 
 		} break;
 		case INSTANCE_FLAG_RECEIVE_SHADOWS: {
 
-			instance->data.receive_shadows=p_enabled;
+			instance->data.receive_shadows = p_enabled;
 
 		} break;
 		case INSTANCE_FLAG_DEPH_SCALE: {
 
-			instance->data.depth_scale=p_enabled;
+			instance->data.depth_scale = p_enabled;
 
 		} break;
 		case INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
 
-			instance->visible_in_all_rooms=p_enabled;
+			instance->visible_in_all_rooms = p_enabled;
 
 		} break;
-
 	}
-
 }
 
-bool VisualServerRaster::instance_geometry_get_flag(RID p_instance,InstanceFlags p_flags) const{
+bool VisualServerRaster::instance_geometry_get_flag(RID p_instance, InstanceFlags p_flags) const {
 
-	const Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, false );
-//	ERR_FAIL_COND_V( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK), false );
+	const Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, false);
+	//	ERR_FAIL_COND_V( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK), false );
 
-	switch(p_flags) {
+	switch (p_flags) {
 
 		case INSTANCE_FLAG_VISIBLE: {
 
@@ -2858,10 +2617,9 @@ bool VisualServerRaster::instance_geometry_get_flag(RID p_instance,InstanceFlags
 
 		} break;
 		case INSTANCE_FLAG_CAST_SHADOW: {
-			if(instance->data.cast_shadows == SHADOW_CASTING_SETTING_OFF) {
+			if (instance->data.cast_shadows == SHADOW_CASTING_SETTING_OFF) {
 				return false;
-			}
-			else {
+			} else {
 				return true;
 			}
 
@@ -2881,7 +2639,6 @@ bool VisualServerRaster::instance_geometry_get_flag(RID p_instance,InstanceFlags
 			return instance->visible_in_all_rooms;
 
 		} break;
-
 	}
 
 	return false;
@@ -2889,238 +2646,210 @@ bool VisualServerRaster::instance_geometry_get_flag(RID p_instance,InstanceFlags
 
 void VisualServerRaster::instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting) {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
 	instance->data.cast_shadows = p_shadow_casting_setting;
 }
 
-VS::ShadowCastingSetting VisualServerRaster::instance_geometry_get_cast_shadows_setting(RID p_instance) const{
+VS::ShadowCastingSetting VisualServerRaster::instance_geometry_get_cast_shadows_setting(RID p_instance) const {
 
-	const Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, SHADOW_CASTING_SETTING_OFF );
+	const Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, SHADOW_CASTING_SETTING_OFF);
 
 	return instance->data.cast_shadows;
 }
 
-
 void VisualServerRaster::instance_geometry_set_material_override(RID p_instance, RID p_material) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-	instance->data.material_override=p_material;
-
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
+	instance->data.material_override = p_material;
 }
 
-RID VisualServerRaster::instance_geometry_get_material_override(RID p_instance) const{
+RID VisualServerRaster::instance_geometry_get_material_override(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance, RID() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, RID());
 	return instance->data.material_override;
-
 }
 
-void VisualServerRaster::instance_geometry_set_draw_range(RID p_instance,float p_min,float p_max){
+void VisualServerRaster::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-
-	instance->draw_range_begin=p_min;
-	instance->draw_range_end=p_max;
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
+	instance->draw_range_begin = p_min;
+	instance->draw_range_end = p_max;
 }
 
-float VisualServerRaster::instance_geometry_get_draw_range_min(RID p_instance) const{
+float VisualServerRaster::instance_geometry_get_draw_range_min(RID p_instance) const {
 
-	const Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance,0 );
+	const Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, 0);
 
 	return instance->draw_range_begin;
-
-
 }
 
-float VisualServerRaster::instance_geometry_get_draw_range_max(RID p_instance) const{
+float VisualServerRaster::instance_geometry_get_draw_range_max(RID p_instance) const {
 
-	const Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance,0 );
+	const Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, 0);
 
 	return instance->draw_range_end;
-
-
 }
 
-
-void VisualServerRaster::instance_geometry_set_baked_light(RID p_instance,RID p_baked_light) {
+void VisualServerRaster::instance_geometry_set_baked_light(RID p_instance, RID p_baked_light) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
 	if (instance->baked_light) {
 
-
 		instance->baked_light->baked_light_info->owned_instances.erase(instance->BLE);
-		instance->BLE=NULL;
-		instance->baked_light=NULL;
-		instance->data.baked_light=NULL;
-		instance->data.baked_light_octree_xform=NULL;
-
+		instance->BLE = NULL;
+		instance->baked_light = NULL;
+		instance->data.baked_light = NULL;
+		instance->data.baked_light_octree_xform = NULL;
 	}
 
 	if (!p_baked_light.is_valid())
 		return;
-	Instance *bl_instance = instance_owner.get( p_baked_light );
-	ERR_FAIL_COND( !bl_instance );
-	ERR_FAIL_COND( bl_instance->base_type!=INSTANCE_BAKED_LIGHT );
-
-	instance->baked_light=bl_instance;
-	instance->BLE=bl_instance->baked_light_info->owned_instances.push_back(instance);
-	instance->data.baked_light=&bl_instance->baked_light_info->baked_light->data;
-	instance->data.baked_light_octree_xform=&bl_instance->baked_light_info->affine_inverse;
+	Instance *bl_instance = instance_owner.get(p_baked_light);
+	ERR_FAIL_COND(!bl_instance);
+	ERR_FAIL_COND(bl_instance->base_type != INSTANCE_BAKED_LIGHT);
 
+	instance->baked_light = bl_instance;
+	instance->BLE = bl_instance->baked_light_info->owned_instances.push_back(instance);
+	instance->data.baked_light = &bl_instance->baked_light_info->baked_light->data;
+	instance->data.baked_light_octree_xform = &bl_instance->baked_light_info->affine_inverse;
 }
 
-RID VisualServerRaster::instance_geometry_get_baked_light(RID p_instance) const{
+RID VisualServerRaster::instance_geometry_get_baked_light(RID p_instance) const {
 
-	const Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance,RID() );
+	const Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, RID());
 	if (instance->baked_light)
 		return instance->baked_light->self;
 	return RID();
-
 }
 
-
-void VisualServerRaster::instance_geometry_set_baked_light_sampler(RID p_instance,RID p_baked_light_sampler) {
+void VisualServerRaster::instance_geometry_set_baked_light_sampler(RID p_instance, RID p_baked_light_sampler) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
 	if (instance->sampled_light) {
 		instance->sampled_light->baked_light_sampler_info->owned_instances.erase(instance);
-		instance->data.sampled_light=RID();
+		instance->data.sampled_light = RID();
 	}
 
-	if(p_baked_light_sampler.is_valid()) {
-		Instance *sampler_instance = instance_owner.get( p_baked_light_sampler );
-		ERR_FAIL_COND( !sampler_instance );
-		ERR_FAIL_COND( sampler_instance->base_type!=INSTANCE_BAKED_LIGHT_SAMPLER );
-		instance->sampled_light=sampler_instance;
+	if (p_baked_light_sampler.is_valid()) {
+		Instance *sampler_instance = instance_owner.get(p_baked_light_sampler);
+		ERR_FAIL_COND(!sampler_instance);
+		ERR_FAIL_COND(sampler_instance->base_type != INSTANCE_BAKED_LIGHT_SAMPLER);
+		instance->sampled_light = sampler_instance;
 		instance->sampled_light->baked_light_sampler_info->owned_instances.insert(instance);
 	} else {
-		instance->sampled_light=NULL;
+		instance->sampled_light = NULL;
 	}
 
-	instance->data.sampled_light=RID();
-
+	instance->data.sampled_light = RID();
 }
 
 RID VisualServerRaster::instance_geometry_get_baked_light_sampler(RID p_instance) const {
 
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance,RID() );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, RID());
 
 	if (instance->sampled_light)
 		return instance->sampled_light->self;
 	else
 		return RID();
-
 }
 
-
-void VisualServerRaster::instance_geometry_set_baked_light_texture_index(RID p_instance,int p_tex_id){
+void VisualServerRaster::instance_geometry_set_baked_light_texture_index(RID p_instance, int p_tex_id) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-
-	instance->data.baked_lightmap_id=p_tex_id;
-
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
 
+	instance->data.baked_lightmap_id = p_tex_id;
 }
-int VisualServerRaster::instance_geometry_get_baked_light_texture_index(RID p_instance) const{
+int VisualServerRaster::instance_geometry_get_baked_light_texture_index(RID p_instance) const {
 
-	const Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance,0 );
+	const Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, 0);
 
 	return instance->data.baked_lightmap_id;
-
 }
 
-
 void VisualServerRaster::_update_instance(Instance *p_instance) {
 
 	p_instance->version++;
 
 	if (p_instance->base_type == INSTANCE_LIGHT) {
 
-		rasterizer->light_instance_set_transform( p_instance->light_info->instance, p_instance->data.transform );
-
+		rasterizer->light_instance_set_transform(p_instance->light_info->instance, p_instance->data.transform);
 	}
 
-
 	if (p_instance->aabb.has_no_surface())
 		return;
 
-
 	if (p_instance->base_type == INSTANCE_PARTICLES) {
 
-		rasterizer->particles_instance_set_transform( p_instance->particles_info->instance, p_instance->data.transform );
+		rasterizer->particles_instance_set_transform(p_instance->particles_info->instance, p_instance->data.transform);
 	}
 
-
-	if ((1<<p_instance->base_type)&INSTANCE_GEOMETRY_MASK) {
+	if ((1 << p_instance->base_type) & INSTANCE_GEOMETRY_MASK) {
 
 		//make sure lights are updated
-		InstanceSet::Element *E=p_instance->lights.front();
-		while(E) {
+		InstanceSet::Element *E = p_instance->lights.front();
+		while (E) {
 
 			E->get()->version++;
-			E=E->next();
+			E = E->next();
 		}
 
 	} else if (p_instance->base_type == INSTANCE_ROOM) {
 
-		p_instance->room_info->affine_inverse=p_instance->data.transform.affine_inverse();
+		p_instance->room_info->affine_inverse = p_instance->data.transform.affine_inverse();
 	} else if (p_instance->base_type == INSTANCE_BAKED_LIGHT) {
 
 		Transform scale;
 		scale.basis.scale(p_instance->baked_light_info->baked_light->octree_aabb.size);
-		scale.origin=p_instance->baked_light_info->baked_light->octree_aabb.pos;
+		scale.origin = p_instance->baked_light_info->baked_light->octree_aabb.pos;
 		//print_line("scale: "+scale);
-		p_instance->baked_light_info->affine_inverse=(p_instance->data.transform*scale).affine_inverse();
+		p_instance->baked_light_info->affine_inverse = (p_instance->data.transform * scale).affine_inverse();
 	}
 
-
-
 	p_instance->data.mirror = p_instance->data.transform.basis.determinant() < 0.0;
 
 	AABB new_aabb;
 
-	if (p_instance->base_type==INSTANCE_PORTAL) {
+	if (p_instance->base_type == INSTANCE_PORTAL) {
 
 		//portals need to be transformed in a special way, so they don't become too wide if they have scale..
 		Transform portal_xform = p_instance->data.transform;
-		portal_xform.basis.set_axis(2,portal_xform.basis.get_axis(2).normalized());
+		portal_xform.basis.set_axis(2, portal_xform.basis.get_axis(2).normalized());
 
-		p_instance->portal_info->plane_cache=Plane( p_instance->data.transform.origin, portal_xform.basis.get_axis(2));
-		int point_count=p_instance->portal_info->portal->shape.size();
+		p_instance->portal_info->plane_cache = Plane(p_instance->data.transform.origin, portal_xform.basis.get_axis(2));
+		int point_count = p_instance->portal_info->portal->shape.size();
 		p_instance->portal_info->transformed_point_cache.resize(point_count);
 
 		AABB portal_aabb;
 
-		for(int i=0;i<point_count;i++) {
+		for (int i = 0; i < point_count; i++) {
 
 			Point2 src = p_instance->portal_info->portal->shape[i];
-			Vector3 point = portal_xform.xform(Vector3(src.x,src.y,0));
-			p_instance->portal_info->transformed_point_cache[i]=point;
-			if (i==0)
-				portal_aabb.pos=point;
+			Vector3 point = portal_xform.xform(Vector3(src.x, src.y, 0));
+			p_instance->portal_info->transformed_point_cache[i] = point;
+			if (i == 0)
+				portal_aabb.pos = point;
 			else
 				portal_aabb.expand_to(point);
 		}
@@ -3134,104 +2863,95 @@ void VisualServerRaster::_update_instance(Instance *p_instance) {
 		new_aabb = p_instance->data.transform.xform(p_instance->aabb);
 	}
 
-
-	for(InstanceSet::Element *E=p_instance->lights.front();E;E=E->next()) {
+	for (InstanceSet::Element *E = p_instance->lights.front(); E; E = E->next()) {
 		Instance *light = E->get();
 		light->version++;
 	}
 
-
-	p_instance->transformed_aabb=new_aabb;
+	p_instance->transformed_aabb = new_aabb;
 
 	if (!p_instance->scenario) {
 
-
 		return;
 	}
 
+	if (p_instance->octree_id == 0) {
 
-
-	if (p_instance->octree_id==0) {
-
-		uint32_t base_type = 1<<p_instance->base_type;
-		uint32_t pairable_mask=0;
-		bool pairable=false;
+		uint32_t base_type = 1 << p_instance->base_type;
+		uint32_t pairable_mask = 0;
+		bool pairable = false;
 
 		if (p_instance->base_type == INSTANCE_LIGHT) {
 
-			pairable_mask=p_instance->light_info->enabled?INSTANCE_GEOMETRY_MASK:0;
-			pairable=true;
+			pairable_mask = p_instance->light_info->enabled ? INSTANCE_GEOMETRY_MASK : 0;
+			pairable = true;
 		}
 
 		if (p_instance->base_type == INSTANCE_PORTAL) {
 
-			pairable_mask=(1<<INSTANCE_PORTAL);
-			pairable=true;
+			pairable_mask = (1 << INSTANCE_PORTAL);
+			pairable = true;
 		}
 
 		if (p_instance->base_type == INSTANCE_BAKED_LIGHT_SAMPLER) {
 
-			pairable_mask=(1<<INSTANCE_BAKED_LIGHT);
-			pairable=true;
+			pairable_mask = (1 << INSTANCE_BAKED_LIGHT);
+			pairable = true;
 		}
 
+		if (!p_instance->room && (1 << p_instance->base_type) & INSTANCE_GEOMETRY_MASK) {
 
-		if (!p_instance->room && (1<<p_instance->base_type)&INSTANCE_GEOMETRY_MASK) {
-
-			base_type|=INSTANCE_ROOMLESS_MASK;
+			base_type |= INSTANCE_ROOMLESS_MASK;
 		}
 
 		if (p_instance->base_type == INSTANCE_ROOM) {
 
-			pairable_mask=INSTANCE_ROOMLESS_MASK;
-			pairable=true;
+			pairable_mask = INSTANCE_ROOMLESS_MASK;
+			pairable = true;
 		}
 
-
 		// not inside octree
-		p_instance->octree_id = p_instance->scenario->octree.create(p_instance,new_aabb,0,pairable,base_type,pairable_mask);
+		p_instance->octree_id = p_instance->scenario->octree.create(p_instance, new_aabb, 0, pairable, base_type, pairable_mask);
 
 	} else {
 
-	//	if (new_aabb==p_instance->data.transformed_aabb)
-	//		return;
+		//	if (new_aabb==p_instance->data.transformed_aabb)
+		//		return;
 
-		p_instance->scenario->octree.move(p_instance->octree_id,new_aabb);
+		p_instance->scenario->octree.move(p_instance->octree_id, new_aabb);
 	}
 
-	if (p_instance->base_type==INSTANCE_PORTAL) {
+	if (p_instance->base_type == INSTANCE_PORTAL) {
 
 		_portal_attempt_connect(p_instance);
 	}
 
-	if (!p_instance->room && (1<<p_instance->base_type)&INSTANCE_GEOMETRY_MASK) {
+	if (!p_instance->room && (1 << p_instance->base_type) & INSTANCE_GEOMETRY_MASK) {
 
 		_instance_validate_autorooms(p_instance);
 	}
 
 	if (p_instance->base_type == INSTANCE_ROOM) {
 
-		for(Set<Instance*>::Element *E=p_instance->room_info->owned_autoroom_geometry.front();E;E=E->next())
+		for (Set<Instance *>::Element *E = p_instance->room_info->owned_autoroom_geometry.front(); E; E = E->next())
 			_instance_validate_autorooms(E->get());
 	}
-
-
 }
 
 void VisualServerRaster::_update_instance_aabb(Instance *p_instance) {
 
 	AABB new_aabb;
 
-	ERR_FAIL_COND(p_instance->base_type!=INSTANCE_NONE && !p_instance->base_rid.is_valid());
+	ERR_FAIL_COND(p_instance->base_type != INSTANCE_NONE && !p_instance->base_rid.is_valid());
 
-	switch(p_instance->base_type) {
+	switch (p_instance->base_type) {
 		case VisualServer::INSTANCE_NONE: {
 
 			// do nothing
 		} break;
 		case VisualServer::INSTANCE_MESH: {
 
-			new_aabb = rasterizer->mesh_get_aabb(p_instance->base_rid,p_instance->data.skeleton);
+			new_aabb = rasterizer->mesh_get_aabb(p_instance->base_rid, p_instance->data.skeleton);
 
 		} break;
 		case VisualServer::INSTANCE_MULTIMESH: {
@@ -3243,13 +2963,11 @@ void VisualServerRaster::_update_instance_aabb(Instance *p_instance) {
 
 			new_aabb = rasterizer->immediate_get_aabb(p_instance->base_rid);
 
-
 		} break;
 		case VisualServer::INSTANCE_PARTICLES: {
 
 			new_aabb = rasterizer->particles_get_aabb(p_instance->base_rid);
 
-
 		} break;
 		case VisualServer::INSTANCE_LIGHT: {
 
@@ -3258,22 +2976,22 @@ void VisualServerRaster::_update_instance_aabb(Instance *p_instance) {
 		} break;
 		case VisualServer::INSTANCE_ROOM: {
 
-			Room *room = room_owner.get( p_instance->base_rid );
+			Room *room = room_owner.get(p_instance->base_rid);
 			ERR_FAIL_COND(!room);
-			new_aabb=room->bounds.get_aabb();
+			new_aabb = room->bounds.get_aabb();
 
 		} break;
 		case VisualServer::INSTANCE_PORTAL: {
 
-			Portal *portal = portal_owner.get( p_instance->base_rid );
+			Portal *portal = portal_owner.get(p_instance->base_rid);
 			ERR_FAIL_COND(!portal);
-			for (int i=0;i<portal->shape.size();i++) {
+			for (int i = 0; i < portal->shape.size(); i++) {
 
-				Vector3 point( portal->shape[i].x, portal->shape[i].y, 0 );
-				if (i==0) {
+				Vector3 point(portal->shape[i].x, portal->shape[i].y, 0);
+				if (i == 0) {
 
-					new_aabb.pos=point;
-					new_aabb.size.z=0.01; // make it not flat for octree
+					new_aabb.pos = point;
+					new_aabb.size.z = 0.01; // make it not flat for octree
 				} else {
 
 					new_aabb.expand_to(point);
@@ -3283,18 +3001,18 @@ void VisualServerRaster::_update_instance_aabb(Instance *p_instance) {
 		} break;
 		case VisualServer::INSTANCE_BAKED_LIGHT: {
 
-			BakedLight *baked_light = baked_light_owner.get( p_instance->base_rid );
+			BakedLight *baked_light = baked_light_owner.get(p_instance->base_rid);
 			ERR_FAIL_COND(!baked_light);
-			new_aabb=baked_light->octree_aabb;
+			new_aabb = baked_light->octree_aabb;
 
 		} break;
 		case VisualServer::INSTANCE_BAKED_LIGHT_SAMPLER: {
 
-			BakedLightSampler *baked_light_sampler = baked_light_sampler_owner.get( p_instance->base_rid );
+			BakedLightSampler *baked_light_sampler = baked_light_sampler_owner.get(p_instance->base_rid);
 			ERR_FAIL_COND(!baked_light_sampler);
 			float radius = baked_light_sampler->params[VS::BAKED_LIGHT_SAMPLER_RADIUS];
 
-			new_aabb=AABB(Vector3(-radius,-radius,-radius),Vector3(radius*2,radius*2,radius*2));
+			new_aabb = AABB(Vector3(-radius, -radius, -radius), Vector3(radius * 2, radius * 2, radius * 2));
 
 		} break;
 
@@ -3304,59 +3022,57 @@ void VisualServerRaster::_update_instance_aabb(Instance *p_instance) {
 	if (p_instance->extra_margin)
 		new_aabb.grow_by(p_instance->extra_margin);
 
-	p_instance->aabb=new_aabb;
-
+	p_instance->aabb = new_aabb;
 }
 
 void VisualServerRaster::_update_instances() {
 
-	while(instance_update_list) {
+	while (instance_update_list) {
 
-		Instance *instance=instance_update_list;
+		Instance *instance = instance_update_list;
 
-		instance_update_list=instance_update_list->update_next;
+		instance_update_list = instance_update_list->update_next;
 
 		if (instance->update_aabb)
 			_update_instance_aabb(instance);
 
 		if (instance->update_materials) {
-			if (instance->base_type==INSTANCE_MESH) {
+			if (instance->base_type == INSTANCE_MESH) {
 				instance->data.materials.resize(rasterizer->mesh_get_surface_count(instance->base_rid));
 			}
 		}
 
 		_update_instance(instance);
 
-		instance->update=false;
-		instance->update_aabb=false;
-		instance->update_materials=false;
-		instance->update_next=0;
+		instance->update = false;
+		instance->update_aabb = false;
+		instance->update_materials = false;
+		instance->update_next = 0;
 	}
 }
 
-void VisualServerRaster::instance_light_set_enabled(RID p_instance,bool p_enabled) {
+void VisualServerRaster::instance_light_set_enabled(RID p_instance, bool p_enabled) {
 
 	VS_CHANGED;
-	Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND( !instance );
-	ERR_FAIL_COND( instance->base_type!=INSTANCE_LIGHT );
+	Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND(!instance);
+	ERR_FAIL_COND(instance->base_type != INSTANCE_LIGHT);
 
-	if (p_enabled==instance->light_info->enabled)
+	if (p_enabled == instance->light_info->enabled)
 		return;
 
-	instance->light_info->enabled=p_enabled;
-	if (light_get_type(instance->base_rid)!=VS::LIGHT_DIRECTIONAL && instance->octree_id && instance->scenario)
-		instance->scenario->octree.set_pairable(instance->octree_id,p_enabled,1<<INSTANCE_LIGHT,p_enabled?INSTANCE_GEOMETRY_MASK:0);
+	instance->light_info->enabled = p_enabled;
+	if (light_get_type(instance->base_rid) != VS::LIGHT_DIRECTIONAL && instance->octree_id && instance->scenario)
+		instance->scenario->octree.set_pairable(instance->octree_id, p_enabled, 1 << INSTANCE_LIGHT, p_enabled ? INSTANCE_GEOMETRY_MASK : 0);
 
 	//_instance_queue_update( instance , true );
-
 }
 
 bool VisualServerRaster::instance_light_is_enabled(RID p_instance) const {
 
-	const Instance *instance = instance_owner.get( p_instance );
-	ERR_FAIL_COND_V( !instance,false );
-	ERR_FAIL_COND_V( instance->base_type!=INSTANCE_LIGHT,false );
+	const Instance *instance = instance_owner.get(p_instance);
+	ERR_FAIL_COND_V(!instance, false);
+	ERR_FAIL_COND_V(instance->base_type != INSTANCE_LIGHT, false);
 
 	return instance->light_info->enabled;
 }
@@ -3364,60 +3080,56 @@ bool VisualServerRaster::instance_light_is_enabled(RID p_instance) const {
 /****** CANVAS *********/
 RID VisualServerRaster::canvas_create() {
 
-	Canvas * canvas = memnew( Canvas );
-	ERR_FAIL_COND_V(!canvas,RID());
-	RID rid = canvas_owner.make_rid( canvas );
+	Canvas *canvas = memnew(Canvas);
+	ERR_FAIL_COND_V(!canvas, RID());
+	RID rid = canvas_owner.make_rid(canvas);
 
 	return rid;
 }
 
+void VisualServerRaster::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring) {
 
-void VisualServerRaster::canvas_set_item_mirroring(RID p_canvas,RID p_item,const Point2& p_mirroring) {
-
-	Canvas * canvas = canvas_owner.get(p_canvas);
+	Canvas *canvas = canvas_owner.get(p_canvas);
 	ERR_FAIL_COND(!canvas);
 	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	int idx = canvas->find_item(canvas_item);
-	ERR_FAIL_COND(idx==-1);
-	canvas->child_items[idx].mirror=p_mirroring;
-
+	ERR_FAIL_COND(idx == -1);
+	canvas->child_items[idx].mirror = p_mirroring;
 }
 
-Point2 VisualServerRaster::canvas_get_item_mirroring(RID p_canvas,RID p_item) const {
+Point2 VisualServerRaster::canvas_get_item_mirroring(RID p_canvas, RID p_item) const {
 
-	Canvas * canvas = canvas_owner.get(p_canvas);
-	ERR_FAIL_COND_V(!canvas,Point2());
-	CanvasItem *canvas_item = memnew( CanvasItem );
-	ERR_FAIL_COND_V(!canvas_item,Point2());
+	Canvas *canvas = canvas_owner.get(p_canvas);
+	ERR_FAIL_COND_V(!canvas, Point2());
+	CanvasItem *canvas_item = memnew(CanvasItem);
+	ERR_FAIL_COND_V(!canvas_item, Point2());
 
 	int idx = canvas->find_item(canvas_item);
-	ERR_FAIL_COND_V(idx==-1,Point2());
+	ERR_FAIL_COND_V(idx == -1, Point2());
 	return canvas->child_items[idx].mirror;
 }
 
-void VisualServerRaster::canvas_set_modulate(RID p_canvas,const Color& p_color) {
+void VisualServerRaster::canvas_set_modulate(RID p_canvas, const Color &p_color) {
 
-	Canvas * canvas = canvas_owner.get(p_canvas);
+	Canvas *canvas = canvas_owner.get(p_canvas);
 	ERR_FAIL_COND(!canvas);
-	canvas->modulate=p_color;
+	canvas->modulate = p_color;
 }
 
-
-
 RID VisualServerRaster::canvas_item_create() {
 
-	CanvasItem *canvas_item = memnew( CanvasItem );
-	ERR_FAIL_COND_V(!canvas_item,RID());
+	CanvasItem *canvas_item = memnew(CanvasItem);
+	ERR_FAIL_COND_V(!canvas_item, RID());
 
-	return canvas_item_owner.make_rid( canvas_item );
+	return canvas_item_owner.make_rid(canvas_item);
 }
 
-void VisualServerRaster::canvas_item_set_parent(RID p_item,RID p_parent) {
+void VisualServerRaster::canvas_item_set_parent(RID p_item, RID p_parent) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	if (canvas_item->parent.is_valid()) {
@@ -3432,16 +3144,15 @@ void VisualServerRaster::canvas_item_set_parent(RID p_item,RID p_parent) {
 			item_owner->child_items.erase(canvas_item);
 		}
 
-		canvas_item->parent=RID();
+		canvas_item->parent = RID();
 	}
 
-
 	if (p_parent.is_valid()) {
 		if (canvas_owner.owns(p_parent)) {
 
 			Canvas *canvas = canvas_owner.get(p_parent);
 			Canvas::ChildItem ci;
-			ci.item=canvas_item;
+			ci.item = canvas_item;
 			canvas->child_items.push_back(ci);
 		} else if (canvas_item_owner.owns(p_parent)) {
 
@@ -3453,86 +3164,75 @@ void VisualServerRaster::canvas_item_set_parent(RID p_item,RID p_parent) {
 			ERR_EXPLAIN("Invalid parent");
 			ERR_FAIL();
 		}
-
-
 	}
 
-	canvas_item->parent=p_parent;
-
-
+	canvas_item->parent = p_parent;
 }
 
 RID VisualServerRaster::canvas_item_get_parent(RID p_canvas_item) const {
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
-	ERR_FAIL_COND_V(!canvas_item,RID());
+	CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
+	ERR_FAIL_COND_V(!canvas_item, RID());
 
 	return canvas_item->parent;
 }
 
-void VisualServerRaster::canvas_item_set_visible(RID p_item,bool p_visible) {
+void VisualServerRaster::canvas_item_set_visible(RID p_item, bool p_visible) {
 
 	VS_CHANGED;
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	canvas_item->visible=p_visible;
+	canvas_item->visible = p_visible;
 }
 
-
 bool VisualServerRaster::canvas_item_is_visible(RID p_item) const {
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
-	ERR_FAIL_COND_V(!canvas_item,RID());
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
+	ERR_FAIL_COND_V(!canvas_item, RID());
 
 	return canvas_item->visible;
-
 }
 
-void VisualServerRaster::canvas_item_set_light_mask(RID p_canvas_item,int p_mask) {
+void VisualServerRaster::canvas_item_set_light_mask(RID p_canvas_item, int p_mask) {
 
 	VS_CHANGED;
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	if (canvas_item->light_mask==p_mask)
+	if (canvas_item->light_mask == p_mask)
 		return;
 	VS_CHANGED;
 
-	canvas_item->light_mask=p_mask;
-
+	canvas_item->light_mask = p_mask;
 }
 
-
-void VisualServerRaster::canvas_item_set_blend_mode(RID p_canvas_item,MaterialBlendMode p_blend) {
+void VisualServerRaster::canvas_item_set_blend_mode(RID p_canvas_item, MaterialBlendMode p_blend) {
 
 	VS_CHANGED;
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	if (canvas_item->blend_mode==p_blend)
+	if (canvas_item->blend_mode == p_blend)
 		return;
 	VS_CHANGED;
 
-	canvas_item->blend_mode=p_blend;
-
+	canvas_item->blend_mode = p_blend;
 }
 
 void VisualServerRaster::canvas_item_attach_viewport(RID p_canvas_item, RID p_viewport) {
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	VS_CHANGED;
 
-	canvas_item->viewport=p_viewport;
-
+	canvas_item->viewport = p_viewport;
 }
 
-
 /*
 void VisualServerRaster::canvas_item_set_rect(RID p_item, const Rect2& p_rect) {
 	VS_CHANGED;
@@ -3544,257 +3244,242 @@ void VisualServerRaster::canvas_item_set_rect(RID p_item, const Rect2& p_rect) {
 
 void VisualServerRaster::canvas_item_set_clip(RID p_item, bool p_clip) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	canvas_item->clip=p_clip;
+	canvas_item->clip = p_clip;
 }
 
 void VisualServerRaster::canvas_item_set_distance_field_mode(RID p_item, bool p_distance_field) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	canvas_item->distance_field=p_distance_field;
+	canvas_item->distance_field = p_distance_field;
 }
 
-
-void VisualServerRaster::canvas_item_set_transform(RID p_item, const Matrix32& p_transform) {
+void VisualServerRaster::canvas_item_set_transform(RID p_item, const Matrix32 &p_transform) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	canvas_item->xform=p_transform;
-
+	canvas_item->xform = p_transform;
 }
 
-
-void VisualServerRaster::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect,const Rect2& p_rect) {
+void VisualServerRaster::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	canvas_item->custom_rect=p_custom_rect;
+	canvas_item->custom_rect = p_custom_rect;
 	if (p_custom_rect)
-		canvas_item->rect=p_rect;
-
+		canvas_item->rect = p_rect;
 }
 
 void VisualServerRaster::canvas_item_set_opacity(RID p_item, float p_opacity) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->opacity=p_opacity;
-
+	canvas_item->opacity = p_opacity;
 }
 float VisualServerRaster::canvas_item_get_opacity(RID p_item, float p_opacity) const {
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
-	ERR_FAIL_COND_V(!canvas_item,-1);
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
+	ERR_FAIL_COND_V(!canvas_item, -1);
 	return canvas_item->opacity;
-
 }
 
 void VisualServerRaster::canvas_item_set_on_top(RID p_item, bool p_on_top) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->ontop=p_on_top;
-
+	canvas_item->ontop = p_on_top;
 }
 
-bool VisualServerRaster::canvas_item_is_on_top(RID p_item) const{
-	const CanvasItem *canvas_item = canvas_item_owner.get( p_item );
-	ERR_FAIL_COND_V(!canvas_item,false);
+bool VisualServerRaster::canvas_item_is_on_top(RID p_item) const {
+	const CanvasItem *canvas_item = canvas_item_owner.get(p_item);
+	ERR_FAIL_COND_V(!canvas_item, false);
 	return canvas_item->ontop;
-
 }
 
-
 void VisualServerRaster::canvas_item_set_self_opacity(RID p_item, float p_self_opacity) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->self_opacity=p_self_opacity;
-
+	canvas_item->self_opacity = p_self_opacity;
 }
 float VisualServerRaster::canvas_item_get_self_opacity(RID p_item, float p_self_opacity) const {
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
-	ERR_FAIL_COND_V(!canvas_item,-1);
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
+	ERR_FAIL_COND_V(!canvas_item, -1);
 	return canvas_item->self_opacity;
-
 }
 
-
-void VisualServerRaster::canvas_item_add_line(RID p_item, const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width) {
+void VisualServerRaster::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandLine * line = memnew( CanvasItem::CommandLine );
+	CanvasItem::CommandLine *line = memnew(CanvasItem::CommandLine);
 	ERR_FAIL_COND(!line);
-	line->color=p_color;
-	line->from=p_from;
-	line->to=p_to;
-	line->width=p_width;
-	canvas_item->rect_dirty=true;
-
+	line->color = p_color;
+	line->from = p_from;
+	line->to = p_to;
+	line->width = p_width;
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(line);
 }
 
-void VisualServerRaster::canvas_item_add_rect(RID p_item, const Rect2& p_rect, const Color& p_color) {
+void VisualServerRaster::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
+	CanvasItem::CommandRect *rect = memnew(CanvasItem::CommandRect);
 	ERR_FAIL_COND(!rect);
-	rect->modulate=p_color;
-	rect->rect=p_rect;
-	canvas_item->rect_dirty=true;
+	rect->modulate = p_color;
+	rect->rect = p_rect;
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(rect);
 }
 
-void VisualServerRaster::canvas_item_add_circle(RID p_item, const Point2& p_pos, float p_radius,const Color& p_color) {
+void VisualServerRaster::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandCircle * circle = memnew( CanvasItem::CommandCircle );
+	CanvasItem::CommandCircle *circle = memnew(CanvasItem::CommandCircle);
 	ERR_FAIL_COND(!circle);
-	circle->color=p_color;
-	circle->pos=p_pos;
-	circle->radius=p_radius;
+	circle->color = p_color;
+	circle->pos = p_pos;
+	circle->radius = p_radius;
 
 	canvas_item->commands.push_back(circle);
-
 }
 
-void VisualServerRaster::canvas_item_add_texture_rect(RID p_item, const Rect2& p_rect, RID p_texture,bool p_tile,const Color& p_modulate,bool p_transpose) {
+void VisualServerRaster::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
+	CanvasItem::CommandRect *rect = memnew(CanvasItem::CommandRect);
 	ERR_FAIL_COND(!rect);
-	rect->modulate=p_modulate;
-	rect->rect=p_rect;
-	rect->flags=0;
+	rect->modulate = p_modulate;
+	rect->rect = p_rect;
+	rect->flags = 0;
 	if (p_tile) {
-		rect->flags|=Rasterizer::CANVAS_RECT_TILE;
-		rect->flags|=Rasterizer::CANVAS_RECT_REGION;
-		rect->source=Rect2(0,0,p_rect.size.width,p_rect.size.height);
+		rect->flags |= Rasterizer::CANVAS_RECT_TILE;
+		rect->flags |= Rasterizer::CANVAS_RECT_REGION;
+		rect->source = Rect2(0, 0, p_rect.size.width, p_rect.size.height);
 	}
 
-	if (p_rect.size.x<0) {
+	if (p_rect.size.x < 0) {
 
-		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_H;
+		rect->flags |= Rasterizer::CANVAS_RECT_FLIP_H;
 		rect->rect.size.x = -rect->rect.size.x;
 	}
-	if (p_rect.size.y<0) {
+	if (p_rect.size.y < 0) {
 
-		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_V;
+		rect->flags |= Rasterizer::CANVAS_RECT_FLIP_V;
 		rect->rect.size.y = -rect->rect.size.y;
 	}
 	if (p_transpose) {
-		rect->flags|=Rasterizer::CANVAS_RECT_TRANSPOSE;
+		rect->flags |= Rasterizer::CANVAS_RECT_TRANSPOSE;
 		SWAP(rect->rect.size.x, rect->rect.size.y);
 	}
-	rect->texture=p_texture;
-	canvas_item->rect_dirty=true;
+	rect->texture = p_texture;
+	canvas_item->rect_dirty = true;
 	canvas_item->commands.push_back(rect);
 }
 
-void VisualServerRaster::canvas_item_add_texture_rect_region(RID p_item, const Rect2& p_rect, RID p_texture,const Rect2& p_src_rect,const Color& p_modulate,bool p_transpose)  {
+void VisualServerRaster::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
+	CanvasItem::CommandRect *rect = memnew(CanvasItem::CommandRect);
 	ERR_FAIL_COND(!rect);
-	rect->modulate=p_modulate;
-	rect->rect=p_rect;
-	rect->texture=p_texture;
-	rect->source=p_src_rect;
-	rect->flags=Rasterizer::CANVAS_RECT_REGION;
+	rect->modulate = p_modulate;
+	rect->rect = p_rect;
+	rect->texture = p_texture;
+	rect->source = p_src_rect;
+	rect->flags = Rasterizer::CANVAS_RECT_REGION;
 
-	if (p_rect.size.x<0) {
+	if (p_rect.size.x < 0) {
 
-		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_H;
+		rect->flags |= Rasterizer::CANVAS_RECT_FLIP_H;
 		rect->rect.size.x = -rect->rect.size.x;
 	}
-	if (p_rect.size.y<0) {
+	if (p_rect.size.y < 0) {
 
-		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_V;
+		rect->flags |= Rasterizer::CANVAS_RECT_FLIP_V;
 		rect->rect.size.y = -rect->rect.size.y;
 	}
 	if (p_transpose) {
-		rect->flags|=Rasterizer::CANVAS_RECT_TRANSPOSE;
+		rect->flags |= Rasterizer::CANVAS_RECT_TRANSPOSE;
 		SWAP(rect->rect.size.x, rect->rect.size.y);
 	}
 
-	canvas_item->rect_dirty=true;
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(rect);
-
 }
 
-void VisualServerRaster::canvas_item_add_style_box(RID p_item, const Rect2& p_rect, const Rect2& p_source, RID p_texture, const Vector2& p_topleft, const Vector2& p_bottomright, bool p_draw_center,const Color& p_modulate) {
+void VisualServerRaster::canvas_item_add_style_box(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, bool p_draw_center, const Color &p_modulate) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandStyle * style = memnew( CanvasItem::CommandStyle );
+	CanvasItem::CommandStyle *style = memnew(CanvasItem::CommandStyle);
 	ERR_FAIL_COND(!style);
-	style->texture=p_texture;
-	style->rect=p_rect;
-	style->source=p_source;
-	style->draw_center=p_draw_center;
-	style->color=p_modulate;
-	style->margin[MARGIN_LEFT]=p_topleft.x;
-	style->margin[MARGIN_TOP]=p_topleft.y;
-	style->margin[MARGIN_RIGHT]=p_bottomright.x;
-	style->margin[MARGIN_BOTTOM]=p_bottomright.y;
-	canvas_item->rect_dirty=true;
+	style->texture = p_texture;
+	style->rect = p_rect;
+	style->source = p_source;
+	style->draw_center = p_draw_center;
+	style->color = p_modulate;
+	style->margin[MARGIN_LEFT] = p_topleft.x;
+	style->margin[MARGIN_TOP] = p_topleft.y;
+	style->margin[MARGIN_RIGHT] = p_bottomright.x;
+	style->margin[MARGIN_BOTTOM] = p_bottomright.y;
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(style);
 }
-void VisualServerRaster::canvas_item_add_primitive(RID p_item,const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture,float p_width) {
+void VisualServerRaster::canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandPrimitive * prim = memnew( CanvasItem::CommandPrimitive );
+	CanvasItem::CommandPrimitive *prim = memnew(CanvasItem::CommandPrimitive);
 	ERR_FAIL_COND(!prim);
-	prim->texture=p_texture;
-	prim->points=p_points;
-	prim->uvs=p_uvs;
-	prim->colors=p_colors;
-	prim->width=p_width;
-	canvas_item->rect_dirty=true;
+	prim->texture = p_texture;
+	prim->points = p_points;
+	prim->uvs = p_uvs;
+	prim->colors = p_colors;
+	prim->width = p_width;
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(prim);
 }
 
-void VisualServerRaster::canvas_item_add_polygon(RID p_item, const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture) {
+void VisualServerRaster::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 #ifdef DEBUG_ENABLED
 	int pointcount = p_points.size();
-	ERR_FAIL_COND(pointcount<3);
-	int color_size=p_colors.size();
-	int uv_size=p_uvs.size();
-	ERR_FAIL_COND(color_size!=0 && color_size!=1 && color_size!=pointcount);
-	ERR_FAIL_COND(uv_size!=0 && (uv_size!=pointcount || !p_texture.is_valid()));
+	ERR_FAIL_COND(pointcount < 3);
+	int color_size = p_colors.size();
+	int uv_size = p_uvs.size();
+	ERR_FAIL_COND(color_size != 0 && color_size != 1 && color_size != pointcount);
+	ERR_FAIL_COND(uv_size != 0 && (uv_size != pointcount || !p_texture.is_valid()));
 #endif
 	Vector<int> indices = Geometry::triangulate_polygon(p_points);
 
@@ -3804,52 +3489,51 @@ void VisualServerRaster::canvas_item_add_polygon(RID p_item, const Vector<Point2
 		ERR_FAIL_V();
 	}
 
-	CanvasItem::CommandPolygon * polygon = memnew( CanvasItem::CommandPolygon );
+	CanvasItem::CommandPolygon *polygon = memnew(CanvasItem::CommandPolygon);
 	ERR_FAIL_COND(!polygon);
-	polygon->texture=p_texture;
-	polygon->points=p_points;
-	polygon->uvs=p_uvs;
-	polygon->colors=p_colors;
-	polygon->indices=indices;
-	polygon->count=indices.size();
-	canvas_item->rect_dirty=true;
+	polygon->texture = p_texture;
+	polygon->points = p_points;
+	polygon->uvs = p_uvs;
+	polygon->colors = p_colors;
+	polygon->indices = indices;
+	polygon->count = indices.size();
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(polygon);
-
 }
 
-void VisualServerRaster::canvas_item_add_triangle_array_ptr(RID p_item, int p_count, const int* p_indices, const Point2* p_points, const Color* p_colors,const Point2* p_uvs, RID p_texture) {
+void VisualServerRaster::canvas_item_add_triangle_array_ptr(RID p_item, int p_count, const int *p_indices, const Point2 *p_points, const Color *p_colors, const Point2 *p_uvs, RID p_texture) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	ERR_FAIL_COND(p_count <= 0);
 
 	ERR_FAIL_COND(p_points == NULL);
 
-	CanvasItem::CommandPolygonPtr * polygon = memnew( CanvasItem::CommandPolygonPtr );
+	CanvasItem::CommandPolygonPtr *polygon = memnew(CanvasItem::CommandPolygonPtr);
 	ERR_FAIL_COND(!polygon);
-	polygon->texture=p_texture;
-	polygon->points=p_points;
-	polygon->uvs=p_uvs;
-	polygon->colors=p_colors;
-	polygon->indices=p_indices;
+	polygon->texture = p_texture;
+	polygon->points = p_points;
+	polygon->uvs = p_uvs;
+	polygon->colors = p_colors;
+	polygon->indices = p_indices;
 	polygon->count = p_count * 3;
-	canvas_item->rect_dirty=true;
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(polygon);
 };
 
-void VisualServerRaster::canvas_item_add_triangle_array(RID p_item, const Vector<int>& p_indices, const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture, int p_count) {
+void VisualServerRaster::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, int p_count) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	int ps = p_points.size();
-	ERR_FAIL_COND(!p_colors.empty() && p_colors.size()!=ps && p_colors.size()!=1);
-	ERR_FAIL_COND(!p_uvs.empty() && p_uvs.size()!=ps);
+	ERR_FAIL_COND(!p_colors.empty() && p_colors.size() != ps && p_colors.size() != 1);
+	ERR_FAIL_COND(!p_uvs.empty() && p_uvs.size() != ps);
 
 	Vector<int> indices = p_indices;
 
@@ -3857,51 +3541,49 @@ void VisualServerRaster::canvas_item_add_triangle_array(RID p_item, const Vector
 
 	if (indices.empty()) {
 
-		ERR_FAIL_COND( ps % 3 != 0 );
+		ERR_FAIL_COND(ps % 3 != 0);
 		if (p_count == -1)
 			count = ps;
 	} else {
 
-		ERR_FAIL_COND( indices.size() % 3 != 0 );
+		ERR_FAIL_COND(indices.size() % 3 != 0);
 		if (p_count == -1)
 			count = indices.size();
 	}
 
-	CanvasItem::CommandPolygon * polygon = memnew( CanvasItem::CommandPolygon );
+	CanvasItem::CommandPolygon *polygon = memnew(CanvasItem::CommandPolygon);
 	ERR_FAIL_COND(!polygon);
-	polygon->texture=p_texture;
-	polygon->points=p_points;
-	polygon->uvs=p_uvs;
-	polygon->colors=p_colors;
-	polygon->indices=indices;
+	polygon->texture = p_texture;
+	polygon->points = p_points;
+	polygon->uvs = p_uvs;
+	polygon->colors = p_colors;
+	polygon->indices = indices;
 	polygon->count = count;
-	canvas_item->rect_dirty=true;
+	canvas_item->rect_dirty = true;
 
 	canvas_item->commands.push_back(polygon);
 }
 
-
-void VisualServerRaster::canvas_item_add_set_transform(RID p_item,const Matrix32& p_transform) {
+void VisualServerRaster::canvas_item_add_set_transform(RID p_item, const Matrix32 &p_transform) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandTransform * tr = memnew( CanvasItem::CommandTransform );
+	CanvasItem::CommandTransform *tr = memnew(CanvasItem::CommandTransform);
 	ERR_FAIL_COND(!tr);
-	tr->xform=p_transform;
+	tr->xform = p_transform;
 
 	canvas_item->commands.push_back(tr);
-
 }
 
 void VisualServerRaster::canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandBlendMode * bm = memnew( CanvasItem::CommandBlendMode );
+	CanvasItem::CommandBlendMode *bm = memnew(CanvasItem::CommandBlendMode);
 	ERR_FAIL_COND(!bm);
 	bm->blend_mode = p_blend;
 
@@ -3910,66 +3592,62 @@ void VisualServerRaster::canvas_item_add_set_blend_mode(RID p_item, MaterialBlen
 
 void VisualServerRaster::canvas_item_set_z(RID p_item, int p_z) {
 
-	ERR_FAIL_COND(p_z<CANVAS_ITEM_Z_MIN || p_z>CANVAS_ITEM_Z_MAX);
+	ERR_FAIL_COND(p_z < CANVAS_ITEM_Z_MIN || p_z > CANVAS_ITEM_Z_MAX);
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->z=p_z;
-
+	canvas_item->z = p_z;
 }
 
 void VisualServerRaster::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->z_relative=p_enable;
-
+	canvas_item->z_relative = p_enable;
 }
 
-void VisualServerRaster::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2& p_rect) {
+void VisualServerRaster::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	if (bool(canvas_item->copy_back_buffer!=NULL) !=p_enable) {
+	if (bool(canvas_item->copy_back_buffer != NULL) != p_enable) {
 		if (p_enable) {
-			canvas_item->copy_back_buffer = memnew( Rasterizer::CanvasItem::CopyBackBuffer );
+			canvas_item->copy_back_buffer = memnew(Rasterizer::CanvasItem::CopyBackBuffer);
 		} else {
 			memdelete(canvas_item->copy_back_buffer);
-			canvas_item->copy_back_buffer=NULL;
+			canvas_item->copy_back_buffer = NULL;
 		}
 	}
 
 	if (p_enable) {
-		canvas_item->copy_back_buffer->rect=p_rect;
-		canvas_item->copy_back_buffer->full=p_rect==Rect2();
+		canvas_item->copy_back_buffer->rect = p_rect;
+		canvas_item->copy_back_buffer->full = p_rect == Rect2();
 	}
-
 }
 
 void VisualServerRaster::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->use_parent_material=p_enable;
-
+	canvas_item->use_parent_material = p_enable;
 }
 
 void VisualServerRaster::canvas_item_set_material(RID p_item, RID p_material) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	if (canvas_item->material)
 		canvas_item->material->owners.erase(canvas_item);
 
-	canvas_item->material=NULL;
+	canvas_item->material = NULL;
 
 	if (canvas_item_material_owner.owns(p_material)) {
-		canvas_item->material=canvas_item_material_owner.get(p_material);
+		canvas_item->material = canvas_item_material_owner.get(p_material);
 		canvas_item->material->owners.insert(canvas_item);
 	}
 }
@@ -3977,39 +3655,35 @@ void VisualServerRaster::canvas_item_set_material(RID p_item, RID p_material) {
 void VisualServerRaster::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->sort_y=p_enable;
+	canvas_item->sort_y = p_enable;
 }
 
-
 void VisualServerRaster::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
 
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-	CanvasItem::CommandClipIgnore * ci = memnew( CanvasItem::CommandClipIgnore);
+	CanvasItem::CommandClipIgnore *ci = memnew(CanvasItem::CommandClipIgnore);
 	ERR_FAIL_COND(!ci);
-	ci->ignore=p_ignore;
+	ci->ignore = p_ignore;
 
 	canvas_item->commands.push_back(ci);
-
 }
 
 void VisualServerRaster::canvas_item_clear(RID p_item) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
-
 	canvas_item->clear();
-
 }
 
 void VisualServerRaster::canvas_item_raise(RID p_item) {
 	VS_CHANGED;
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	CanvasItem *canvas_item = canvas_item_owner.get(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	if (canvas_item->parent.is_valid()) {
@@ -4018,7 +3692,7 @@ void VisualServerRaster::canvas_item_raise(RID p_item) {
 
 			Canvas *canvas = canvas_owner.get(canvas_item->parent);
 			int idx = canvas->find_item(canvas_item);
-			ERR_FAIL_COND(idx<0);
+			ERR_FAIL_COND(idx < 0);
 			Canvas::ChildItem ci = canvas->child_items[idx];
 			canvas->child_items.remove(idx);
 			canvas->child_items.push_back(ci);
@@ -4027,24 +3701,22 @@ void VisualServerRaster::canvas_item_raise(RID p_item) {
 
 			CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
 			int idx = item_owner->child_items.find(canvas_item);
-			ERR_FAIL_COND(idx<0);
+			ERR_FAIL_COND(idx < 0);
 			item_owner->child_items.remove(idx);
 			item_owner->child_items.push_back(canvas_item);
-
 		}
 	}
-
 }
 
 /***** CANVAS LIGHT *******/
 
 RID VisualServerRaster::canvas_light_create() {
 
-	Rasterizer::CanvasLight *clight = memnew( Rasterizer::CanvasLight );
+	Rasterizer::CanvasLight *clight = memnew(Rasterizer::CanvasLight);
 	return canvas_light_owner.make_rid(clight);
 }
 
-void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light,RID p_canvas){
+void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light, RID p_canvas) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
@@ -4056,184 +3728,156 @@ void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light,RID p_canvas)
 	}
 
 	if (!canvas_owner.owns(p_canvas))
-		p_canvas=RID();
-	clight->canvas=p_canvas;
+		p_canvas = RID();
+	clight->canvas = p_canvas;
 
 	if (clight->canvas.is_valid()) {
 
 		Canvas *canvas = canvas_owner.get(clight->canvas);
 		canvas->lights.insert(clight);
 	}
-
-
-
 }
-void VisualServerRaster::canvas_light_set_enabled(RID p_light, bool p_enabled){
+void VisualServerRaster::canvas_light_set_enabled(RID p_light, bool p_enabled) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->enabled=p_enabled;
-
+	clight->enabled = p_enabled;
 }
-void VisualServerRaster::canvas_light_set_transform(RID p_light, const Matrix32& p_transform){
+void VisualServerRaster::canvas_light_set_transform(RID p_light, const Matrix32 &p_transform) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->xform=p_transform;
-
+	clight->xform = p_transform;
 }
 void VisualServerRaster::canvas_light_set_scale(RID p_light, float p_scale) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->scale=p_scale;
-
+	clight->scale = p_scale;
 }
 
-
-void VisualServerRaster::canvas_light_set_texture(RID p_light, RID p_texture){
+void VisualServerRaster::canvas_light_set_texture(RID p_light, RID p_texture) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->texture=p_texture;
-
+	clight->texture = p_texture;
 }
-void VisualServerRaster::canvas_light_set_texture_offset(RID p_light, const Vector2& p_offset){
+void VisualServerRaster::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->texture_offset=p_offset;
-
+	clight->texture_offset = p_offset;
 }
-void VisualServerRaster::canvas_light_set_color(RID p_light, const Color& p_color){
+void VisualServerRaster::canvas_light_set_color(RID p_light, const Color &p_color) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->color=p_color;
-
-
+	clight->color = p_color;
 }
-void VisualServerRaster::canvas_light_set_height(RID p_light, float p_height){
+void VisualServerRaster::canvas_light_set_height(RID p_light, float p_height) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->height=p_height;
-
+	clight->height = p_height;
 }
 
-void VisualServerRaster::canvas_light_set_energy(RID p_light, float p_energy){
+void VisualServerRaster::canvas_light_set_energy(RID p_light, float p_energy) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->energy=p_energy;
-
+	clight->energy = p_energy;
 }
 
-void VisualServerRaster::canvas_light_set_z_range(RID p_light, int p_min_z,int p_max_z){
+void VisualServerRaster::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->z_min=p_min_z;
-	clight->z_max=p_max_z;
-
+	clight->z_min = p_min_z;
+	clight->z_max = p_max_z;
 }
 
-void VisualServerRaster::canvas_light_set_layer_range(RID p_light, int p_min_layer,int p_max_layer) {
+void VisualServerRaster::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->layer_min=p_min_layer;
-	clight->layer_max=p_max_layer;
-
+	clight->layer_min = p_min_layer;
+	clight->layer_max = p_max_layer;
 }
 
-void VisualServerRaster::canvas_light_set_item_mask(RID p_light, int p_mask){
+void VisualServerRaster::canvas_light_set_item_mask(RID p_light, int p_mask) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->item_mask=p_mask;
-
+	clight->item_mask = p_mask;
 }
 
-void VisualServerRaster::canvas_light_set_item_shadow_mask(RID p_light, int p_mask){
+void VisualServerRaster::canvas_light_set_item_shadow_mask(RID p_light, int p_mask) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->item_shadow_mask=p_mask;
-
+	clight->item_shadow_mask = p_mask;
 }
 
-
 void VisualServerRaster::canvas_light_set_mode(RID p_light, CanvasLightMode p_mode) {
 
-
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->mode=p_mode;
-
+	clight->mode = p_mode;
 }
-void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled){
+void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
 
-	if (clight->shadow_buffer.is_valid()==p_enabled)
+	if (clight->shadow_buffer.is_valid() == p_enabled)
 		return;
 	if (p_enabled) {
-		clight->shadow_buffer=rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
+		clight->shadow_buffer = rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
 	} else {
 		rasterizer->free(clight->shadow_buffer);
-		clight->shadow_buffer=RID();
-
+		clight->shadow_buffer = RID();
 	}
-
 }
 
-void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size){
+void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
 
-	ERR_FAIL_COND(p_size<32 || p_size>16384);
-
-	clight->shadow_buffer_size=nearest_power_of_2(p_size);
+	ERR_FAIL_COND(p_size < 32 || p_size > 16384);
 
+	clight->shadow_buffer_size = nearest_power_of_2(p_size);
 
 	if (clight->shadow_buffer.is_valid()) {
 		rasterizer->free(clight->shadow_buffer);
-		clight->shadow_buffer=rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
+		clight->shadow_buffer = rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
 	}
-
 }
 
 void VisualServerRaster::canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->shadow_esm_mult=p_multiplier;
-
+	clight->shadow_esm_mult = p_multiplier;
 }
 
-void VisualServerRaster::canvas_light_set_shadow_color(RID p_light, const Color& p_color) {
+void VisualServerRaster::canvas_light_set_shadow_color(RID p_light, const Color &p_color) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->shadow_color=p_color;
-
+	clight->shadow_color = p_color;
 }
 
-
 /****** CANVAS LIGHT OCCLUDER ******/
 
 RID VisualServerRaster::canvas_light_occluder_create() {
 
-	Rasterizer::CanvasLightOccluderInstance *occluder = memnew( Rasterizer::CanvasLightOccluderInstance );
-
-	return canvas_light_occluder_owner.make_rid( occluder );
+	Rasterizer::CanvasLightOccluderInstance *occluder = memnew(Rasterizer::CanvasLightOccluderInstance);
 
+	return canvas_light_occluder_owner.make_rid(occluder);
 }
 
-void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas) {
+void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas) {
 
 	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
 	ERR_FAIL_COND(!occluder);
@@ -4245,9 +3889,9 @@ void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder,R
 	}
 
 	if (!canvas_owner.owns(p_canvas))
-		p_canvas=RID();
+		p_canvas = RID();
 
-	occluder->canvas=p_canvas;
+	occluder->canvas = p_canvas;
 
 	if (occluder->canvas.is_valid()) {
 
@@ -4256,16 +3900,15 @@ void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder,R
 	}
 }
 
-void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled){
+void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled) {
 
 	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
-	occluder->enabled=p_enabled;
-
+	occluder->enabled = p_enabled;
 }
 
-void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder,RID p_polygon) {
+void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon) {
 
 	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
 	ERR_FAIL_COND(!occluder);
@@ -4277,152 +3920,138 @@ void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder,RID p_
 		}
 	}
 
-	occluder->polygon=p_polygon;
-	occluder->polygon_buffer=RID();
+	occluder->polygon = p_polygon;
+	occluder->polygon_buffer = RID();
 
 	if (occluder->polygon.is_valid()) {
 		CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
 		if (!occluder_poly)
-			occluder->polygon=RID();
+			occluder->polygon = RID();
 		ERR_FAIL_COND(!occluder_poly);
 		occluder_poly->owners.insert(occluder);
-		occluder->polygon_buffer=occluder_poly->occluder;
-		occluder->aabb_cache=occluder_poly->aabb;
-		occluder->cull_cache=occluder_poly->cull_mode;
+		occluder->polygon_buffer = occluder_poly->occluder;
+		occluder->aabb_cache = occluder_poly->aabb;
+		occluder->cull_cache = occluder_poly->cull_mode;
 	}
-
 }
 
-
-
-
-void VisualServerRaster::canvas_light_occluder_set_transform(RID p_occluder,const Matrix32& p_xform) {
+void VisualServerRaster::canvas_light_occluder_set_transform(RID p_occluder, const Matrix32 &p_xform) {
 
 	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
-	occluder->xform=p_xform;
-
+	occluder->xform = p_xform;
 }
 
-void VisualServerRaster::canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask) {
+void VisualServerRaster::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) {
 
 	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
-	occluder->light_mask=p_mask;
-
+	occluder->light_mask = p_mask;
 }
 
-
 RID VisualServerRaster::canvas_occluder_polygon_create() {
 
-	CanvasLightOccluderPolygon * occluder_poly = memnew( CanvasLightOccluderPolygon );
-	occluder_poly->occluder=rasterizer->canvas_light_occluder_create();
+	CanvasLightOccluderPolygon *occluder_poly = memnew(CanvasLightOccluderPolygon);
+	occluder_poly->occluder = rasterizer->canvas_light_occluder_create();
 	return canvas_light_occluder_polygon_owner.make_rid(occluder_poly);
-
 }
 
-void VisualServerRaster::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2>& p_shape, bool p_close){
+void VisualServerRaster::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2> &p_shape, bool p_close) {
 
-	if (p_shape.size()<3) {
-		canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon,p_shape);
+	if (p_shape.size() < 3) {
+		canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, p_shape);
 		return;
 	}
 
 	DVector<Vector2> lines;
-	int lc = p_shape.size()*2;
+	int lc = p_shape.size() * 2;
 
-	lines.resize(lc-(p_close?0:2));
+	lines.resize(lc - (p_close ? 0 : 2));
 	{
 		DVector<Vector2>::Write w = lines.write();
 		DVector<Vector2>::Read r = p_shape.read();
 
-		int max=lc/2;
+		int max = lc / 2;
 		if (!p_close) {
 			max--;
 		}
-		for(int i=0;i<max;i++) {
+		for (int i = 0; i < max; i++) {
 
 			Vector2 a = r[i];
-			Vector2 b = r[(i+1)%(lc/2)];
-			w[i*2+0]=a;
-			w[i*2+1]=b;
+			Vector2 b = r[(i + 1) % (lc / 2)];
+			w[i * 2 + 0] = a;
+			w[i * 2 + 1] = b;
 		}
-
 	}
 
-	canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon,lines);
+	canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, lines);
 }
 
-void VisualServerRaster::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const DVector<Vector2>& p_shape) {
+void VisualServerRaster::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const DVector<Vector2> &p_shape) {
 
-	CanvasLightOccluderPolygon * occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
+	CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
 	ERR_FAIL_COND(!occluder_poly);
-	ERR_FAIL_COND(p_shape.size()&1);
+	ERR_FAIL_COND(p_shape.size() & 1);
 
 	int lc = p_shape.size();
-	occluder_poly->aabb=Rect2();
+	occluder_poly->aabb = Rect2();
 	{
 		DVector<Vector2>::Read r = p_shape.read();
-		for(int i=0;i<lc;i++) {
-			if (i==0)
-				occluder_poly->aabb.pos=r[i];
+		for (int i = 0; i < lc; i++) {
+			if (i == 0)
+				occluder_poly->aabb.pos = r[i];
 			else
 				occluder_poly->aabb.expand_to(r[i]);
 		}
 	}
 
-	rasterizer->canvas_light_occluder_set_polylines(occluder_poly->occluder,p_shape);
-	for( Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=occluder_poly->owners.front();E;E=E->next()) {
-		E->get()->aabb_cache=occluder_poly->aabb;
+	rasterizer->canvas_light_occluder_set_polylines(occluder_poly->occluder, p_shape);
+	for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
+		E->get()->aabb_cache = occluder_poly->aabb;
 	}
 }
 
-void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,CanvasOccluderPolygonCullMode p_mode) {
+void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, CanvasOccluderPolygonCullMode p_mode) {
 
-	CanvasLightOccluderPolygon * occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
+	CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
 	ERR_FAIL_COND(!occluder_poly);
-	occluder_poly->cull_mode=p_mode;
-	for( Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=occluder_poly->owners.front();E;E=E->next()) {
-		E->get()->cull_cache=p_mode;
+	occluder_poly->cull_mode = p_mode;
+	for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
+		E->get()->cull_cache = p_mode;
 	}
-
 }
 
 RID VisualServerRaster::canvas_item_material_create() {
 
-	Rasterizer::CanvasItemMaterial *material = memnew( Rasterizer::CanvasItemMaterial );
+	Rasterizer::CanvasItemMaterial *material = memnew(Rasterizer::CanvasItemMaterial);
 	return canvas_item_material_owner.make_rid(material);
-
 }
 
-void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader){
+void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader) {
 
 	VS_CHANGED;
-	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	material->shader=p_shader;
-
+	material->shader = p_shader;
 }
-void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName& p_param, const Variant& p_value){
+void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName &p_param, const Variant &p_value) {
 
 	VS_CHANGED;
-	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	if (p_value.get_type()==Variant::NIL)
+	if (p_value.get_type() == Variant::NIL)
 		material->shader_param.erase(p_param);
 	else
-		material->shader_param[p_param]=p_value;
-
-
+		material->shader_param[p_param] = p_value;
 }
-Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName& p_param) const{
-	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
-	ERR_FAIL_COND_V(!material,Variant());
+Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName &p_param) const {
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
+	ERR_FAIL_COND_V(!material, Variant());
 	if (!material->shader_param.has(p_param)) {
-		ERR_FAIL_COND_V(!material->shader.is_valid(),Variant());
-		return rasterizer->shader_get_default_param(material->shader,p_param);
+		ERR_FAIL_COND_V(!material->shader.is_valid(), Variant());
+		return rasterizer->shader_get_default_param(material->shader, p_param);
 	}
 
 	return material->shader_param[p_param];
@@ -4431,16 +4060,13 @@ Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material
 void VisualServerRaster::canvas_item_material_set_shading_mode(RID p_material, CanvasItemShadingMode p_mode) {
 
 	VS_CHANGED;
-	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
-	material->shading_mode=p_mode;
-
+	material->shading_mode = p_mode;
 }
 
-
 /******** CANVAS *********/
 
-
 void VisualServerRaster::cursor_set_rotation(float p_rotation, int p_cursor) {
 	VS_CHANGED;
 	ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
@@ -4464,100 +4090,95 @@ void VisualServerRaster::cursor_set_visible(bool p_visible, int p_cursor) {
 	cursors[p_cursor].visible = p_visible;
 };
 
-void VisualServerRaster::cursor_set_pos(const Point2& p_pos, int p_cursor) {
+void VisualServerRaster::cursor_set_pos(const Point2 &p_pos, int p_cursor) {
 
 	ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
-	if (cursors[p_cursor].pos==p_pos)
+	if (cursors[p_cursor].pos == p_pos)
 		return;
 	VS_CHANGED;
 	cursors[p_cursor].pos = p_pos;
 };
 
-
 void VisualServerRaster::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom) {
 
-	black_margin[MARGIN_LEFT]=p_left;
-	black_margin[MARGIN_TOP]=p_top;
-	black_margin[MARGIN_RIGHT]=p_right;
-	black_margin[MARGIN_BOTTOM]=p_bottom;
+	black_margin[MARGIN_LEFT] = p_left;
+	black_margin[MARGIN_TOP] = p_top;
+	black_margin[MARGIN_RIGHT] = p_right;
+	black_margin[MARGIN_BOTTOM] = p_bottom;
 }
 
 void VisualServerRaster::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom) {
 
-	black_image[MARGIN_LEFT]=p_left;
-	black_image[MARGIN_TOP]=p_top;
-	black_image[MARGIN_RIGHT]=p_right;
-	black_image[MARGIN_BOTTOM]=p_bottom;
+	black_image[MARGIN_LEFT] = p_left;
+	black_image[MARGIN_TOP] = p_top;
+	black_image[MARGIN_RIGHT] = p_right;
+	black_image[MARGIN_BOTTOM] = p_bottom;
 }
 
-void VisualServerRaster::_free_attached_instances(RID p_rid,bool p_free_scenario) {
+void VisualServerRaster::_free_attached_instances(RID p_rid, bool p_free_scenario) {
 
-	Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_rid );
+	Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(p_rid);
 
 	if (E) {
 		// has instances
-		while( E->get().size() ) {
+		while (E->get().size()) {
 			// erase all attached instances
 			if (p_free_scenario)
-				instance_set_scenario( E->get().front()->get(), RID() );
+				instance_set_scenario(E->get().front()->get(), RID());
 			else
-				instance_set_base( E->get().front()->get(), RID() );
-
+				instance_set_base(E->get().front()->get(), RID());
 		}
 	}
 
 	instance_dependency_map.erase(p_rid);
-
 }
 
 void VisualServerRaster::custom_shade_model_set_shader(int p_model, RID p_shader) {
 
 	VS_CHANGED;
-//	rasterizer->custom_shade_model_set_shader(p_model,p_shader);
+	//	rasterizer->custom_shade_model_set_shader(p_model,p_shader);
 }
 
 RID VisualServerRaster::custom_shade_model_get_shader(int p_model) const {
 
 	//return rasterizer->custom_shade_model_get_shader(p_model);
 	return RID();
-
 }
-void VisualServerRaster::custom_shade_model_set_name(int p_model, const String& p_name) {
+void VisualServerRaster::custom_shade_model_set_name(int p_model, const String &p_name) {
 
 	//rasterizer->custom_shade_model_set_name(p_model,p_name);
-
 }
 String VisualServerRaster::custom_shade_model_get_name(int p_model) const {
 
 	//return rasterizer->custom_shade_model_get_name(p_model);
 	return "";
 }
-void VisualServerRaster::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo>& p_info) {
+void VisualServerRaster::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo> &p_info) {
 
 	VS_CHANGED;
 	//rasterizer->custom_shade_model_set_param_info(p_model,p_info);
 }
-void VisualServerRaster::custom_shade_model_get_param_info(int p_model, List<PropertyInfo>* p_info) const {
+void VisualServerRaster::custom_shade_model_get_param_info(int p_model, List<PropertyInfo> *p_info) const {
 
 	//rasterizer->custom_shade_model_get_param_info(p_model,p_info);
 }
 
-void VisualServerRaster::free( RID p_rid ) {
+void VisualServerRaster::free(RID p_rid) {
 
 	VS_CHANGED;
 
-	if (rasterizer->is_texture(p_rid) || rasterizer->is_material(p_rid) ||  rasterizer->is_shader(p_rid) || rasterizer->is_environment(p_rid)) {
+	if (rasterizer->is_texture(p_rid) || rasterizer->is_material(p_rid) || rasterizer->is_shader(p_rid) || rasterizer->is_environment(p_rid)) {
 
 		rasterizer->free(p_rid);
 	} else if (rasterizer->is_skeleton(p_rid)) {
 
-		Map< RID, Set<Instance*> >::Element *E=skeleton_dependency_map.find(p_rid);
+		Map<RID, Set<Instance *> >::Element *E = skeleton_dependency_map.find(p_rid);
 
 		if (E) {
 			//detach skeletons
-			for (Set<Instance*>::Element *F=E->get().front();F;F=F->next()) {
+			for (Set<Instance *>::Element *F = E->get().front(); F; F = F->next()) {
 
-				F->get()->data.skeleton=RID();
+				F->get()->data.skeleton = RID();
 			}
 			skeleton_dependency_map.erase(E);
 		}
@@ -4576,7 +4197,6 @@ void VisualServerRaster::free( RID p_rid ) {
 		room_owner.free(p_rid);
 		memdelete(room);
 
-
 	} else if (portal_owner.owns(p_rid)) {
 
 		_free_attached_instances(p_rid);
@@ -4614,16 +4234,16 @@ void VisualServerRaster::free( RID p_rid ) {
 		Camera *camera = camera_owner.get(p_rid);
 		ERR_FAIL_COND(!camera);
 
-		camera_owner.free( p_rid );
+		camera_owner.free(p_rid);
 		memdelete(camera);
 
 	} else if (viewport_owner.owns(p_rid)) {
 		// delete the viewport
 
-		Viewport *viewport = viewport_owner.get( p_rid );
+		Viewport *viewport = viewport_owner.get(p_rid);
 		ERR_FAIL_COND(!viewport);
 
-//		Viewport *parent=NULL;
+		//		Viewport *parent=NULL;
 
 		rasterizer->free(viewport->viewport_data);
 		if (viewport->render_target.is_valid()) {
@@ -4636,7 +4256,7 @@ void VisualServerRaster::free( RID p_rid ) {
 		if (screen_viewports.has(p_rid))
 			screen_viewports.erase(p_rid);
 
-		while(viewport->canvas_map.size()) {
+		while (viewport->canvas_map.size()) {
 
 			Canvas *c = viewport->canvas_map.front()->get().canvas;
 			c->viewports.erase(p_rid);
@@ -4644,7 +4264,6 @@ void VisualServerRaster::free( RID p_rid ) {
 			viewport->canvas_map.erase(viewport->canvas_map.front());
 		}
 
-
 		viewport_owner.free(p_rid);
 		memdelete(viewport);
 
@@ -4656,14 +4275,14 @@ void VisualServerRaster::free( RID p_rid ) {
 		Instance *instance = instance_owner.get(p_rid);
 		ERR_FAIL_COND(!instance);
 
-		instance_set_room(p_rid,RID());
-		instance_set_scenario(p_rid,RID());
-		instance_geometry_set_baked_light(p_rid,RID());
-		instance_geometry_set_baked_light_sampler(p_rid,RID());
-		instance_set_base(p_rid,RID());
+		instance_set_room(p_rid, RID());
+		instance_set_scenario(p_rid, RID());
+		instance_geometry_set_baked_light(p_rid, RID());
+		instance_geometry_set_baked_light_sampler(p_rid, RID());
+		instance_set_base(p_rid, RID());
 
 		if (instance->data.skeleton.is_valid())
-			instance_attach_skeleton(p_rid,RID());
+			instance_attach_skeleton(p_rid, RID());
 
 		instance_owner.free(p_rid);
 		memdelete(instance);
@@ -4673,36 +4292,36 @@ void VisualServerRaster::free( RID p_rid ) {
 		Canvas *canvas = canvas_owner.get(p_rid);
 		ERR_FAIL_COND(!canvas);
 
-		while(canvas->viewports.size()) {
+		while (canvas->viewports.size()) {
 
 			Viewport *vp = viewport_owner.get(canvas->viewports.front()->get());
 			ERR_FAIL_COND(!vp);
 
-			Map<RID,Viewport::CanvasData>::Element *E=vp->canvas_map.find(p_rid);
+			Map<RID, Viewport::CanvasData>::Element *E = vp->canvas_map.find(p_rid);
 			ERR_FAIL_COND(!E);
 			vp->canvas_map.erase(p_rid);
 
-			canvas->viewports.erase( canvas->viewports.front() );
+			canvas->viewports.erase(canvas->viewports.front());
 		}
 
-		for (int i=0;i<canvas->child_items.size();i++) {
+		for (int i = 0; i < canvas->child_items.size(); i++) {
 
-			canvas->child_items[i].item->parent=RID();
+			canvas->child_items[i].item->parent = RID();
 		}
 
-		for (Set<Rasterizer::CanvasLight*>::Element *E=canvas->lights.front();E;E=E->next()) {
+		for (Set<Rasterizer::CanvasLight *>::Element *E = canvas->lights.front(); E; E = E->next()) {
 
-			E->get()->canvas=RID();
+			E->get()->canvas = RID();
 		}
 
-		for (Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=canvas->occluders.front();E;E=E->next()) {
+		for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *E = canvas->occluders.front(); E; E = E->next()) {
 
-			E->get()->canvas=RID();
+			E->get()->canvas = RID();
 		}
 
-		canvas_owner.free( p_rid );
+		canvas_owner.free(p_rid);
 
-		memdelete( canvas );
+		memdelete(canvas);
 
 	} else if (canvas_item_owner.owns(p_rid)) {
 
@@ -4719,30 +4338,29 @@ void VisualServerRaster::free( RID p_rid ) {
 
 				CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
 				item_owner->child_items.erase(canvas_item);
-
 			}
 		}
 
-		for (int i=0;i<canvas_item->child_items.size();i++) {
+		for (int i = 0; i < canvas_item->child_items.size(); i++) {
 
-			canvas_item->child_items[i]->parent=RID();
+			canvas_item->child_items[i]->parent = RID();
 		}
 
 		if (canvas_item->material) {
 			canvas_item->material->owners.erase(canvas_item);
 		}
 
-		canvas_item_owner.free( p_rid );
+		canvas_item_owner.free(p_rid);
 
-		memdelete( canvas_item );
+		memdelete(canvas_item);
 
 	} else if (canvas_item_material_owner.owns(p_rid)) {
 
 		Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_rid);
 		ERR_FAIL_COND(!material);
-		for(Set<Rasterizer::CanvasItem*>::Element *E=material->owners.front();E;E=E->next()) {
+		for (Set<Rasterizer::CanvasItem *>::Element *E = material->owners.front(); E; E = E->next()) {
 
-			E->get()->material=NULL;
+			E->get()->material = NULL;
 		}
 
 		canvas_item_material_owner.free(p_rid);
@@ -4754,7 +4372,7 @@ void VisualServerRaster::free( RID p_rid ) {
 		ERR_FAIL_COND(!canvas_light);
 
 		if (canvas_light->canvas.is_valid()) {
-			Canvas* canvas = canvas_owner.get(canvas_light->canvas);
+			Canvas *canvas = canvas_owner.get(canvas_light->canvas);
 			if (canvas)
 				canvas->lights.erase(canvas_light);
 		}
@@ -4762,8 +4380,8 @@ void VisualServerRaster::free( RID p_rid ) {
 		if (canvas_light->shadow_buffer.is_valid())
 			rasterizer->free(canvas_light->shadow_buffer);
 
-		canvas_light_owner.free( p_rid );
-		memdelete( canvas_light );
+		canvas_light_owner.free(p_rid);
+		memdelete(canvas_light);
 
 	} else if (canvas_light_occluder_owner.owns(p_rid)) {
 
@@ -4776,17 +4394,15 @@ void VisualServerRaster::free( RID p_rid ) {
 			if (occluder_poly) {
 				occluder_poly->owners.erase(occluder);
 			}
-
 		}
 
 		if (occluder->canvas.is_valid() && canvas_owner.owns(occluder->canvas)) {
 
 			Canvas *canvas = canvas_owner.get(occluder->canvas);
 			canvas->occluders.erase(occluder);
-
 		}
 
-		canvas_light_occluder_owner.free( p_rid );
+		canvas_light_occluder_owner.free(p_rid);
 		memdelete(occluder);
 
 	} else if (canvas_light_occluder_polygon_owner.owns(p_rid)) {
@@ -4795,22 +4411,22 @@ void VisualServerRaster::free( RID p_rid ) {
 		ERR_FAIL_COND(!occluder_poly);
 		rasterizer->free(occluder_poly->occluder);
 
-		while(occluder_poly->owners.size()) {
+		while (occluder_poly->owners.size()) {
 
-			occluder_poly->owners.front()->get()->polygon=RID();
-			occluder_poly->owners.erase( occluder_poly->owners.front() );
+			occluder_poly->owners.front()->get()->polygon = RID();
+			occluder_poly->owners.erase(occluder_poly->owners.front());
 		}
 
-		canvas_light_occluder_polygon_owner.free( p_rid );
+		canvas_light_occluder_polygon_owner.free(p_rid);
 		memdelete(occluder_poly);
 
 	} else if (scenario_owner.owns(p_rid)) {
 
-		Scenario *scenario=scenario_owner.get(p_rid);
+		Scenario *scenario = scenario_owner.get(p_rid);
 		ERR_FAIL_COND(!scenario);
 
 		_update_instances(); // be sure
-		_free_attached_instances(p_rid,true);
+		_free_attached_instances(p_rid, true);
 
 		//rasterizer->free( scenario->environment );
 		scenario_owner.free(p_rid);
@@ -4820,28 +4436,24 @@ void VisualServerRaster::free( RID p_rid ) {
 
 		ERR_FAIL();
 	}
-
 }
 
-
-
 void VisualServerRaster::_instance_draw(Instance *p_instance) {
 
 	if (p_instance->light_cache_dirty) {
-		int l=0;
+		int l = 0;
 		//add positional lights
-		InstanceSet::Element *LE=p_instance->lights.front();
+		InstanceSet::Element *LE = p_instance->lights.front();
 		p_instance->data.light_instances.resize(p_instance->lights.size());
-		while(LE) {
+		while (LE) {
 
-			p_instance->data.light_instances[l++]=LE->get()->light_info->instance;
-			LE=LE->next();
+			p_instance->data.light_instances[l++] = LE->get()->light_info->instance;
+			LE = LE->next();
 		}
-		p_instance->light_cache_dirty=false;
+		p_instance->light_cache_dirty = false;
 	}
 
-
-	switch(p_instance->base_type) {
+	switch (p_instance->base_type) {
 
 		case INSTANCE_MESH: {
 			rasterizer->add_mesh(p_instance->base_rid, &p_instance->data);
@@ -4859,27 +4471,25 @@ void VisualServerRaster::_instance_draw(Instance *p_instance) {
 	}
 }
 
-
-Vector<Vector3> VisualServerRaster::_camera_generate_endpoints(Instance *p_light,Camera *p_camera,float p_range_min, float p_range_max) {
+Vector<Vector3> VisualServerRaster::_camera_generate_endpoints(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max) {
 
 	// setup a camera matrix for that range!
 	CameraMatrix camera_matrix;
 
-	switch(p_camera->type) {
+	switch (p_camera->type) {
 
 		case Camera::ORTHOGONAL: {
 
-			camera_matrix.set_orthogonal(p_camera->size,viewport_rect.width / (float)viewport_rect.height,p_range_min,p_range_max,p_camera->vaspect);
+			camera_matrix.set_orthogonal(p_camera->size, viewport_rect.width / (float)viewport_rect.height, p_range_min, p_range_max, p_camera->vaspect);
 		} break;
 		case Camera::PERSPECTIVE: {
 
 			camera_matrix.set_perspective(
-				p_camera->fov,
-				viewport_rect.width / (float)viewport_rect.height,
-				p_range_min,
-				p_range_max,
-				p_camera->vaspect
-			);
+					p_camera->fov,
+					viewport_rect.width / (float)viewport_rect.height,
+					p_range_min,
+					p_range_max,
+					p_camera->vaspect);
 
 		} break;
 	}
@@ -4888,49 +4498,47 @@ Vector<Vector3> VisualServerRaster::_camera_generate_endpoints(Instance *p_light
 
 	Vector<Vector3> endpoints;
 	endpoints.resize(8);
-	bool res = camera_matrix.get_endpoints(p_camera->transform,&endpoints[0]);
-	ERR_FAIL_COND_V(!res,Vector<Vector3>());
+	bool res = camera_matrix.get_endpoints(p_camera->transform, &endpoints[0]);
+	ERR_FAIL_COND_V(!res, Vector<Vector3>());
 
 	return endpoints;
 }
 
-Vector<Plane> VisualServerRaster::_camera_generate_orthogonal_planes(Instance *p_light,Camera *p_camera,float p_range_min, float p_range_max) {
+Vector<Plane> VisualServerRaster::_camera_generate_orthogonal_planes(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max) {
 
-	Vector<Vector3> endpoints=_camera_generate_endpoints(p_light,p_camera,p_range_min,p_range_max); // frustum plane endpoints
-	ERR_FAIL_COND_V(endpoints.empty(),Vector<Plane>());
+	Vector<Vector3> endpoints = _camera_generate_endpoints(p_light, p_camera, p_range_min, p_range_max); // frustum plane endpoints
+	ERR_FAIL_COND_V(endpoints.empty(), Vector<Plane>());
 
 	// obtain the light frustm ranges (given endpoints)
 
-	Vector3 x_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_X ).normalized();
-	Vector3 y_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Y ).normalized();
-	Vector3 z_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Z ).normalized();
+	Vector3 x_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_X).normalized();
+	Vector3 y_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Y).normalized();
+	Vector3 z_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
 
-	float x_min,x_max;
-	float y_min,y_max;
-	float z_min,z_max;
+	float x_min, x_max;
+	float y_min, y_max;
+	float z_min, z_max;
 
-	for(int j=0;j<8;j++) {
+	for (int j = 0; j < 8; j++) {
 
-		float d_x=x_vec.dot(endpoints[j]);
-		float d_y=y_vec.dot(endpoints[j]);
-		float d_z=z_vec.dot(endpoints[j]);
+		float d_x = x_vec.dot(endpoints[j]);
+		float d_y = y_vec.dot(endpoints[j]);
+		float d_z = z_vec.dot(endpoints[j]);
 
-		if (j==0 || d_x<x_min)
-			x_min=d_x;
-		if (j==0 || d_x>x_max)
-			x_max=d_x;
-
-		if (j==0 || d_y<y_min)
-			y_min=d_y;
-		if (j==0 || d_y>y_max)
-			y_max=d_y;
-
-		if (j==0 || d_z<z_min)
-			z_min=d_z;
-		if (j==0 || d_z>z_max)
-			z_max=d_z;
+		if (j == 0 || d_x < x_min)
+			x_min = d_x;
+		if (j == 0 || d_x > x_max)
+			x_max = d_x;
 
+		if (j == 0 || d_y < y_min)
+			y_min = d_y;
+		if (j == 0 || d_y > y_max)
+			y_max = d_y;
 
+		if (j == 0 || d_z < z_min)
+			z_min = d_z;
+		if (j == 0 || d_z > z_max)
+			z_max = d_z;
 	}
 	//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
 
@@ -4938,82 +4546,77 @@ Vector<Plane> VisualServerRaster::_camera_generate_orthogonal_planes(Instance *p
 	light_frustum_planes.resize(6);
 
 	//right/left
-	light_frustum_planes[0]=Plane( x_vec, x_max );
-	light_frustum_planes[1]=Plane( -x_vec, -x_min );
+	light_frustum_planes[0] = Plane(x_vec, x_max);
+	light_frustum_planes[1] = Plane(-x_vec, -x_min);
 	//top/bottom
-	light_frustum_planes[2]=Plane( y_vec, y_max );
-	light_frustum_planes[3]=Plane( -y_vec, -y_min );
+	light_frustum_planes[2] = Plane(y_vec, y_max);
+	light_frustum_planes[3] = Plane(-y_vec, -y_min);
 	//near/far
-	light_frustum_planes[4]=Plane( z_vec, z_max+1e6 );
-	light_frustum_planes[5]=Plane( -z_vec, -z_min ); // z_min is ok, since casters further than far-light plane are not needed
+	light_frustum_planes[4] = Plane(z_vec, z_max + 1e6);
+	light_frustum_planes[5] = Plane(-z_vec, -z_min); // z_min is ok, since casters further than far-light plane are not needed
 
 	//TODO@ add more actual frustum planes to minimize get
 
 	return light_frustum_planes;
-
 }
-void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
+void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
 
-	int splits = rasterizer->light_instance_get_shadow_passes( p_light->light_info->instance );
-
-	float split_weight=rasterizer->light_directional_get_shadow_param(p_light->base_rid,LIGHT_DIRECTIONAL_SHADOW_PARAM_PSSM_SPLIT_WEIGHT);
+	int splits = rasterizer->light_instance_get_shadow_passes(p_light->light_info->instance);
 
+	float split_weight = rasterizer->light_directional_get_shadow_param(p_light->base_rid, LIGHT_DIRECTIONAL_SHADOW_PARAM_PSSM_SPLIT_WEIGHT);
 
 	float distances[5];
-	float texsize=rasterizer->light_instance_get_shadow_size( p_light->light_info->instance );
+	float texsize = rasterizer->light_instance_get_shadow_size(p_light->light_info->instance);
 
-//	float cull_min=p_cull_range.min;
+	//	float cull_min=p_cull_range.min;
 	//float cull_max=p_cull_range.max;
 
+	bool overlap = rasterizer->light_instance_get_pssm_shadow_overlap(p_light->light_info->instance);
 
-	bool overlap = 	rasterizer->light_instance_get_pssm_shadow_overlap(p_light->light_info->instance);
-
-	float cull_min=p_camera->znear;
-	float cull_max=p_camera->zfar;
-	float max_dist = rasterizer->light_directional_get_shadow_param(p_light->base_rid,VS::LIGHT_DIRECTIONAL_SHADOW_PARAM_MAX_DISTANCE);
-	if (max_dist>0.0)
-		cull_max=MIN(cull_max,max_dist);
+	float cull_min = p_camera->znear;
+	float cull_max = p_camera->zfar;
+	float max_dist = rasterizer->light_directional_get_shadow_param(p_light->base_rid, VS::LIGHT_DIRECTIONAL_SHADOW_PARAM_MAX_DISTANCE);
+	if (max_dist > 0.0)
+		cull_max = MIN(cull_max, max_dist);
 
-	for(int i = 0; i < splits; i++) {
+	for (int i = 0; i < splits; i++) {
 		float idm = i / (float)splits;
-		float lg = cull_min * Math::pow(cull_max/cull_min, idm);
+		float lg = cull_min * Math::pow(cull_max / cull_min, idm);
 		float uniform = cull_min + (cull_max - cull_min) * idm;
 		distances[i] = lg * split_weight + uniform * (1.0 - split_weight);
-
 	}
 
-	distances[0]=cull_min;
-	distances[splits]=cull_max;
+	distances[0] = cull_min;
+	distances[splits] = cull_max;
 
-	for (int i=0;i<splits;i++) {
+	for (int i = 0; i < splits; i++) {
 
 		// setup a camera matrix for that range!
 		CameraMatrix camera_matrix;
 
-		switch(p_camera->type) {
+		switch (p_camera->type) {
 
 			case Camera::ORTHOGONAL: {
 
 				camera_matrix.set_orthogonal(
-					p_camera->size,
-					viewport_rect.width / (float)viewport_rect.height,
-					distances[(i==0 || !overlap )?i:i-1],
-					distances[i+1],
-					p_camera->vaspect
+						p_camera->size,
+						viewport_rect.width / (float)viewport_rect.height,
+						distances[(i == 0 || !overlap) ? i : i - 1],
+						distances[i + 1],
+						p_camera->vaspect
 
-				);
+						);
 			} break;
 			case Camera::PERSPECTIVE: {
 
-
 				camera_matrix.set_perspective(
-					p_camera->fov,
-					viewport_rect.width / (float)viewport_rect.height,
-					distances[(i==0 || !overlap )?i:i-1],
-					distances[i+1],
-					p_camera->vaspect
+						p_camera->fov,
+						viewport_rect.width / (float)viewport_rect.height,
+						distances[(i == 0 || !overlap) ? i : i - 1],
+						distances[i + 1],
+						p_camera->vaspect
 
-				);
+						);
 
 			} break;
 		}
@@ -5021,96 +4624,86 @@ void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light,Sc
 		//obtain the frustum endpoints
 
 		Vector3 endpoints[8]; // frustum plane endpoints
-		bool res = camera_matrix.get_endpoints(p_camera->transform,endpoints);
+		bool res = camera_matrix.get_endpoints(p_camera->transform, endpoints);
 		ERR_CONTINUE(!res);
 
 		// obtain the light frustm ranges (given endpoints)
 
-		Vector3 x_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_X ).normalized();
-		Vector3 y_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Y ).normalized();
-		Vector3 z_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Z ).normalized();
+		Vector3 x_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_X).normalized();
+		Vector3 y_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Y).normalized();
+		Vector3 z_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
 		//z_vec points agsint the camera, like in default opengl
 
-		float x_min,x_max;
-		float y_min,y_max;
-		float z_min,z_max;
-
-		float x_min_cam,x_max_cam;
-		float y_min_cam,y_max_cam;
-		float z_min_cam,z_max_cam;
+		float x_min, x_max;
+		float y_min, y_max;
+		float z_min, z_max;
 
+		float x_min_cam, x_max_cam;
+		float y_min_cam, y_max_cam;
+		float z_min_cam, z_max_cam;
 
 		//used for culling
-		for(int j=0;j<8;j++) {
+		for (int j = 0; j < 8; j++) {
 
-			float d_x=x_vec.dot(endpoints[j]);
-			float d_y=y_vec.dot(endpoints[j]);
-			float d_z=z_vec.dot(endpoints[j]);
+			float d_x = x_vec.dot(endpoints[j]);
+			float d_y = y_vec.dot(endpoints[j]);
+			float d_z = z_vec.dot(endpoints[j]);
 
-			if (j==0 || d_x<x_min)
-				x_min=d_x;
-			if (j==0 || d_x>x_max)
-				x_max=d_x;
-
-			if (j==0 || d_y<y_min)
-				y_min=d_y;
-			if (j==0 || d_y>y_max)
-				y_max=d_y;
-
-			if (j==0 || d_z<z_min)
-				z_min=d_z;
-			if (j==0 || d_z>z_max)
-				z_max=d_z;
+			if (j == 0 || d_x < x_min)
+				x_min = d_x;
+			if (j == 0 || d_x > x_max)
+				x_max = d_x;
 
+			if (j == 0 || d_y < y_min)
+				y_min = d_y;
+			if (j == 0 || d_y > y_max)
+				y_max = d_y;
 
+			if (j == 0 || d_z < z_min)
+				z_min = d_z;
+			if (j == 0 || d_z > z_max)
+				z_max = d_z;
 		}
 
-
-
-
-
 		{
 			//camera viewport stuff
 			//this trick here is what stabilizes the shadow (make potential jaggies to not move)
 			//at the cost of some wasted resolution. Still the quality increase is very well worth it
 
-
 			Vector3 center;
 
-			for(int j=0;j<8;j++) {
+			for (int j = 0; j < 8; j++) {
 
-				center+=endpoints[j];
+				center += endpoints[j];
 			}
-			center/=8.0;
+			center /= 8.0;
 
 			//center=x_vec*(x_max-x_min)*0.5 + y_vec*(y_max-y_min)*0.5 + z_vec*(z_max-z_min)*0.5;
 
-			float radius=0;
+			float radius = 0;
 
-			for(int j=0;j<8;j++) {
+			for (int j = 0; j < 8; j++) {
 
 				float d = center.distance_to(endpoints[j]);
-				if (d>radius)
-					radius=d;
+				if (d > radius)
+					radius = d;
 			}
 
+			radius *= texsize / (texsize - 2.0); //add a texel by each side, so stepified texture will always fit
 
-			radius *= texsize/(texsize-2.0); //add a texel by each side, so stepified texture will always fit
-
-			x_max_cam=x_vec.dot(center)+radius;
-			x_min_cam=x_vec.dot(center)-radius;
-			y_max_cam=y_vec.dot(center)+radius;
-			y_min_cam=y_vec.dot(center)-radius;
-			z_max_cam=z_vec.dot(center)+radius;
-			z_min_cam=z_vec.dot(center)-radius;
+			x_max_cam = x_vec.dot(center) + radius;
+			x_min_cam = x_vec.dot(center) - radius;
+			y_max_cam = y_vec.dot(center) + radius;
+			y_min_cam = y_vec.dot(center) - radius;
+			z_max_cam = z_vec.dot(center) + radius;
+			z_min_cam = z_vec.dot(center) - radius;
 
-			float unit = radius*2.0/texsize;
-
-			x_max_cam=Math::stepify(x_max_cam,unit);
-			x_min_cam=Math::stepify(x_min_cam,unit);
-			y_max_cam=Math::stepify(y_max_cam,unit);
-			y_min_cam=Math::stepify(y_min_cam,unit);
+			float unit = radius * 2.0 / texsize;
 
+			x_max_cam = Math::stepify(x_max_cam, unit);
+			x_min_cam = Math::stepify(x_min_cam, unit);
+			y_max_cam = Math::stepify(y_max_cam, unit);
+			y_min_cam = Math::stepify(y_min_cam, unit);
 		}
 
 		//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
@@ -5119,91 +4712,85 @@ void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light,Sc
 		light_frustum_planes.resize(6);
 
 		//right/left
-		light_frustum_planes[0]=Plane( x_vec, x_max );
-		light_frustum_planes[1]=Plane( -x_vec, -x_min );
+		light_frustum_planes[0] = Plane(x_vec, x_max);
+		light_frustum_planes[1] = Plane(-x_vec, -x_min);
 		//top/bottom
-		light_frustum_planes[2]=Plane( y_vec, y_max );
-		light_frustum_planes[3]=Plane( -y_vec, -y_min );
+		light_frustum_planes[2] = Plane(y_vec, y_max);
+		light_frustum_planes[3] = Plane(-y_vec, -y_min);
 		//near/far
-		light_frustum_planes[4]=Plane( z_vec, z_max+1e6 );
-		light_frustum_planes[5]=Plane( -z_vec, -z_min ); // z_min is ok, since casters further than far-light plane are not needed
+		light_frustum_planes[4] = Plane(z_vec, z_max + 1e6);
+		light_frustum_planes[5] = Plane(-z_vec, -z_min); // z_min is ok, since casters further than far-light plane are not needed
 
-		int caster_cull_count = p_scenario->octree.cull_convex(light_frustum_planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
+		int caster_cull_count = p_scenario->octree.cull_convex(light_frustum_planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
 
 		// a pre pass will need to be needed to determine the actual z-near to be used
-		for(int j=0;j<caster_cull_count;j++) {
+		for (int j = 0; j < caster_cull_count; j++) {
 
-			float min,max;
-			Instance *ins=instance_shadow_cull_result[j];
+			float min, max;
+			Instance *ins = instance_shadow_cull_result[j];
 			if (!ins->visible || ins->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
 				continue;
-			ins->transformed_aabb.project_range_in_plane(Plane(z_vec,0),min,max);
+			ins->transformed_aabb.project_range_in_plane(Plane(z_vec, 0), min, max);
 
-			if (max>z_max)
-				z_max=max;
+			if (max > z_max)
+				z_max = max;
 		}
 
 		{
 			CameraMatrix ortho_camera;
-			real_t half_x = (x_max_cam-x_min_cam) * 0.5;
-			real_t half_y = (y_max_cam-y_min_cam) * 0.5;
-
+			real_t half_x = (x_max_cam - x_min_cam) * 0.5;
+			real_t half_y = (y_max_cam - y_min_cam) * 0.5;
 
-			ortho_camera.set_orthogonal( -half_x, half_x,-half_y,half_y, 0, (z_max-z_min_cam) );
+			ortho_camera.set_orthogonal(-half_x, half_x, -half_y, half_y, 0, (z_max - z_min_cam));
 
 			Transform ortho_transform;
-			ortho_transform.basis=p_light->data.transform.basis;
-			ortho_transform.origin=x_vec*(x_min_cam+half_x)+y_vec*(y_min_cam+half_y)+z_vec*z_max;
+			ortho_transform.basis = p_light->data.transform.basis;
+			ortho_transform.origin = x_vec * (x_min_cam + half_x) + y_vec * (y_min_cam + half_y) + z_vec * z_max;
 
-			rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, i, ortho_camera, ortho_transform,distances[i],distances[i+1] );
+			rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, i, ortho_camera, ortho_transform, distances[i], distances[i + 1]);
 		}
 
-		rasterizer->begin_shadow_map( p_light->light_info->instance, i );
+		rasterizer->begin_shadow_map(p_light->light_info->instance, i);
 
-		for (int j=0;j<caster_cull_count;j++) {
+		for (int j = 0; j < caster_cull_count; j++) {
 
 			Instance *instance = instance_shadow_cull_result[j];
-			if (!instance->visible || instance->data.cast_shadows==VS::SHADOW_CASTING_SETTING_OFF)
+			if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
 				continue;
 			_instance_draw(instance);
 		}
 
 		rasterizer->end_shadow_map();
-
-
 	}
-
-
 }
 
-
-CameraMatrix _lispm_look( const Vector3 pos, const Vector3 dir, const Vector3 up) {
+CameraMatrix _lispm_look(const Vector3 pos, const Vector3 dir, const Vector3 up) {
 
 	Vector3 dirN;
 	Vector3 upN;
 	Vector3 lftN;
 
-	lftN=dir.cross(up);
+	lftN = dir.cross(up);
 	lftN.normalize();
 
-	upN=lftN.cross(dir);
+	upN = lftN.cross(dir);
 	upN.normalize();
-	dirN=dir.normalized();
+	dirN = dir.normalized();
 
 	CameraMatrix cmout;
-	float *output=&cmout.matrix[0][0];
-	output[ 0] = lftN[0];
-	output[ 1] = upN[0];
-	output[ 2] = -dirN[0];
-	output[ 3] = 0.0;
+	float *output = &cmout.matrix[0][0];
+	output[0] = lftN[0];
+	output[1] = upN[0];
+	output[2] = -dirN[0];
+	output[3] = 0.0;
 
-	output[ 4] = lftN[1];
-	output[ 5] = upN[1];
-	output[ 6] = -dirN[1];
-	output[ 7] = 0.0;
+	output[4] = lftN[1];
+	output[5] = upN[1];
+	output[6] = -dirN[1];
+	output[7] = 0.0;
 
-	output[ 8] = lftN[2];
-	output[ 9] = upN[2];
+	output[8] = lftN[2];
+	output[9] = upN[2];
 	output[10] = -dirN[2];
 	output[11] = 0.0;
 
@@ -5215,121 +4802,112 @@ CameraMatrix _lispm_look( const Vector3 pos, const Vector3 dir, const Vector3 up
 	return cmout;
 }
 
-
-
 #if 1
 
-void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
+void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
 
 	Vector3 light_vec = -p_light->data.transform.basis.get_axis(2);
 	Vector3 view_vec = -p_camera->transform.basis.get_axis(2);
 
-	float near_dist=1;
+	float near_dist = 1;
 
-	Vector<Plane> light_frustum_planes = _camera_generate_orthogonal_planes(p_light,p_camera,p_cull_range.min,p_cull_range.max);
-	int caster_count = p_scenario->octree.cull_convex(light_frustum_planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
+	Vector<Plane> light_frustum_planes = _camera_generate_orthogonal_planes(p_light, p_camera, p_cull_range.min, p_cull_range.max);
+	int caster_count = p_scenario->octree.cull_convex(light_frustum_planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
 
 	// this could be faster by just getting supports from the AABBs..
 	// but, safer to do as the original implementation explains for now..
 
 	Vector<Vector3> caster_pointcloud;
-	caster_pointcloud.resize(caster_count*8);
-	int caster_pointcloud_size=0;
+	caster_pointcloud.resize(caster_count * 8);
+	int caster_pointcloud_size = 0;
 
 	{
 
 		//fill pointcloud
-		Vector3* caster_pointcloud_ptr=&caster_pointcloud[0];
+		Vector3 *caster_pointcloud_ptr = &caster_pointcloud[0];
 
-		for(int i=0;i<caster_count;i++) {
+		for (int i = 0; i < caster_count; i++) {
 
 			Instance *ins = instance_shadow_cull_result[i];
 			if (!ins->visible || ins->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
 				continue;
 
-			for(int j=0;j<8;j++) {
+			for (int j = 0; j < 8; j++) {
 
 				Vector3 v = ins->aabb.get_endpoint(j);
 				v = ins->data.transform.xform(v);
-				caster_pointcloud_ptr[caster_pointcloud_size+j]=v;
+				caster_pointcloud_ptr[caster_pointcloud_size + j] = v;
 			}
 
-			caster_pointcloud_size+=8;
-
+			caster_pointcloud_size += 8;
 		}
 	}
 
 	// now generate a pointcloud that contains the maximum bound (camera extruded by light)
 
-	Vector<Vector3> camera_pointcloud = _camera_generate_endpoints(p_light,p_camera,p_cull_range.min,p_cull_range.max);
-	int cpcsize=camera_pointcloud.size();
-	camera_pointcloud.resize( cpcsize*2 );
+	Vector<Vector3> camera_pointcloud = _camera_generate_endpoints(p_light, p_camera, p_cull_range.min, p_cull_range.max);
+	int cpcsize = camera_pointcloud.size();
+	camera_pointcloud.resize(cpcsize * 2);
 
-	for(int i=0;i<cpcsize;i++) {
+	for (int i = 0; i < cpcsize; i++) {
 
-		camera_pointcloud[i+cpcsize]=camera_pointcloud[i]-light_vec*1000;
+		camera_pointcloud[i + cpcsize] = camera_pointcloud[i] - light_vec * 1000;
 	}
 
-
-
 	// Vector<Vector3> frustum_points=_camera_generate_endpoints(p_light,p_camera,p_cull_range.min,p_cull_range.max);
 
-
 	//  compute the "light-space" basis, using the algorithm described in the paper
 	//  note:  since bodyB is defined in eye space, all of these vectors should also be defined in eye space
 
-
 	Vector3 eye = p_camera->transform.origin;
 	Vector3 up = light_vec.cross(view_vec).cross(light_vec).normalized();
 
-
-	CameraMatrix light_space_basis = _lispm_look(eye,light_vec,up);
+	CameraMatrix light_space_basis = _lispm_look(eye, light_vec, up);
 
 	AABB light_space_aabb;
 
-
 	{ //create an optimal AABB from both the camera pointcloud and the objects pointcloud
 		AABB light_space_pointcloud_aabb;
 		AABB light_space_camera_aabb;
 		//xform pointcloud
-		const Vector3* caster_pointcloud_ptr=&caster_pointcloud[0];
+		const Vector3 *caster_pointcloud_ptr = &caster_pointcloud[0];
 
-		for(int i=0;i<caster_pointcloud_size;i++) {
+		for (int i = 0; i < caster_pointcloud_size; i++) {
 
 			Vector3 p = light_space_basis.xform(caster_pointcloud_ptr[i]);
-			if (i==0) {
-				light_space_pointcloud_aabb.pos=p;
+			if (i == 0) {
+				light_space_pointcloud_aabb.pos = p;
 			} else {
 				light_space_pointcloud_aabb.expand_to(p);
 			}
 		}
-		for(int i=0;i<camera_pointcloud.size();i++) {
+		for (int i = 0; i < camera_pointcloud.size(); i++) {
 
 			Vector3 p = light_space_basis.xform(camera_pointcloud[i]);
-			if (i==0) {
-				light_space_camera_aabb.pos=p;
+			if (i == 0) {
+				light_space_camera_aabb.pos = p;
 			} else {
 				light_space_camera_aabb.expand_to(p);
 			}
 		}
 
-		light_space_aabb=light_space_pointcloud_aabb.intersection(light_space_camera_aabb);
+		light_space_aabb = light_space_pointcloud_aabb.intersection(light_space_camera_aabb);
 	}
 
 	float lvdp = light_vec.dot(view_vec);
 
-	float sin_gamma = Math::sqrt(1.0-lvdp*lvdp);
+	float sin_gamma = Math::sqrt(1.0 - lvdp * lvdp);
 	//use the formulas of the paper to get n (and f)
-	float factor = 1.0/sin_gamma;
-	float z_n = factor*near_dist; //often 1
+	float factor = 1.0 / sin_gamma;
+	float z_n = factor * near_dist; //often 1
 	float d = Math::abs(light_space_aabb.size.y); //perspective transform depth //light space y extents
-	float z_f = z_n + d*sin_gamma;
-	float n = (z_n+Math::sqrt(z_f*z_n))/sin_gamma;
-	float f = n+d;
+	float z_f = z_n + d * sin_gamma;
+	float n = (z_n + Math::sqrt(z_f * z_n)) / sin_gamma;
+	float f = n + d;
 
-	Vector3 pos = eye - up*(n-near_dist);
+	Vector3 pos = eye - up * (n - near_dist);
 
-	CameraMatrix light_space_basis2 = _lispm_look(pos,light_vec,up);
+	CameraMatrix light_space_basis2 = _lispm_look(pos, light_vec, up);
 	//Transform light_space_basis2;
 	//light_space_basis2.set_look_at(pos,light_vec-pos,up);
 	//light_space_basis2.affine_invert();
@@ -5338,15 +4916,14 @@ void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,
 	//with the two parameters n(near) and f(far) in y direction
 
 	CameraMatrix lisp_matrix;
-	lisp_matrix.matrix[1][1]=(f+n)/(f-n);
-	lisp_matrix.matrix[3][1]=-2*f*n/(f-n);
-	lisp_matrix.matrix[1][3]=1;
-	lisp_matrix.matrix[3][3]=0;
+	lisp_matrix.matrix[1][1] = (f + n) / (f - n);
+	lisp_matrix.matrix[3][1] = -2 * f * n / (f - n);
+	lisp_matrix.matrix[1][3] = 1;
+	lisp_matrix.matrix[3][3] = 0;
 
 	CameraMatrix projection = lisp_matrix * light_space_basis2;
 	//CameraMatrix projection = light_space_basis2 * lisp_matrix;
 
-
 	AABB proj_space_aabb;
 
 	{
@@ -5354,44 +4931,44 @@ void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,
 		AABB proj_space_pointcloud_aabb;
 		AABB proj_space_camera_aabb;
 		//xform pointcloud
-		Vector3* caster_pointcloud_ptr=&caster_pointcloud[0];
-		for(int i=0;i<caster_pointcloud_size;i++) {
+		Vector3 *caster_pointcloud_ptr = &caster_pointcloud[0];
+		for (int i = 0; i < caster_pointcloud_size; i++) {
 
 			Vector3 p = projection.xform(caster_pointcloud_ptr[i]);
-			if (i==0) {
-				proj_space_pointcloud_aabb.pos=p;
+			if (i == 0) {
+				proj_space_pointcloud_aabb.pos = p;
 			} else {
 				proj_space_pointcloud_aabb.expand_to(p);
 			}
 		}
 
-		for(int i=0;i<camera_pointcloud.size();i++) {
+		for (int i = 0; i < camera_pointcloud.size(); i++) {
 
 			Vector3 p = projection.xform(camera_pointcloud[i]);
-			if (i==0) {
-				proj_space_camera_aabb.pos=p;
+			if (i == 0) {
+				proj_space_camera_aabb.pos = p;
 			} else {
 				proj_space_camera_aabb.expand_to(p);
 			}
 		}
 
 		//proj_space_aabb=proj_space_pointcloud_aabb.intersection_with(proj_space_camera_aabb);
-		proj_space_aabb=proj_space_pointcloud_aabb;
+		proj_space_aabb = proj_space_pointcloud_aabb;
 	}
 
 	projection.scale_translate_to_fit(proj_space_aabb);
-	projection=projection * lisp_matrix;
+	projection = projection * lisp_matrix;
 
 	CameraMatrix scale;
-	scale.make_scale(Vector3(1.0,1.0,-1.0)); // transform to left handed
+	scale.make_scale(Vector3(1.0, 1.0, -1.0)); // transform to left handed
 
-	projection=scale * projection;
+	projection = scale * projection;
 
-	rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance,0, projection , light_space_basis2.inverse() );
+	rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, 0, projection, light_space_basis2.inverse());
 
-	rasterizer->begin_shadow_map( p_light->light_info->instance,  0 );
+	rasterizer->begin_shadow_map(p_light->light_info->instance, 0);
 
-	for(int i=0;i<caster_count;i++) {
+	for (int i = 0; i < caster_count; i++) {
 
 		Instance *instance = instance_shadow_cull_result[i];
 
@@ -5401,19 +4978,14 @@ void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,
 	}
 
 	rasterizer->end_shadow_map();
-
-
 }
 
 #else
 
-
-void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
+void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
 
 	/* STEP 1: GENERATE LIGHT TRANSFORM */
 
-
-
 	Vector3 light_vec = -p_light->data.transform.basis.get_axis(2);
 	Vector3 view_vec = -p_camera->transform.basis.get_axis(2);
 	float viewdot = Math::absf(light_vec.dot(view_vec));
@@ -5421,48 +4993,44 @@ void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,
 	Vector3 up = light_vec.cross(view_vec).cross(light_vec).normalized();
 
 	Transform light_transform;
-	light_transform.set_look_at(Vector3(),light_vec,up);
-
+	light_transform.set_look_at(Vector3(), light_vec, up);
 
 	/* STEP 2: GENERATE WORDLSPACE PLANES AND VECTORS*/
-	float range_min=0.01; //p_cull_range.min
-	float range_max=20;//p_cull_range.max;
+	float range_min = 0.01; //p_cull_range.min
+	float range_max = 20; //p_cull_range.max;
 
-	Vector<Vector3> camera_endpoints=_camera_generate_endpoints(p_light,p_camera,range_min,range_max); // frustum plane endpoints
+	Vector<Vector3> camera_endpoints = _camera_generate_endpoints(p_light, p_camera, range_min, range_max); // frustum plane endpoints
 	ERR_FAIL_COND(camera_endpoints.empty());
 
 	// obtain the light frustm ranges (given endpoints)
 
-
-	Vector3 light_x_vec=light_transform.basis.get_axis( Vector3::AXIS_X ).normalized();
-	Vector3 light_y_vec=light_transform.basis.get_axis( Vector3::AXIS_Y ).normalized();
-	Vector3 light_z_vec=light_transform.basis.get_axis( Vector3::AXIS_Z ).normalized();
+	Vector3 light_x_vec = light_transform.basis.get_axis(Vector3::AXIS_X).normalized();
+	Vector3 light_y_vec = light_transform.basis.get_axis(Vector3::AXIS_Y).normalized();
+	Vector3 light_z_vec = light_transform.basis.get_axis(Vector3::AXIS_Z).normalized();
 
 	Vector3 light_axis_max;
 	Vector3 light_axis_min;
 
-	for(int j=0;j<8;j++) {
-
-		float d_x=light_x_vec.dot(camera_endpoints[j]);
-		float d_y=light_y_vec.dot(camera_endpoints[j]);
-		float d_z=light_z_vec.dot(camera_endpoints[j]);
+	for (int j = 0; j < 8; j++) {
 
-		if (j==0 || d_x<light_axis_min.x)
-			light_axis_min.x=d_x;
-		if (j==0 || d_x>light_axis_max.x)
-			light_axis_max.x=d_x;
+		float d_x = light_x_vec.dot(camera_endpoints[j]);
+		float d_y = light_y_vec.dot(camera_endpoints[j]);
+		float d_z = light_z_vec.dot(camera_endpoints[j]);
 
-		if (j==0 || d_y<light_axis_min.y)
-			light_axis_min.y=d_y;
-		if (j==0 || d_y>light_axis_max.y)
-			light_axis_max.y=d_y;
-
-		if (j==0 || d_z<light_axis_min.z)
-			light_axis_min.z=d_z;
-		if (j==0 || d_z>light_axis_max.z)
-			light_axis_max.z=d_z;
+		if (j == 0 || d_x < light_axis_min.x)
+			light_axis_min.x = d_x;
+		if (j == 0 || d_x > light_axis_max.x)
+			light_axis_max.x = d_x;
 
+		if (j == 0 || d_y < light_axis_min.y)
+			light_axis_min.y = d_y;
+		if (j == 0 || d_y > light_axis_max.y)
+			light_axis_max.y = d_y;
 
+		if (j == 0 || d_z < light_axis_min.z)
+			light_axis_min.z = d_z;
+		if (j == 0 || d_z > light_axis_max.z)
+			light_axis_max.z = d_z;
 	}
 
 	//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
@@ -5470,164 +5038,151 @@ void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,
 	Vector<Plane> light_cull_planes;
 	light_cull_planes.resize(6);
 
-
 	//right/left
-	light_cull_planes[0]=Plane( light_x_vec, light_axis_max.x );
-	light_cull_planes[1]=Plane( -light_x_vec, -light_axis_min.x );
+	light_cull_planes[0] = Plane(light_x_vec, light_axis_max.x);
+	light_cull_planes[1] = Plane(-light_x_vec, -light_axis_min.x);
 	//top/bottom
-	light_cull_planes[2]=Plane( light_y_vec, light_axis_max.y );
-	light_cull_planes[3]=Plane( -light_y_vec, -light_axis_min.y );
+	light_cull_planes[2] = Plane(light_y_vec, light_axis_max.y);
+	light_cull_planes[3] = Plane(-light_y_vec, -light_axis_min.y);
 	//near/far
-	light_cull_planes[4]=Plane( light_z_vec, light_axis_max.z+1e6 );
-	light_cull_planes[5]=Plane( -light_z_vec, -light_axis_min.z ); // z_min is ok, since casters further than far-light plane are not needed
-
+	light_cull_planes[4] = Plane(light_z_vec, light_axis_max.z + 1e6);
+	light_cull_planes[5] = Plane(-light_z_vec, -light_axis_min.z); // z_min is ok, since casters further than far-light plane are not needed
 
 	/* STEP 3: CULL CASTERS */
 
-	int caster_count = p_scenario->octree.cull_convex(light_cull_planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
+	int caster_count = p_scenario->octree.cull_convex(light_cull_planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
 
 	/* STEP 4: ADJUST FAR Z PLANE */
 
-	float caster_max_z=1e-1;
-	for(int i=0;i<caster_count;i++) {
+	float caster_max_z = 1e-1;
+	for (int i = 0; i < caster_count; i++) {
 
-		Instance *ins=instance_shadow_cull_result[i];
-		if (!ins->visible || ins->cast_shadows==VS::SHADOW_CASTING_SETTING_OFF)
+		Instance *ins = instance_shadow_cull_result[i];
+		if (!ins->visible || ins->cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
 			continue;
 
 		//@TODO optimize using support mapping
-		for(int j=0;j<8;j++) {
+		for (int j = 0; j < 8; j++) {
 
-			Vector3 v=ins->data.transform.xform(ins->aabb.get_endpoint(j));
+			Vector3 v = ins->data.transform.xform(ins->aabb.get_endpoint(j));
 			float d = light_z_vec.dot(v);
-			if (d>caster_max_z)
-				caster_max_z=d;
-
+			if (d > caster_max_z)
+				caster_max_z = d;
 		}
-
 	}
 
-	float expand = caster_max_z-light_axis_max.z;
-	if (expand<0)
-		expand=0;
-	light_axis_max.z=MAX(caster_max_z,light_axis_max.z);
+	float expand = caster_max_z - light_axis_max.z;
+	if (expand < 0)
+		expand = 0;
+	light_axis_max.z = MAX(caster_max_z, light_axis_max.z);
 
 	/* STEP 5: CREATE ORTHOGONAL PROJECTION */
 
 	CameraMatrix light_projection;
 
-	real_t half_x = (light_axis_max.x-light_axis_min.x) * 0.5;
-	real_t half_y = (light_axis_max.y-light_axis_min.y) * 0.5;
-	light_projection.set_orthogonal( -half_x, half_x,half_y, -half_y, 0, (light_axis_max.z-light_axis_min.z) );
-	light_transform.origin=light_x_vec*(light_axis_min.x+half_x)+light_y_vec*(light_axis_min.y+half_y)+light_z_vec*light_axis_max.z;
-
+	real_t half_x = (light_axis_max.x - light_axis_min.x) * 0.5;
+	real_t half_y = (light_axis_max.y - light_axis_min.y) * 0.5;
+	light_projection.set_orthogonal(-half_x, half_x, half_y, -half_y, 0, (light_axis_max.z - light_axis_min.z));
+	light_transform.origin = light_x_vec * (light_axis_min.x + half_x) + light_y_vec * (light_axis_min.y + half_y) + light_z_vec * light_axis_max.z;
 
-	if (/*false &&*/ viewdot<0.96) {
+	if (/*false &&*/ viewdot < 0.96) {
 
 		float lvdp = light_vec.dot(view_vec);
 
-		float near_dist=1.0;
-		float sin_gamma = Math::sqrt(1.0-lvdp*lvdp);
+		float near_dist = 1.0;
+		float sin_gamma = Math::sqrt(1.0 - lvdp * lvdp);
 		//use the formulas of the paper to get n (and f)
-		float factor = 1.0/sin_gamma;
-		float z_n = factor*near_dist; //often 1
-		float d = Math::abs(light_axis_max.y-light_axis_min.y); //perspective transform depth //light space y extents
-		float z_f = z_n + d*sin_gamma;
-		float n = (z_n+Math::sqrt(z_f*z_n))/sin_gamma;
-		float f = n+d;
+		float factor = 1.0 / sin_gamma;
+		float z_n = factor * near_dist; //often 1
+		float d = Math::abs(light_axis_max.y - light_axis_min.y); //perspective transform depth //light space y extents
+		float z_f = z_n + d * sin_gamma;
+		float n = (z_n + Math::sqrt(z_f * z_n)) / sin_gamma;
+		float f = n + d;
 
 		CameraMatrix lisp_matrix;
-		lisp_matrix.matrix[1][1]=(f+n)/(f-n);
-		lisp_matrix.matrix[3][1]=-2*f*n/(f-n);
-		lisp_matrix.matrix[1][3]=1;
-		lisp_matrix.matrix[3][3]=0;
+		lisp_matrix.matrix[1][1] = (f + n) / (f - n);
+		lisp_matrix.matrix[3][1] = -2 * f * n / (f - n);
+		lisp_matrix.matrix[1][3] = 1;
+		lisp_matrix.matrix[3][3] = 0;
 
-		Vector3 pos = p_camera->transform.origin - up*(n-near_dist);
+		Vector3 pos = p_camera->transform.origin - up * (n - near_dist);
 
-		CameraMatrix world2light = _lispm_look(pos,light_vec,up);
+		CameraMatrix world2light = _lispm_look(pos, light_vec, up);
 		CameraMatrix projection = lisp_matrix * world2light;
 
 		AABB projection_bounds;
-		for(int i=0;i<camera_endpoints.size();i++) {
+		for (int i = 0; i < camera_endpoints.size(); i++) {
 
-			Vector3 p=camera_endpoints[i];
-			if (i==0)
-				projection_bounds.pos=projection.xform(p);
+			Vector3 p = camera_endpoints[i];
+			if (i == 0)
+				projection_bounds.pos = projection.xform(p);
 			else
 				projection_bounds.expand_to(projection.xform(p));
 
-			projection_bounds.expand_to(projection.xform(p+light_vec*-expand));
+			projection_bounds.expand_to(projection.xform(p + light_vec * -expand));
 		}
 
 		CameraMatrix scaletrans;
 		scaletrans.scale_translate_to_fit(projection_bounds);
-		projection=scaletrans * lisp_matrix;
+		projection = scaletrans * lisp_matrix;
 
 		CameraMatrix scale;
-		scale.make_scale(Vector3(1.0,1.0,-1.0)); // transform to left handed
+		scale.make_scale(Vector3(1.0, 1.0, -1.0)); // transform to left handed
 
-		projection=scale * projection;
+		projection = scale * projection;
 
-
-		rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance,0, projection, world2light.inverse(), viewdot);
+		rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, 0, projection, world2light.inverse(), viewdot);
 
 	} else {
 		//orthogonal
-		rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance,0, light_projection , light_transform, viewdot);
+		rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, 0, light_projection, light_transform, viewdot);
 	}
 
-	rasterizer->begin_shadow_map( p_light->light_info->instance,  0 );
+	rasterizer->begin_shadow_map(p_light->light_info->instance, 0);
 
-	for(int i=0;i<caster_count;i++) {
+	for (int i = 0; i < caster_count; i++) {
 
 		Instance *instance = instance_shadow_cull_result[i];
 
-		if (!instance->visible || instance->cast_shadows==VS::SHADOW_CASTING_SETTING_OFF)
+		if (!instance->visible || instance->cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
 			continue;
 		_instance_draw(instance);
 	}
 
 	rasterizer->end_shadow_map();
-
 }
 
 #endif
 
+void VisualServerRaster::_light_instance_update_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
 
-void VisualServerRaster::_light_instance_update_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
-
-
-
-	if (!rasterizer->shadow_allocate_near( p_light->light_info->instance ))
+	if (!rasterizer->shadow_allocate_near(p_light->light_info->instance))
 		return; // shadow could not be updated
 
-
 	/* VisualServerRaster supports for many shadow techniques, using the one the rasterizer requests */
 
 	Rasterizer::ShadowType shadow_type = rasterizer->light_instance_get_shadow_type(p_light->light_info->instance);
 
-	switch(shadow_type) {
+	switch (shadow_type) {
 
 		case Rasterizer::SHADOW_SIMPLE: {
 			/* SPOT SHADOW */
 
-
-			rasterizer->begin_shadow_map( p_light->light_info->instance, 0 );
+			rasterizer->begin_shadow_map(p_light->light_info->instance, 0);
 
 			//using this one ensures that raster deferred will have it
 
-			float far = rasterizer->light_get_var( p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
+			float far = rasterizer->light_get_var(p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
 
-			float angle = rasterizer->light_get_var( p_light->base_rid, VS::LIGHT_PARAM_SPOT_ANGLE );
+			float angle = rasterizer->light_get_var(p_light->base_rid, VS::LIGHT_PARAM_SPOT_ANGLE);
 
 			CameraMatrix cm;
-			cm.set_perspective( angle*2.0, 1.0, 0.001, far );
+			cm.set_perspective(angle * 2.0, 1.0, 0.001, far);
 
 			Vector<Plane> planes = cm.get_projection_planes(p_light->data.transform);
-			int cull_count = p_scenario->octree.cull_convex(planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
-
+			int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
 
-			for (int i=0;i<cull_count;i++) {
+			for (int i = 0; i < cull_count; i++) {
 
 				Instance *instance = instance_shadow_cull_result[i];
 				if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
@@ -5642,33 +5197,30 @@ void VisualServerRaster::_light_instance_update_shadow(Instance *p_light,Scenari
 
 			/* OMNI SHADOW */
 
-			int passes = rasterizer->light_instance_get_shadow_passes( p_light->light_info->instance );
+			int passes = rasterizer->light_instance_get_shadow_passes(p_light->light_info->instance);
 
-			if (passes==2) {
+			if (passes == 2) {
 
-				for(int i=0;i<2;i++) {
-
-					rasterizer->begin_shadow_map( p_light->light_info->instance, i );
+				for (int i = 0; i < 2; i++) {
 
+					rasterizer->begin_shadow_map(p_light->light_info->instance, i);
 
 					//using this one ensures that raster deferred will have it
 
-					float radius = rasterizer->light_get_var( p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
+					float radius = rasterizer->light_get_var(p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
 
-					float z =i==0?-1:1;
+					float z = i == 0 ? -1 : 1;
 					Vector<Plane> planes;
 					planes.resize(5);
-					planes[0]=p_light->data.transform.xform(Plane(Vector3(0,0,z),radius));
-					planes[1]=p_light->data.transform.xform(Plane(Vector3(1,0,z).normalized(),radius));
-					planes[2]=p_light->data.transform.xform(Plane(Vector3(-1,0,z).normalized(),radius));
-					planes[3]=p_light->data.transform.xform(Plane(Vector3(0,1,z).normalized(),radius));
-					planes[4]=p_light->data.transform.xform(Plane(Vector3(0,-1,z).normalized(),radius));
-
-
-					int cull_count = p_scenario->octree.cull_convex(planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
+					planes[0] = p_light->data.transform.xform(Plane(Vector3(0, 0, z), radius));
+					planes[1] = p_light->data.transform.xform(Plane(Vector3(1, 0, z).normalized(), radius));
+					planes[2] = p_light->data.transform.xform(Plane(Vector3(-1, 0, z).normalized(), radius));
+					planes[3] = p_light->data.transform.xform(Plane(Vector3(0, 1, z).normalized(), radius));
+					planes[4] = p_light->data.transform.xform(Plane(Vector3(0, -1, z).normalized(), radius));
 
+					int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
 
-					for (int j=0;j<cull_count;j++) {
+					for (int j = 0; j < cull_count; j++) {
 
 						Instance *instance = instance_shadow_cull_result[j];
 						if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
@@ -5679,11 +5231,8 @@ void VisualServerRaster::_light_instance_update_shadow(Instance *p_light,Scenari
 
 					rasterizer->end_shadow_map();
 				}
-			} else if (passes==1) {
+			} else if (passes == 1) {
 				//one go
-
-
-
 			}
 
 		} break;
@@ -5693,30 +5242,28 @@ void VisualServerRaster::_light_instance_update_shadow(Instance *p_light,Scenari
 		} break;
 		case Rasterizer::SHADOW_ORTHOGONAL: {
 
-			_light_instance_update_pssm_shadow(p_light,p_scenario,p_camera,p_cull_range);
+			_light_instance_update_pssm_shadow(p_light, p_scenario, p_camera, p_cull_range);
 		} break;
 		case Rasterizer::SHADOW_PSSM: {
 
-			_light_instance_update_pssm_shadow(p_light,p_scenario,p_camera,p_cull_range);
+			_light_instance_update_pssm_shadow(p_light, p_scenario, p_camera, p_cull_range);
 		} break;
 		case Rasterizer::SHADOW_PSM: {
 
-			_light_instance_update_lispsm_shadow(p_light,p_scenario,p_camera,p_cull_range);
-		 // todo
+			_light_instance_update_lispsm_shadow(p_light, p_scenario, p_camera, p_cull_range);
+			// todo
 		} break;
 		default: {}
 	}
-
 }
 
-void VisualServerRaster::_portal_disconnect(Instance *p_portal,bool p_cleanup) {
+void VisualServerRaster::_portal_disconnect(Instance *p_portal, bool p_cleanup) {
 
 	if (p_portal->portal_info->connected) {
 
 		//disconnect first
-		p_portal->portal_info->connected->portal_info->connected=NULL;
-		p_portal->portal_info->connected=NULL;
-
+		p_portal->portal_info->connected->portal_info->connected = NULL;
+		p_portal->portal_info->connected = NULL;
 	}
 
 	if (p_portal->room && p_portal->room->room) {
@@ -5729,57 +5276,55 @@ void VisualServerRaster::_portal_disconnect(Instance *p_portal,bool p_cleanup) {
 			p_portal->room->room->room_info->disconnected_child_portals.insert(p_portal);
 		}
 	}
-
 }
 
 void VisualServerRaster::_instance_validate_autorooms(Instance *p_geometry) {
 
-	if (p_geometry->auto_rooms.size()==0)
+	if (p_geometry->auto_rooms.size() == 0)
 		return;
 
 	p_geometry->valid_auto_rooms.clear();
 
 	int point_count = aabb_random_points.size();
-	const Vector3 * src_points = &aabb_random_points[0];
+	const Vector3 *src_points = &aabb_random_points[0];
 
-	for(Set<Instance*>::Element *E=p_geometry->valid_auto_rooms.front();E;E=E->next()) {
+	for (Set<Instance *>::Element *E = p_geometry->valid_auto_rooms.front(); E; E = E->next()) {
 
 		Instance *room = E->get();
-		Vector3 *dst_points=&transformed_aabb_random_points[0];
+		Vector3 *dst_points = &transformed_aabb_random_points[0];
 
 		//generate points
-		for(int i=0;i<point_count;i++) {
+		for (int i = 0; i < point_count; i++) {
 
-			dst_points[i] = room->room_info->affine_inverse.xform(p_geometry->data.transform.xform((src_points[i]*p_geometry->transformed_aabb.size)+p_geometry->transformed_aabb.pos));
+			dst_points[i] = room->room_info->affine_inverse.xform(p_geometry->data.transform.xform((src_points[i] * p_geometry->transformed_aabb.size) + p_geometry->transformed_aabb.pos));
 		}
 
-		int pass = room->room_info->room->bounds.get_points_inside(dst_points,point_count);
+		int pass = room->room_info->room->bounds.get_points_inside(dst_points, point_count);
 
 		float ratio = pass;
-		if( point_count != 0 ) {
+		if (point_count != 0) {
 			ratio /= (float)point_count;
 		}
 
-		if (ratio>0.5) // should make some constant
+		if (ratio > 0.5) // should make some constant
 			p_geometry->valid_auto_rooms.insert(room);
 	}
 }
 
 void VisualServerRaster::_portal_attempt_connect(Instance *p_portal) {
 
-
 	_portal_disconnect(p_portal);
 
 	Vector3 A_norm = p_portal->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
-	Plane A_plane( p_portal->data.transform.origin, A_norm );
+	Plane A_plane(p_portal->data.transform.origin, A_norm);
 	float A_surface = p_portal->portal_info->portal->bounds.get_area();
-	if (A_surface==0)
+	if (A_surface == 0)
 		return; //wtf
 
-	Instance *found=NULL;
+	Instance *found = NULL;
 	Transform affine_inverse = p_portal->data.transform.affine_inverse();
 
-	for(Set<Instance*>::Element *E=p_portal->portal_info->candidate_set.front();E;E=E->next()) {
+	for (Set<Instance *>::Element *E = p_portal->portal_info->candidate_set.front(); E; E = E->next()) {
 
 		Instance *B = E->get();
 
@@ -5791,65 +5336,57 @@ void VisualServerRaster::_portal_attempt_connect(Instance *p_portal) {
 		// check that they are in front of another
 		float dot = A_norm.dot(-B_norm);
 
-		if (dot<0.707) // 45 degrees, TODO unharcode this
+		if (dot < 0.707) // 45 degrees, TODO unharcode this
 			continue;
 
 		// check the max distance to the other portal
 
-		bool valid=true;
+		bool valid = true;
 
 		Rect2 local_bounds;
 
-		for(int i=0;i<B->portal_info->portal->shape.size();i++) {
+		for (int i = 0; i < B->portal_info->portal->shape.size(); i++) {
 
 			Point2 point2 = B->portal_info->portal->shape[i];
 
-			Vector3 point = B->data.transform.xform( Vector3( point2.x, point2.y, 0 ) );
+			Vector3 point = B->data.transform.xform(Vector3(point2.x, point2.y, 0));
 
 			float dist = Math::abs(A_plane.distance_to(point));
 
 			if (
-				dist>p_portal->portal_info->portal->connect_range ||
-				dist>B->portal_info->portal->connect_range ) {
-					valid=false;
-					break;
-				}
-
+					dist > p_portal->portal_info->portal->connect_range ||
+					dist > B->portal_info->portal->connect_range) {
+				valid = false;
+				break;
+			}
 
 			Vector3 point_local = affine_inverse.xform(A_plane.project(point));
-			point2 = Point2(point_local.x,point_local.y);
+			point2 = Point2(point_local.x, point_local.y);
 
-			if (i==0)
-				local_bounds.pos=point2;
+			if (i == 0)
+				local_bounds.pos = point2;
 			else
 				local_bounds.expand_to(point2);
-
-
 		}
 
 		if (!valid)
 			continue;
 
 		float B_surface = B->portal_info->portal->bounds.get_area();
-		if (B_surface==0)
+		if (B_surface == 0)
 			continue; //wtf
 
 		float clip_area = p_portal->portal_info->portal->bounds.clip(local_bounds).get_area();
 
-
 		//check that most of the area is shared
 
-		if ( (clip_area/A_surface) < 0.5 || (clip_area/B_surface) < 0.5) // TODO change for something else
+		if ((clip_area / A_surface) < 0.5 || (clip_area / B_surface) < 0.5) // TODO change for something else
 			continue;
 
-		found=B;
+		found = B;
 		break;
-
-
-
 	}
 
-
 	if (!found) {
 
 		if (p_portal->room && p_portal->room->room) {
@@ -5860,21 +5397,19 @@ void VisualServerRaster::_portal_attempt_connect(Instance *p_portal) {
 		return;
 	}
 
-	p_portal->portal_info->connected=found;
-	found->portal_info->connected=p_portal;
-
-
+	p_portal->portal_info->connected = found;
+	found->portal_info->connected = p_portal;
 }
 
-void* VisualServerRaster::instance_pair(void *p_self, OctreeElementID, Instance *p_A,int, OctreeElementID, Instance *p_B,int) {
+void *VisualServerRaster::instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int) {
 
-	VisualServerRaster *self = (VisualServerRaster*)p_self;
+	VisualServerRaster *self = (VisualServerRaster *)p_self;
 	Instance *A = p_A;
 	Instance *B = p_B;
 
-	if (A->base_type==INSTANCE_PORTAL) {
+	if (A->base_type == INSTANCE_PORTAL) {
 
-		ERR_FAIL_COND_V( B->base_type!=INSTANCE_PORTAL,NULL );
+		ERR_FAIL_COND_V(B->base_type != INSTANCE_PORTAL, NULL);
 
 		A->portal_info->candidate_set.insert(B);
 		B->portal_info->candidate_set.insert(A);
@@ -5883,56 +5418,52 @@ void* VisualServerRaster::instance_pair(void *p_self, OctreeElementID, Instance
 		//attempt to conncet portal A (will go through B anyway)
 		//this is a little hackish, but works fine in practice
 
-	} else if (A->base_type==INSTANCE_BAKED_LIGHT || B->base_type==INSTANCE_BAKED_LIGHT) {
+	} else if (A->base_type == INSTANCE_BAKED_LIGHT || B->base_type == INSTANCE_BAKED_LIGHT) {
 
-		if (B->base_type==INSTANCE_BAKED_LIGHT) {
-			SWAP(A,B);
+		if (B->base_type == INSTANCE_BAKED_LIGHT) {
+			SWAP(A, B);
 		}
 
-		ERR_FAIL_COND_V(B->base_type!=INSTANCE_BAKED_LIGHT_SAMPLER,NULL);
+		ERR_FAIL_COND_V(B->base_type != INSTANCE_BAKED_LIGHT_SAMPLER, NULL);
 		B->baked_light_sampler_info->baked_lights.insert(A);
 
-	} else if (A->base_type==INSTANCE_ROOM || B->base_type==INSTANCE_ROOM) {
+	} else if (A->base_type == INSTANCE_ROOM || B->base_type == INSTANCE_ROOM) {
 
-		if (B->base_type==INSTANCE_ROOM)
-			SWAP(A,B);
+		if (B->base_type == INSTANCE_ROOM)
+			SWAP(A, B);
 
-		ERR_FAIL_COND_V(! ((1<<B->base_type)&INSTANCE_GEOMETRY_MASK ),NULL);
+		ERR_FAIL_COND_V(!((1 << B->base_type) & INSTANCE_GEOMETRY_MASK), NULL);
 
 		B->auto_rooms.insert(A);
 		A->room_info->owned_autoroom_geometry.insert(B);
 
 		self->_instance_validate_autorooms(B);
 
-
 	} else {
 
-		if (B->base_type==INSTANCE_LIGHT) {
+		if (B->base_type == INSTANCE_LIGHT) {
 
-			SWAP(A,B);
-		} else if (A->base_type!=INSTANCE_LIGHT) {
+			SWAP(A, B);
+		} else if (A->base_type != INSTANCE_LIGHT) {
 			return NULL;
 		}
 
-
 		A->light_info->affected.insert(B);
 		B->lights.insert(A);
-		B->light_cache_dirty=true;
+		B->light_cache_dirty = true;
 	}
 
 	return NULL;
-
 }
-void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance *p_A,int, OctreeElementID, Instance *p_B,int,void*) {
+void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *) {
 
-	VisualServerRaster *self = (VisualServerRaster*)p_self;
+	VisualServerRaster *self = (VisualServerRaster *)p_self;
 	Instance *A = p_A;
 	Instance *B = p_B;
 
-	if (A->base_type==INSTANCE_PORTAL) {
-
-		ERR_FAIL_COND( B->base_type!=INSTANCE_PORTAL );
+	if (A->base_type == INSTANCE_PORTAL) {
 
+		ERR_FAIL_COND(B->base_type != INSTANCE_PORTAL);
 
 		A->portal_info->candidate_set.erase(B);
 		B->portal_info->candidate_set.erase(A);
@@ -5941,90 +5472,84 @@ void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance
 		self->_portal_attempt_connect(A);
 		self->_portal_attempt_connect(B);
 
-	} else if (A->base_type==INSTANCE_BAKED_LIGHT || B->base_type==INSTANCE_BAKED_LIGHT) {
+	} else if (A->base_type == INSTANCE_BAKED_LIGHT || B->base_type == INSTANCE_BAKED_LIGHT) {
 
-		if (B->base_type==INSTANCE_BAKED_LIGHT) {
-			SWAP(A,B);
+		if (B->base_type == INSTANCE_BAKED_LIGHT) {
+			SWAP(A, B);
 		}
 
-		ERR_FAIL_COND(B->base_type!=INSTANCE_BAKED_LIGHT_SAMPLER);
+		ERR_FAIL_COND(B->base_type != INSTANCE_BAKED_LIGHT_SAMPLER);
 		B->baked_light_sampler_info->baked_lights.erase(A);
 
-	} else if (A->base_type==INSTANCE_ROOM || B->base_type==INSTANCE_ROOM) {
+	} else if (A->base_type == INSTANCE_ROOM || B->base_type == INSTANCE_ROOM) {
 
-		if (B->base_type==INSTANCE_ROOM)
-			SWAP(A,B);
+		if (B->base_type == INSTANCE_ROOM)
+			SWAP(A, B);
 
-		ERR_FAIL_COND(! ((1<<B->base_type)&INSTANCE_GEOMETRY_MASK ));
+		ERR_FAIL_COND(!((1 << B->base_type) & INSTANCE_GEOMETRY_MASK));
 
 		B->auto_rooms.erase(A);
 		B->valid_auto_rooms.erase(A);
 		A->room_info->owned_autoroom_geometry.erase(B);
 
-	}else {
-
+	} else {
 
-		if (B->base_type==INSTANCE_LIGHT) {
+		if (B->base_type == INSTANCE_LIGHT) {
 
-			SWAP(A,B);
-		} else if (A->base_type!=INSTANCE_LIGHT) {
+			SWAP(A, B);
+		} else if (A->base_type != INSTANCE_LIGHT) {
 			return;
 		}
 
-
 		A->light_info->affected.erase(B);
 		B->lights.erase(A);
-		B->light_cache_dirty=true;
+		B->light_cache_dirty = true;
 	}
 }
 
 bool VisualServerRaster::_test_portal_cull(Camera *p_camera, Instance *p_from_portal, Instance *p_to_portal) {
 
+	int src_point_count = p_from_portal->portal_info->transformed_point_cache.size();
+	int dst_point_count = p_to_portal->portal_info->transformed_point_cache.size();
 
-	int src_point_count=p_from_portal->portal_info->transformed_point_cache.size();
-	int dst_point_count=p_to_portal->portal_info->transformed_point_cache.size();
-
-	if (src_point_count<2 || dst_point_count<2)
+	if (src_point_count < 2 || dst_point_count < 2)
 		return false;
 
-	const Vector3 *src_points=&p_from_portal->portal_info->transformed_point_cache[0];
-	const Vector3 *dst_points=&p_to_portal->portal_info->transformed_point_cache[0];
+	const Vector3 *src_points = &p_from_portal->portal_info->transformed_point_cache[0];
+	const Vector3 *dst_points = &p_to_portal->portal_info->transformed_point_cache[0];
 
-	bool outside=false;
+	bool outside = false;
 
 	bool clockwise = !p_from_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin);
 
-	for(int i=0;i<src_point_count;i++) {
+	for (int i = 0; i < src_point_count; i++) {
 
-		const Vector3& point_prev = src_points[i?(i-1):(src_point_count-1)];
-		const Vector3& point = src_points[i];
+		const Vector3 &point_prev = src_points[i ? (i - 1) : (src_point_count - 1)];
+		const Vector3 &point = src_points[i];
 
-		Plane p = clockwise?Plane(p_camera->transform.origin,point,point_prev):Plane(p_camera->transform.origin,point_prev,point);
+		Plane p = clockwise ? Plane(p_camera->transform.origin, point, point_prev) : Plane(p_camera->transform.origin, point_prev, point);
 
-		bool all_over=true;
+		bool all_over = true;
 
-		for(int j=0;j<dst_point_count;j++) {
+		for (int j = 0; j < dst_point_count; j++) {
 
 			if (!p.is_point_over(dst_points[j])) {
 
-				all_over=false;
+				all_over = false;
 				break;
 			}
-
 		}
 
 		if (all_over) {
-			outside=true;
+			outside = true;
 			break;
 		}
-
 	}
 
 	return !outside;
-
 }
 
-void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal,Instance *p_from_portal) {
+void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal, Instance *p_from_portal) {
 
 	ERR_FAIL_COND(!p_portal->scenario); //scenario outside
 
@@ -6033,13 +5558,13 @@ void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal,Insta
 	if (!portal->room) {
 
 		return; //portals need all to belong to a room, it may be unconfigured yet
-	} else if (portal->last_render_pass!=render_pass) {
+	} else if (portal->last_render_pass != render_pass) {
 
 		return; //invalid portal, ignore
-	} else if (portal->portal_info->last_visited_pass==render_pass) {
+	} else if (portal->portal_info->last_visited_pass == render_pass) {
 
 		return; //portal already visited
-	} else if (portal==p_from_portal) {
+	} else if (portal == p_from_portal) {
 
 		return; // came from this portal, don't even bother testing
 	}
@@ -6058,7 +5583,6 @@ void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal,Insta
 
 	/* TEST PORTAL NOT FACING OPTIMIZATION */
 
-
 	if (p_portal->portal_info->connected) {
 		//connected portal means, it must face against the camera to be seen
 		if (p_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin)) { //portal facing against camera (exterior)
@@ -6077,7 +5601,7 @@ void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal,Insta
 		return; // portal not visible (culled)
 	}
 
-	portal->portal_info->last_visited_pass=render_pass;
+	portal->portal_info->last_visited_pass = render_pass;
 
 	if (portal->portal_info->connected) {
 
@@ -6096,94 +5620,80 @@ void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal,Insta
 
 		_cull_room(p_camera, parent_room, portal);
 	}
-
 }
 
-void VisualServerRaster::_cull_room(Camera *p_camera, Instance *p_room,Instance *p_from_portal) {
+void VisualServerRaster::_cull_room(Camera *p_camera, Instance *p_room, Instance *p_from_portal) {
 
-	if (p_room==NULL) {
+	if (p_room == NULL) {
 		//exterior
-		exterior_visited=true;
+		exterior_visited = true;
 
-		for(int i=0;i<exterior_portal_cull_count;i++) {
+		for (int i = 0; i < exterior_portal_cull_count; i++) {
 
-			_cull_portal(p_camera, exterior_portal_cull_result[i],p_from_portal);
+			_cull_portal(p_camera, exterior_portal_cull_result[i], p_from_portal);
 		}
 
 	} else {
 
 		ERR_FAIL_COND(!p_room->scenario);
 
-		if (p_room->last_render_pass!=render_pass)
+		if (p_room->last_render_pass != render_pass)
 			return; //this room is invalid
 
 		//interior
 		//first of all, validate the room
-		p_room->room_info->last_visited_pass=render_pass;
+		p_room->room_info->last_visited_pass = render_pass;
 		//see about going around portals
 		if (!p_room->room_info->room->occlude_exterior)
-			exterior_visited=true;
-
-		for(List<Instance*>::Element * E=p_room->room_info->owned_portal_instances.front();E;E=E->next()) {
+			exterior_visited = true;
 
-			_cull_portal(p_camera, E->get(),p_from_portal);
+		for (List<Instance *>::Element *E = p_room->room_info->owned_portal_instances.front(); E; E = E->next()) {
 
+			_cull_portal(p_camera, E->get(), p_from_portal);
 		}
 
-		for(Set<Instance*>::Element * E=p_room->room_info->disconnected_child_portals.front();E;E=E->next()) {
-
-			_cull_portal(p_camera, E->get(),p_from_portal);
+		for (Set<Instance *>::Element *E = p_room->room_info->disconnected_child_portals.front(); E; E = E->next()) {
 
+			_cull_portal(p_camera, E->get(), p_from_portal);
 		}
-
-
 	}
-
 }
 
-void VisualServerRaster::_process_sampled_light(const Transform& p_camera,Instance *p_sampled_light,bool p_linear_colorspace) {
-
+void VisualServerRaster::_process_sampled_light(const Transform &p_camera, Instance *p_sampled_light, bool p_linear_colorspace) {
 
 	BakedLightSampler *sampler_opts = p_sampled_light->baked_light_sampler_info->sampler;
 	int res = sampler_opts->resolution;
-	int dp_size = res*res*2;
-	Color * dp_map = (Color*)alloca( sizeof(Color)*dp_size); //allocate the dual parabolloid colors
-	Vector3 * dp_normals = (Vector3*)alloca( sizeof(Vector3)*dp_size); //allocate the dual parabolloid normals
-	const Vector3 * dp_src_normals = p_sampled_light->baked_light_sampler_info->sampler->dp_cache.ptr();
-
+	int dp_size = res * res * 2;
+	Color *dp_map = (Color *)alloca(sizeof(Color) * dp_size); //allocate the dual parabolloid colors
+	Vector3 *dp_normals = (Vector3 *)alloca(sizeof(Vector3) * dp_size); //allocate the dual parabolloid normals
+	const Vector3 *dp_src_normals = p_sampled_light->baked_light_sampler_info->sampler->dp_cache.ptr();
 
-	if (!p_sampled_light->baked_light_sampler_info->sampled_light.is_valid() || p_sampled_light->baked_light_sampler_info->resolution!=sampler_opts->resolution) {
+	if (!p_sampled_light->baked_light_sampler_info->sampled_light.is_valid() || p_sampled_light->baked_light_sampler_info->resolution != sampler_opts->resolution) {
 		if (p_sampled_light->baked_light_sampler_info->sampled_light.is_valid()) {
 			rasterizer->free(p_sampled_light->baked_light_sampler_info->sampled_light);
 		}
 
-		p_sampled_light->baked_light_sampler_info->resolution=sampler_opts->resolution;
-		p_sampled_light->baked_light_sampler_info->sampled_light=rasterizer->sampled_light_dp_create(sampler_opts->resolution,sampler_opts->resolution*2);
-
-
+		p_sampled_light->baked_light_sampler_info->resolution = sampler_opts->resolution;
+		p_sampled_light->baked_light_sampler_info->sampled_light = rasterizer->sampled_light_dp_create(sampler_opts->resolution, sampler_opts->resolution * 2);
 	}
 
+	zeromem(dp_map, sizeof(Color) * dp_size);
+	bool valid = false;
+	int samples = 0;
 
-	zeromem(dp_map,sizeof(Color)*dp_size);
-	bool valid=false;
-	int samples=0;
-
-
-	for(Set<Instance*>::Element *E=p_sampled_light->baked_light_sampler_info->baked_lights.front();E;E=E->next()) {
+	for (Set<Instance *>::Element *E = p_sampled_light->baked_light_sampler_info->baked_lights.front(); E; E = E->next()) {
 
 		Instance *bl = E->get();
-		if (bl->baked_light_info->baked_light->sampler.size()==0)
+		if (bl->baked_light_info->baked_light->sampler.size() == 0)
 			continue; //not usable
 
-
-		Matrix3 norm_xform = bl->baked_light_info->affine_inverse.basis;//.inverse();
-		for(int i=0;i<dp_size;i++) {
-			dp_normals[i]=norm_xform.xform(dp_src_normals[i]).normalized();
+		Matrix3 norm_xform = bl->baked_light_info->affine_inverse.basis; //.inverse();
+		for (int i = 0; i < dp_size; i++) {
+			dp_normals[i] = norm_xform.xform(dp_src_normals[i]).normalized();
 		}
 
 		//normals in place
 
-
 		//sample octree
 
 		float r = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_RADIUS];
@@ -6191,8 +5701,8 @@ void VisualServerRaster::_process_sampled_light(const Transform& p_camera,Instan
 		float str = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_STRENGTH];
 		Vector3 s = p_sampled_light->data.transform.basis.get_scale();
 
-		r*=MAX(MAX(s.x,s.y),s.z);
-		AABB sample_aabb= bl->data.transform.affine_inverse().xform(AABB(Vector3(-r,-r,-r)+p_sampled_light->data.transform.origin,Vector3(r*2,r*2,r*2)));
+		r *= MAX(MAX(s.x, s.y), s.z);
+		AABB sample_aabb = bl->data.transform.affine_inverse().xform(AABB(Vector3(-r, -r, -r) + p_sampled_light->data.transform.origin, Vector3(r * 2, r * 2, r * 2)));
 		//ok got octree local AABB
 
 		DVector<int>::Read rp = bl->baked_light_info->baked_light->sampler.read();
@@ -6200,230 +5710,209 @@ void VisualServerRaster::_process_sampled_light(const Transform& p_camera,Instan
 
 		int first = rptr[1];
 		int depth = rptr[2];
-		bool islinear = rptr[3]&1;
-		depth+=1;
+		bool islinear = rptr[3] & 1;
+		depth += 1;
 
 		AABB aabb;
-		aabb.pos.x=decode_float((const uint8_t*)&rptr[4]);
-		aabb.pos.y=decode_float((const uint8_t*)&rptr[5]);
-		aabb.pos.z=decode_float((const uint8_t*)&rptr[6]);
-		aabb.size.x=decode_float((const uint8_t*)&rptr[7]);
-		aabb.size.y=decode_float((const uint8_t*)&rptr[8]);
-		aabb.size.z=decode_float((const uint8_t*)&rptr[9]);
+		aabb.pos.x = decode_float((const uint8_t *)&rptr[4]);
+		aabb.pos.y = decode_float((const uint8_t *)&rptr[5]);
+		aabb.pos.z = decode_float((const uint8_t *)&rptr[6]);
+		aabb.size.x = decode_float((const uint8_t *)&rptr[7]);
+		aabb.size.y = decode_float((const uint8_t *)&rptr[8]);
+		aabb.size.z = decode_float((const uint8_t *)&rptr[9]);
 
-		uint32_t *stack=(uint32_t*)alloca(depth*sizeof(uint32_t));
-		int *stack_ptr=(int*)alloca(depth*sizeof(int));
-		AABB *aabb_stack=(AABB*)alloca(depth*sizeof(AABB));
+		uint32_t *stack = (uint32_t *)alloca(depth * sizeof(uint32_t));
+		int *stack_ptr = (int *)alloca(depth * sizeof(int));
+		AABB *aabb_stack = (AABB *)alloca(depth * sizeof(AABB));
 
-		stack[0]=0;
-		stack_ptr[0]=first;
-		aabb_stack[0]=aabb;
+		stack[0] = 0;
+		stack_ptr[0] = first;
+		aabb_stack[0] = aabb;
 		Vector3 center = sample_aabb.pos + sample_aabb.size * 0.5;
 
-
-		int stack_pos=0;
+		int stack_pos = 0;
 		Color max_col;
 
 		//int reso = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO];
 
 		int lalimit = sample_aabb.get_longest_axis_index();
-		float limit = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO]*sample_aabb.size[lalimit];
-
+		float limit = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO] * sample_aabb.size[lalimit];
 
-		while(true) {
+		while (true) {
 
+			bool leaf = (rptr[stack_ptr[stack_pos]] >> 16) == 0;
 
-			bool leaf = (rptr[ stack_ptr[stack_pos] ]>>16)==0;
-
-			if (aabb_stack[stack_pos].size[lalimit]<limit) {
-				leaf=true;
+			if (aabb_stack[stack_pos].size[lalimit] < limit) {
+				leaf = true;
 			}
 
-
 			if (leaf) {
 
 				Vector3 from = aabb_stack[stack_pos].pos + aabb_stack[stack_pos].size * 0.5;
-				Vector3 norm = (from-center).normalized();
-
+				Vector3 norm = (from - center).normalized();
 
 				Color col;
-				col.r = ((rptr[ stack_ptr[stack_pos] ]&0xFFFF)/256.0);
-				col.g = ((rptr[ stack_ptr[stack_pos]+1 ]>>16)/256.0);
-				col.b = ((rptr[ stack_ptr[stack_pos]+1 ]&0xFFFF)/256.0);
+				col.r = ((rptr[stack_ptr[stack_pos]] & 0xFFFF) / 256.0);
+				col.g = ((rptr[stack_ptr[stack_pos] + 1] >> 16) / 256.0);
+				col.b = ((rptr[stack_ptr[stack_pos] + 1] & 0xFFFF) / 256.0);
 
-
-				max_col.r = MAX(max_col.r,col.r);
-				max_col.g = MAX(max_col.g,col.g);
-				max_col.b = MAX(max_col.b,col.b);
+				max_col.r = MAX(max_col.r, col.r);
+				max_col.g = MAX(max_col.g, col.g);
+				max_col.b = MAX(max_col.b, col.b);
 
 				if (!islinear && p_linear_colorspace) {
-					col=col.to_linear();
+					col = col.to_linear();
 				}
 
 				float distance;
 
 				if (aabb_stack[stack_pos].has_point(center)) {
-					distance=0;
+					distance = 0;
 				} else {
 
 					Vector3 support = aabb_stack[stack_pos].get_support(norm);
-					distance = Math::absf(norm.dot(support)-norm.dot(center));
-
+					distance = Math::absf(norm.dot(support) - norm.dot(center));
 				}
 
-				if (distance>r)
-					distance=r;
-
-				float mult = Math::pow(1.0-distance/r,att)*str;
-				if (mult>0) {
-					col.r*=mult;
-					col.g*=mult;
-					col.b*=mult;
+				if (distance > r)
+					distance = r;
 
+				float mult = Math::pow(1.0 - distance / r, att) * str;
+				if (mult > 0) {
+					col.r *= mult;
+					col.g *= mult;
+					col.b *= mult;
 
-
-					for(int i=0;i<dp_size;i++) {
+					for (int i = 0; i < dp_size; i++) {
 						float mult2 = norm.dot(dp_normals[i]);
-						if (mult2<0)
-							mult2=0;
-						Color col2(col.r*mult2,col.g*mult2,col.b*mult2,1.0);
-						dp_map[i].r=MAX(dp_map[i].r,col2.r);
-						dp_map[i].g=MAX(dp_map[i].g,col2.g);
-						dp_map[i].b=MAX(dp_map[i].b,col2.b);
+						if (mult2 < 0)
+							mult2 = 0;
+						Color col2(col.r * mult2, col.g * mult2, col.b * mult2, 1.0);
+						dp_map[i].r = MAX(dp_map[i].r, col2.r);
+						dp_map[i].g = MAX(dp_map[i].g, col2.g);
+						dp_map[i].b = MAX(dp_map[i].b, col2.b);
 					}
-
 				}
 
 				samples++;
 				//nothing is valid unless you hit a leaf
-				valid=true;
+				valid = true;
 				stack_pos--;
-			} else if ((stack[stack_pos]&0xFF)<8) {
+			} else if ((stack[stack_pos] & 0xFF) < 8) {
 
-				int i = stack[stack_pos]&0xFF;
-				int base = (stack[stack_pos]>>8);
+				int i = stack[stack_pos] & 0xFF;
+				int base = (stack[stack_pos] >> 8);
 
-				if (!((rptr[ stack_ptr[stack_pos] ]>>16)&(1<<i))) {
+				if (!((rptr[stack_ptr[stack_pos]] >> 16) & (1 << i))) {
 					//no bit, no test
-					stack[stack_pos]=(base<<8)+(i+1);
+					stack[stack_pos] = (base << 8) + (i + 1);
 					continue;
 				}
 
-				stack[stack_pos]=((base+1)<<8)+(i+1);
+				stack[stack_pos] = ((base + 1) << 8) + (i + 1);
 
 				AABB child_aabb = aabb_stack[stack_pos];
-				child_aabb.size*=0.5;
-				if (i&1)
-					child_aabb.pos.x+=child_aabb.size.x;
-				if (i&2)
-					child_aabb.pos.y+=child_aabb.size.y;
-				if (i&4)
-					child_aabb.pos.z+=child_aabb.size.z;
+				child_aabb.size *= 0.5;
+				if (i & 1)
+					child_aabb.pos.x += child_aabb.size.x;
+				if (i & 2)
+					child_aabb.pos.y += child_aabb.size.y;
+				if (i & 4)
+					child_aabb.pos.z += child_aabb.size.z;
 
 				if (!child_aabb.intersects(sample_aabb)) {
 					continue;
 				}
 
 				if (child_aabb.encloses(sample_aabb)) {
-					stack[stack_pos]=(base<<8)|8; //don't test the rest
+					stack[stack_pos] = (base << 8) | 8; //don't test the rest
 				}
 
 				stack_pos++;
-				ERR_FAIL_COND(stack_pos>=depth);
+				ERR_FAIL_COND(stack_pos >= depth);
 
-				stack[stack_pos]=0;
-				stack_ptr[stack_pos]=rptr[ stack_ptr[stack_pos-1]+2+base ];
-				aabb_stack[stack_pos]=child_aabb;
+				stack[stack_pos] = 0;
+				stack_ptr[stack_pos] = rptr[stack_ptr[stack_pos - 1] + 2 + base];
+				aabb_stack[stack_pos] = child_aabb;
 			} else {
 				stack_pos--;
-				if (stack_pos<0)
+				if (stack_pos < 0)
 					break;
 			}
 		}
-
-
 	}
 
 	//print_line("samples "+itos(samples) );
 
 	if (valid) {
 
-		for(int i=0;i<res;i++) {
+		for (int i = 0; i < res; i++) {
 			//average seams to avoid aliasing
 			{
 				//top
 				int ofs1 = i;
-				int ofs2 = dp_size-res+i;
+				int ofs2 = dp_size - res + i;
 				Color avg(
-					(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
-					(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
-					(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
-					1.0
-				);
-				dp_map[ofs1]=avg;
-				dp_map[ofs2]=avg;
+						(dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
+						(dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
+						(dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
+						1.0);
+				dp_map[ofs1] = avg;
+				dp_map[ofs2] = avg;
 			}
 			{
 				//bottom
-				int ofs1 = res*res-res+i;
-				int ofs2 = res*res+i;
+				int ofs1 = res * res - res + i;
+				int ofs2 = res * res + i;
 				Color avg(
-					(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
-					(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
-					(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
-					1.0
-				);
-				dp_map[ofs1]=avg;
-				dp_map[ofs2]=avg;
+						(dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
+						(dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
+						(dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
+						1.0);
+				dp_map[ofs1] = avg;
+				dp_map[ofs2] = avg;
 			}
 			{
 				//left
-				int ofs1 = i*res;
-				int ofs2 = res*res+(res-i-1)*res;
+				int ofs1 = i * res;
+				int ofs2 = res * res + (res - i - 1) * res;
 				Color avg(
-					(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
-					(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
-					(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
-					1.0
-				);
-				dp_map[ofs1]=avg;
-				dp_map[ofs2]=avg;
+						(dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
+						(dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
+						(dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
+						1.0);
+				dp_map[ofs1] = avg;
+				dp_map[ofs2] = avg;
 			}
 			{
 				//right
-				int ofs1 = i*res+(res-1);
-				int ofs2 = res*res+(res-i-1)*res+(res-1);
+				int ofs1 = i * res + (res - 1);
+				int ofs2 = res * res + (res - i - 1) * res + (res - 1);
 				Color avg(
-					(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
-					(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
-					(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
-					1.0
-				);
-				dp_map[ofs1]=avg;
-				dp_map[ofs2]=avg;
+						(dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
+						(dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
+						(dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
+						1.0);
+				dp_map[ofs1] = avg;
+				dp_map[ofs2] = avg;
 			}
-
 		}
 
-		rasterizer->sampled_light_dp_update(p_sampled_light->baked_light_sampler_info->sampled_light,dp_map,1.0);
-		for(Set<Instance*>::Element *F=p_sampled_light->baked_light_sampler_info->owned_instances.front();F;F=F->next()) {
+		rasterizer->sampled_light_dp_update(p_sampled_light->baked_light_sampler_info->sampled_light, dp_map, 1.0);
+		for (Set<Instance *>::Element *F = p_sampled_light->baked_light_sampler_info->owned_instances.front(); F; F = F->next()) {
 
-			F->get()->data.sampled_light=p_sampled_light->baked_light_sampler_info->sampled_light;
+			F->get()->data.sampled_light = p_sampled_light->baked_light_sampler_info->sampled_light;
 		}
 
-
 	} else {
 
-		for(Set<Instance*>::Element *F=p_sampled_light->baked_light_sampler_info->owned_instances.front();F;F=F->next()) {
+		for (Set<Instance *>::Element *F = p_sampled_light->baked_light_sampler_info->owned_instances.front(); F; F = F->next()) {
 
-			F->get()->data.sampled_light=RID(); //do not use because nothing close
+			F->get()->data.sampled_light = RID(); //do not use because nothing close
 		}
 	}
 
-
-
-
-/*
+	/*
 		highp vec3 vtx = vertex_interp;
 		vtx.z*=dual_paraboloid.y; //side to affect
 		vtx.z+=0.01;
@@ -6436,83 +5925,75 @@ void VisualServerRaster::_process_sampled_light(const Transform& p_camera,Instan
 		vtx.z = vtx.z * 2.0 - 1.0; // fit to clipspace
 		vertex_interp=vtx;
 */
-
-
-
-
 }
 
-
-void VisualServerRaster::_render_no_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario) {
+void VisualServerRaster::_render_no_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario) {
 	RID environment;
 	if (p_scenario->environment.is_valid())
-		environment=p_scenario->environment;
+		environment = p_scenario->environment;
 	else
-		environment=p_scenario->fallback_environment;
+		environment = p_scenario->fallback_environment;
 
-	rasterizer->set_camera(Transform(),CameraMatrix(),false);
-	rasterizer->begin_scene(p_viewport->viewport_data,environment,p_scenario->debug);
+	rasterizer->set_camera(Transform(), CameraMatrix(), false);
+	rasterizer->begin_scene(p_viewport->viewport_data, environment, p_scenario->debug);
 	rasterizer->set_viewport(viewport_rect);
 	rasterizer->end_scene();
 }
 
-
-void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario) {
-
+void VisualServerRaster::_render_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario) {
 
 	render_pass++;
-	uint32_t camera_layer_mask=p_camera->visible_layers;
+	uint32_t camera_layer_mask = p_camera->visible_layers;
 
 	/* STEP 1 - SETUP CAMERA */
 	CameraMatrix camera_matrix;
-	bool ortho=false;
+	bool ortho = false;
 
-	switch(p_camera->type) {
+	switch (p_camera->type) {
 		case Camera::ORTHOGONAL: {
 
 			camera_matrix.set_orthogonal(
-				p_camera->size,
-				viewport_rect.width / (float)viewport_rect.height,
-				p_camera->znear,
-				p_camera->zfar,
-				p_camera->vaspect
+					p_camera->size,
+					viewport_rect.width / (float)viewport_rect.height,
+					p_camera->znear,
+					p_camera->zfar,
+					p_camera->vaspect
 
-			);
-			ortho=true;
+					);
+			ortho = true;
 		} break;
 		case Camera::PERSPECTIVE: {
 
 			camera_matrix.set_perspective(
-				p_camera->fov,
-				viewport_rect.width / (float)viewport_rect.height,
-				p_camera->znear,
-				p_camera->zfar,
-				p_camera->vaspect
+					p_camera->fov,
+					viewport_rect.width / (float)viewport_rect.height,
+					p_camera->znear,
+					p_camera->zfar,
+					p_camera->vaspect
 
-			);
-			ortho=false;
+					);
+			ortho = false;
 
 		} break;
 	}
 
-
-	rasterizer->set_camera(p_camera->transform, camera_matrix,ortho);
+	rasterizer->set_camera(p_camera->transform, camera_matrix, ortho);
 
 	Vector<Plane> planes = camera_matrix.get_projection_planes(p_camera->transform);
 
 	CullRange cull_range; // cull range is used for PSSM, and having an idea of the rendering depth
-	cull_range.nearp=Plane(p_camera->transform.origin,-p_camera->transform.basis.get_axis(2).normalized());
-	cull_range.z_near=camera_matrix.get_z_near();
-	cull_range.z_far=camera_matrix.get_z_far();
-	cull_range.min=cull_range.z_far;
-	cull_range.max=cull_range.z_near;
+	cull_range.nearp = Plane(p_camera->transform.origin, -p_camera->transform.basis.get_axis(2).normalized());
+	cull_range.z_near = camera_matrix.get_z_near();
+	cull_range.z_far = camera_matrix.get_z_far();
+	cull_range.min = cull_range.z_far;
+	cull_range.max = cull_range.z_near;
 
 	/* STEP 2 - CULL */
-	int cull_count = p_scenario->octree.cull_convex(planes,instance_cull_result,MAX_INSTANCE_CULL);
-	light_cull_count=0;
-	light_samplers_culled=0;
+	int cull_count = p_scenario->octree.cull_convex(planes, instance_cull_result, MAX_INSTANCE_CULL);
+	light_cull_count = 0;
+	light_samplers_culled = 0;
 
-/*	print_line("OT: "+rtos( (OS::get_singleton()->get_ticks_usec()-t)/1000.0));
+	/*	print_line("OT: "+rtos( (OS::get_singleton()->get_ticks_usec()-t)/1000.0));
 	print_line("OTO: "+itos(p_scenario->octree.get_octant_count()));
 //	print_line("OTE: "+itos(p_scenario->octree.get_elem_count()));
 	print_line("OTP: "+itos(p_scenario->octree.get_pair_count()));
@@ -6520,58 +6001,55 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 
 	/* STEP 3 - PROCESS PORTALS, VALIDATE ROOMS */
 
-
 	// compute portals
 
-	exterior_visited=false;
-	exterior_portal_cull_count=0;
+	exterior_visited = false;
+	exterior_portal_cull_count = 0;
 
 	if (room_cull_enabled) {
-		for(int i=0;i<cull_count;i++) {
+		for (int i = 0; i < cull_count; i++) {
 
 			Instance *ins = instance_cull_result[i];
-			ins->last_render_pass=render_pass;
+			ins->last_render_pass = render_pass;
 
-			if (ins->base_type!=INSTANCE_PORTAL)
+			if (ins->base_type != INSTANCE_PORTAL)
 				continue;
 
 			if (ins->room)
 				continue;
 
-			ERR_CONTINUE(exterior_portal_cull_count>=MAX_EXTERIOR_PORTALS);
-			exterior_portal_cull_result[exterior_portal_cull_count++]=ins;
-
+			ERR_CONTINUE(exterior_portal_cull_count >= MAX_EXTERIOR_PORTALS);
+			exterior_portal_cull_result[exterior_portal_cull_count++] = ins;
 		}
 
-		room_cull_count = p_scenario->octree.cull_point(p_camera->transform.origin,room_cull_result,MAX_ROOM_CULL,NULL,(1<<INSTANCE_ROOM)|(1<<INSTANCE_PORTAL));
-
+		room_cull_count = p_scenario->octree.cull_point(p_camera->transform.origin, room_cull_result, MAX_ROOM_CULL, NULL, (1 << INSTANCE_ROOM) | (1 << INSTANCE_PORTAL));
 
-		Set<Instance*> current_rooms;
-		Set<Instance*> portal_rooms;
+		Set<Instance *> current_rooms;
+		Set<Instance *> portal_rooms;
 		//add to set
-		for(int i=0;i<room_cull_count;i++) {
+		for (int i = 0; i < room_cull_count; i++) {
 
-			if (room_cull_result[i]->base_type==INSTANCE_ROOM) {
+			if (room_cull_result[i]->base_type == INSTANCE_ROOM) {
 				current_rooms.insert(room_cull_result[i]);
 			}
-			if (room_cull_result[i]->base_type==INSTANCE_PORTAL) {
+			if (room_cull_result[i]->base_type == INSTANCE_PORTAL) {
 				//assume inside that room if also inside the portal..
 				if (room_cull_result[i]->room) {
 					portal_rooms.insert(room_cull_result[i]->room);
 				}
 
-				SWAP(room_cull_result[i],room_cull_result[room_cull_count-1]);
+				SWAP(room_cull_result[i], room_cull_result[room_cull_count - 1]);
 				room_cull_count--;
 				i--;
 			}
 		}
 
 		//remove from set if it has a parent room or BSP doesn't contain
-		for(int i=0;i<room_cull_count;i++) {
+		for (int i = 0; i < room_cull_count; i++) {
 			Instance *r = room_cull_result[i];
 
 			//check inside BSP
-			Vector3 room_local_point = r->room_info->affine_inverse.xform( p_camera->transform.origin );
+			Vector3 room_local_point = r->room_info->affine_inverse.xform(p_camera->transform.origin);
 
 			if (!portal_rooms.has(r) && !r->room_info->room->bounds.point_is_inside(room_local_point)) {
 
@@ -6580,66 +6058,60 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 			}
 
 			//check parent
-			while (r->room) {// has parent room
+			while (r->room) { // has parent room
 
 				current_rooms.erase(r);
-				r=r->room;
+				r = r->room;
 			}
-
 		}
 
 		if (current_rooms.size()) {
 			//camera is inside a room
 			// go through rooms
-			for(Set<Instance*>::Element *E=current_rooms.front();E;E=E->next()) {
-				_cull_room(p_camera,E->get());
+			for (Set<Instance *>::Element *E = current_rooms.front(); E; E = E->next()) {
+				_cull_room(p_camera, E->get());
 			}
 
 		} else {
 			//start from exterior
-			_cull_room(p_camera,NULL);
-
+			_cull_room(p_camera, NULL);
 		}
 	}
 
 	/* STEP 4 - REMOVE FURTHER CULLED OBJECTS, ADD LIGHTS */
 
-	for(int i=0;i<cull_count;i++) {
+	for (int i = 0; i < cull_count; i++) {
 
 		Instance *ins = instance_cull_result[i];
 
-		bool keep=false;
-
+		bool keep = false;
 
-		if ((camera_layer_mask&ins->layer_mask)==0) {
+		if ((camera_layer_mask & ins->layer_mask) == 0) {
 
 			//failure
-		} else if (ins->base_type==INSTANCE_LIGHT) {
+		} else if (ins->base_type == INSTANCE_LIGHT) {
 
-			if (light_cull_count<MAX_LIGHTS_CULLED) {
-				light_cull_result[light_cull_count++]=ins;
-//				rasterizer->light_instance_set_active_hint(ins->light_info->instance);
+			if (light_cull_count < MAX_LIGHTS_CULLED) {
+				light_cull_result[light_cull_count++] = ins;
+				//				rasterizer->light_instance_set_active_hint(ins->light_info->instance);
 				{
 					//compute distance to camera using aabb support
 					Vector3 n = ins->data.transform.basis.xform_inv(cull_range.nearp.normal).normalized();
 					Vector3 s = ins->data.transform.xform(ins->aabb.get_support(n));
-					ins->light_info->dtc=cull_range.nearp.distance_to(s);
+					ins->light_info->dtc = cull_range.nearp.distance_to(s);
 				}
 			}
 
-		} else if ((1<<ins->base_type)&INSTANCE_GEOMETRY_MASK && ins->visible && ins->data.cast_shadows!=VS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) {
-
+		} else if ((1 << ins->base_type) & INSTANCE_GEOMETRY_MASK && ins->visible && ins->data.cast_shadows != VS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) {
 
-			bool discarded=false;
+			bool discarded = false;
 
-			if (ins->draw_range_end>0) {
+			if (ins->draw_range_end > 0) {
 
 				float d = cull_range.nearp.distance_to(ins->data.transform.origin);
-				if (d<0)
-					d=0;
-				discarded=(d<ins->draw_range_begin || d>=ins->draw_range_end);
-
-
+				if (d < 0)
+					d = 0;
+				discarded = (d < ins->draw_range_begin || d >= ins->draw_range_end);
 			}
 
 			if (!discarded) {
@@ -6648,70 +6120,64 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 
 				if (room_cull_enabled) {
 
-
 					if (ins->visible_in_all_rooms) {
-						keep=true;
+						keep = true;
 					} else if (ins->room) {
 
-						if (ins->room->room_info->last_visited_pass==render_pass)
-							keep=true;
+						if (ins->room->room_info->last_visited_pass == render_pass)
+							keep = true;
 					} else if (ins->auto_rooms.size()) {
 
+						for (Set<Instance *>::Element *E = ins->auto_rooms.front(); E; E = E->next()) {
 
-						for(Set<Instance*>::Element *E=ins->auto_rooms.front();E;E=E->next()) {
-
-							if (E->get()->room_info->last_visited_pass==render_pass) {
-								keep=true;
+							if (E->get()->room_info->last_visited_pass == render_pass) {
+								keep = true;
 								break;
 							}
 						}
-					} else if(exterior_visited)
-						keep=true;
+					} else if (exterior_visited)
+						keep = true;
 				} else {
 
-					keep=true;
+					keep = true;
 				}
-
-
 			}
 
-
 			if (keep) {
 				// update cull range
-				float min,max;
-				ins->transformed_aabb.project_range_in_plane(cull_range.nearp,min,max);
+				float min, max;
+				ins->transformed_aabb.project_range_in_plane(cull_range.nearp, min, max);
 
-				if (min<cull_range.min)
-					cull_range.min=min;
-				if (max>cull_range.max)
-					cull_range.max=max;
+				if (min < cull_range.min)
+					cull_range.min = min;
+				if (max > cull_range.max)
+					cull_range.max = max;
 
-				if (ins->sampled_light && ins->sampled_light->baked_light_sampler_info->last_pass!=render_pass) {
-					if (light_samplers_culled<MAX_LIGHT_SAMPLERS) {
-						light_sampler_cull_result[light_samplers_culled++]=ins->sampled_light;
-						ins->sampled_light->baked_light_sampler_info->last_pass=render_pass;
+				if (ins->sampled_light && ins->sampled_light->baked_light_sampler_info->last_pass != render_pass) {
+					if (light_samplers_culled < MAX_LIGHT_SAMPLERS) {
+						light_sampler_cull_result[light_samplers_culled++] = ins->sampled_light;
+						ins->sampled_light->baked_light_sampler_info->last_pass = render_pass;
 					}
 				}
 			}
-
 		}
 
 		if (!keep) {
 			// remove, no reason to keep
 			cull_count--;
-			SWAP( instance_cull_result[i], instance_cull_result[ cull_count ] );
+			SWAP(instance_cull_result[i], instance_cull_result[cull_count]);
 			i--;
-			ins->last_render_pass=0; // make invalid
+			ins->last_render_pass = 0; // make invalid
 		} else {
 
-			ins->last_render_pass=render_pass;
+			ins->last_render_pass = render_pass;
 		}
 	}
 
-	if (cull_range.max > cull_range.z_far )
-		cull_range.max=cull_range.z_far;
-	if (cull_range.min < cull_range.z_near )
-		cull_range.min=cull_range.z_near;
+	if (cull_range.max > cull_range.z_far)
+		cull_range.max = cull_range.z_far;
+	if (cull_range.min < cull_range.z_near)
+		cull_range.min = cull_range.z_near;
 
 	/* STEP 5 - PROCESS LIGHTS */
 
@@ -6719,26 +6185,24 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 
 	// directional lights
 	{
-		List<RID>::Element *E=p_scenario->directional_lights.front();
+		List<RID>::Element *E = p_scenario->directional_lights.front();
 
+		while (E) {
 
-		while(E) {
-
-			Instance  *light = E->get().is_valid()?instance_owner.get(E->get()):NULL;
+			Instance *light = E->get().is_valid() ? instance_owner.get(E->get()) : NULL;
 
 			if (light && light->light_info->enabled && rasterizer->light_has_shadow(light->base_rid)) {
 				//rasterizer->light_instance_set_active_hint(light->light_info->instance);
-				_light_instance_update_shadow(light,p_scenario,p_camera,cull_range);
+				_light_instance_update_shadow(light, p_scenario, p_camera, cull_range);
 			}
 
-			E=E->next();
+			E = E->next();
 		}
 	}
 
-
 	//discard lights not affecting anything (useful for deferred rendering, shadowmaps, etc)
 
-	for (int i=0;i<light_cull_count;i++) {
+	for (int i = 0; i < light_cull_count; i++) {
 
 		Instance *ins = light_cull_result[i];
 
@@ -6749,33 +6213,31 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 			//because of early out condition. It will only go through everything
 			//if it's being discarded.
 
-			bool valid=false;
-			InstanceSet::Element *E =ins->light_info->affected.front();
-			while(E) {
+			bool valid = false;
+			InstanceSet::Element *E = ins->light_info->affected.front();
+			while (E) {
 
-				if (E->get()->last_render_pass==render_pass) {
+				if (E->get()->last_render_pass == render_pass) {
 
-					valid=true; // early out.
+					valid = true; // early out.
 					break;
 				}
-				E=E->next();
+				E = E->next();
 			}
 			if (!valid) {
 
 				light_cull_count--;
-				SWAP( light_cull_result[i], light_cull_result[ light_cull_count ] );
+				SWAP(light_cull_result[i], light_cull_result[light_cull_count]);
 				i--;
-
 			}
 		}
-
 	}
 
 	{ //this should eventually change to
 		//assign shadows by distance to camera
-		SortArray<Instance*,_InstanceLightsort> sorter;
-		sorter.sort(light_cull_result,light_cull_count);
-		for (int i=0;i<light_cull_count;i++) {
+		SortArray<Instance *, _InstanceLightsort> sorter;
+		sorter.sort(light_cull_result, light_cull_count);
+		for (int i = 0; i < light_cull_count; i++) {
 
 			Instance *ins = light_cull_result[i];
 
@@ -6787,8 +6249,8 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 				continue; // didn't change
 			*/
 
-			_light_instance_update_shadow(ins,p_scenario,p_camera,cull_range);
-			ins->light_info->last_version=ins->version;
+			_light_instance_update_shadow(ins, p_scenario, p_camera, cull_range);
+			ins->light_info->last_version = ins->version;
 		}
 	}
 
@@ -6796,62 +6258,59 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 
 	RID environment;
 	if (p_camera->env.is_valid()) //camera has more environment priority
-		environment=p_camera->env;
+		environment = p_camera->env;
 	else if (p_scenario->environment.is_valid())
-		environment=p_scenario->environment;
+		environment = p_scenario->environment;
 	else
-		environment=p_scenario->fallback_environment;
-
+		environment = p_scenario->fallback_environment;
 
 	/* STEP 6 - SAMPLE BAKED LIGHT */
 
-	bool islinear =false;
+	bool islinear = false;
 	if (environment.is_valid()) {
-		islinear = rasterizer->environment_is_fx_enabled(environment,VS::ENV_FX_SRGB);
+		islinear = rasterizer->environment_is_fx_enabled(environment, VS::ENV_FX_SRGB);
 	}
 
-	for(int i=0;i<light_samplers_culled;i++) {
+	for (int i = 0; i < light_samplers_culled; i++) {
 
-		_process_sampled_light(p_camera->transform,light_sampler_cull_result[i],islinear);
+		_process_sampled_light(p_camera->transform, light_sampler_cull_result[i], islinear);
 	}
 
 	/* STEP 7 - PROCESS GEOMETRY AND DRAW SCENE*/
 
-
-	rasterizer->begin_scene(p_viewport->viewport_data,environment,p_scenario->debug);
+	rasterizer->begin_scene(p_viewport->viewport_data, environment, p_scenario->debug);
 	rasterizer->set_viewport(viewport_rect);
 
 	// add lights
 
 	{
-		List<RID>::Element *E=p_scenario->directional_lights.front();
+		List<RID>::Element *E = p_scenario->directional_lights.front();
 
-
-		for(;E;E=E->next()) {
-			Instance  *light = E->get().is_valid()?instance_owner.get(E->get()):NULL;
+		for (; E; E = E->next()) {
+			Instance *light = E->get().is_valid() ? instance_owner.get(E->get()) : NULL;
 
 			ERR_CONTINUE(!light);
 			if (!light->light_info->enabled)
 				continue;
 
 			rasterizer->add_light(light->light_info->instance);
-			light->light_info->last_add_pass=render_pass;
+			light->light_info->last_add_pass = render_pass;
 		}
 
-		for (int i=0;i<light_cull_count;i++) {
+		for (int i = 0; i < light_cull_count; i++) {
 
 			Instance *ins = light_cull_result[i];
 			rasterizer->add_light(ins->light_info->instance);
-			ins->light_info->last_add_pass=render_pass;
+			ins->light_info->last_add_pass = render_pass;
 		}
 	}
-		// add geometry
+	// add geometry
 
-	for(int i=0;i<cull_count;i++) {
+	for (int i = 0; i < cull_count; i++) {
 
 		Instance *ins = instance_cull_result[i];
 
-		ERR_CONTINUE(!((1<<ins->base_type)&INSTANCE_GEOMETRY_MASK));
+		ERR_CONTINUE(!((1 << ins->base_type) & INSTANCE_GEOMETRY_MASK));
 
 		_instance_draw(ins);
 	}
@@ -6859,75 +6318,66 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 	rasterizer->end_scene();
 }
 
+void VisualServerRaster::_render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, Rasterizer::CanvasLight *p_lights) {
 
-void VisualServerRaster::_render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32& p_transform, const Rect2& p_clip_rect, const Color& p_modulate, Rasterizer::CanvasLight *p_lights) {
-
-
-	static const int z_range = CANVAS_ITEM_Z_MAX-CANVAS_ITEM_Z_MIN+1;
+	static const int z_range = CANVAS_ITEM_Z_MAX - CANVAS_ITEM_Z_MIN + 1;
 	Rasterizer::CanvasItem *z_list[z_range];
 	Rasterizer::CanvasItem *z_last_list[z_range];
 
-	for(int i=0;i<z_range;i++) {
-		z_list[i]=NULL;
-		z_last_list[i]=NULL;
+	for (int i = 0; i < z_range; i++) {
+		z_list[i] = NULL;
+		z_last_list[i] = NULL;
 	}
 
+	_render_canvas_item(p_canvas_item, p_transform, p_clip_rect, 1.0, 0, z_list, z_last_list, NULL, NULL);
 
-	_render_canvas_item(p_canvas_item,p_transform,p_clip_rect,1.0,0,z_list,z_last_list,NULL,NULL);
-
-	for(int i=0;i<z_range;i++) {
+	for (int i = 0; i < z_range; i++) {
 		if (!z_list[i])
 			continue;
-		rasterizer->canvas_render_items(z_list[i],CANVAS_ITEM_Z_MIN+i,p_modulate,p_lights);
+		rasterizer->canvas_render_items(z_list[i], CANVAS_ITEM_Z_MIN + i, p_modulate, p_lights);
 	}
-
 }
 
+void VisualServerRaster::_render_canvas_item_viewport(VisualServer *p_self, void *p_vp, const Rect2 &p_rect) {
 
-void VisualServerRaster::_render_canvas_item_viewport(VisualServer* p_self,void *p_vp,const Rect2& p_rect) {
-
-	VisualServerRaster *self=(VisualServerRaster*)(p_self);
-	Viewport *vp=(Viewport*)p_vp;
-	self->_draw_viewport(vp,p_rect.pos.x,p_rect.pos.y,p_rect.size.x,p_rect.size.y);
+	VisualServerRaster *self = (VisualServerRaster *)(p_self);
+	Viewport *vp = (Viewport *)p_vp;
+	self->_draw_viewport(vp, p_rect.pos.x, p_rect.pos.y, p_rect.size.x, p_rect.size.y);
 	self->rasterizer->canvas_begin();
-
 }
 
-
-void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect, float p_opacity,int p_z,Rasterizer::CanvasItem **z_list,Rasterizer::CanvasItem **z_last_list,CanvasItem *p_canvas_clip,CanvasItem *p_material_owner) {
+void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, float p_opacity, int p_z, Rasterizer::CanvasItem **z_list, Rasterizer::CanvasItem **z_last_list, CanvasItem *p_canvas_clip, CanvasItem *p_material_owner) {
 
 	CanvasItem *ci = p_canvas_item;
 
 	if (!ci->visible)
 		return;
 
-	if (p_opacity<0.007)
+	if (p_opacity < 0.007)
 		return;
 
-
 	Rect2 rect = ci->get_rect();
 	Matrix32 xform = p_transform * ci->xform;
 	Rect2 global_rect = xform.xform(rect);
-	global_rect.pos+=p_clip_rect.pos;
-
+	global_rect.pos += p_clip_rect.pos;
 
 	if (global_rect.intersects(p_clip_rect) && ci->viewport.is_valid() && viewport_owner.owns(ci->viewport)) {
 
 		Viewport *vp = viewport_owner.get(ci->viewport);
 
-		Point2i from = xform.get_origin() + Point2(viewport_rect.x,viewport_rect.y);
+		Point2i from = xform.get_origin() + Point2(viewport_rect.x, viewport_rect.y);
 		Point2i size = rect.size;
 		size.x *= xform[0].length();
 		size.y *= xform[1].length();
 
-		ci->vp_render = memnew( Rasterizer::CanvasItem::ViewportRender );
-		ci->vp_render->owner=this;
-		ci->vp_render->udata=vp;
-		ci->vp_render->rect=Rect2(from.x,
-					  from.y,
-					  size.x,
-					  size.y);
-/*
+		ci->vp_render = memnew(Rasterizer::CanvasItem::ViewportRender);
+		ci->vp_render->owner = this;
+		ci->vp_render->udata = vp;
+		ci->vp_render->rect = Rect2(from.x,
+				from.y,
+				size.x,
+				size.y);
+		/*
 		_draw_viewport(vp,
 				from.x,
 				from.y,
@@ -6936,52 +6386,50 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 */
 		//rasterizer->canvas_begin();
 	} else {
-		ci->vp_render=NULL;
+		ci->vp_render = NULL;
 	}
 
 	if (ci->use_parent_material && p_material_owner)
-		ci->material_owner=p_material_owner;
+		ci->material_owner = p_material_owner;
 	else {
-		p_material_owner=ci;
-		ci->material_owner=NULL;
+		p_material_owner = ci;
+		ci->material_owner = NULL;
 	}
 
-
 	float opacity = ci->opacity * p_opacity;
 
-
-	int child_item_count=ci->child_items.size();
-	CanvasItem **child_items=(CanvasItem**)alloca(child_item_count*sizeof(CanvasItem*));
-	copymem(child_items,ci->child_items.ptr(),child_item_count*sizeof(CanvasItem*));
+	int child_item_count = ci->child_items.size();
+	CanvasItem **child_items = (CanvasItem **)alloca(child_item_count * sizeof(CanvasItem *));
+	copymem(child_items, ci->child_items.ptr(), child_item_count * sizeof(CanvasItem *));
 
 	if (ci->clip) {
 		if (p_canvas_clip != NULL) {
-			ci->final_clip_rect=p_canvas_clip->final_clip_rect.clip(global_rect);
+			ci->final_clip_rect = p_canvas_clip->final_clip_rect.clip(global_rect);
 		} else {
-			ci->final_clip_rect=global_rect;
+			ci->final_clip_rect = global_rect;
 		}
-		ci->final_clip_owner=ci;
+		ci->final_clip_owner = ci;
 
 	} else {
-		ci->final_clip_owner=p_canvas_clip;
+		ci->final_clip_owner = p_canvas_clip;
 	}
 
 	if (ci->sort_y) {
 
-		SortArray<CanvasItem*,CanvasItemPtrSort> sorter;
-		sorter.sort(child_items,child_item_count);
+		SortArray<CanvasItem *, CanvasItemPtrSort> sorter;
+		sorter.sort(child_items, child_item_count);
 	}
 
 	if (ci->z_relative)
-		p_z=CLAMP(p_z+ci->z,CANVAS_ITEM_Z_MIN,CANVAS_ITEM_Z_MAX);
+		p_z = CLAMP(p_z + ci->z, CANVAS_ITEM_Z_MIN, CANVAS_ITEM_Z_MAX);
 	else
-		p_z=ci->z;
+		p_z = ci->z;
 
-	for(int i=0;i<child_item_count;i++) {
+	for (int i = 0; i < child_item_count; i++) {
 
 		if (child_items[i]->ontop)
 			continue;
-		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_material_owner);
+		_render_canvas_item(child_items[i], xform, p_clip_rect, opacity, p_z, z_list, z_last_list, (CanvasItem *)ci->final_clip_owner, p_material_owner);
 	}
 
 	if (ci->copy_back_buffer) {
@@ -6991,202 +6439,185 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 
 	if ((!ci->commands.empty() && p_clip_rect.intersects(global_rect)) || ci->vp_render || ci->copy_back_buffer) {
 		//something to draw?
-		ci->final_transform=xform;
-		ci->final_opacity=opacity * ci->self_opacity;
-		ci->global_rect_cache=global_rect;
-		ci->global_rect_cache.pos-=p_clip_rect.pos;
-		ci->light_masked=false;
+		ci->final_transform = xform;
+		ci->final_opacity = opacity * ci->self_opacity;
+		ci->global_rect_cache = global_rect;
+		ci->global_rect_cache.pos -= p_clip_rect.pos;
+		ci->light_masked = false;
 
-		int zidx = p_z-CANVAS_ITEM_Z_MIN;
+		int zidx = p_z - CANVAS_ITEM_Z_MIN;
 
 		if (z_last_list[zidx]) {
-			z_last_list[zidx]->next=ci;
-			z_last_list[zidx]=ci;
+			z_last_list[zidx]->next = ci;
+			z_last_list[zidx] = ci;
 
 		} else {
-			z_list[zidx]=ci;
-			z_last_list[zidx]=ci;
+			z_list[zidx] = ci;
+			z_last_list[zidx] = ci;
 		}
 
-
-
-		ci->next=NULL;
-
+		ci->next = NULL;
 	}
 
-	for(int i=0;i<child_item_count;i++) {
+	for (int i = 0; i < child_item_count; i++) {
 
 		if (!child_items[i]->ontop)
 			continue;
-		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_material_owner);
+		_render_canvas_item(child_items[i], xform, p_clip_rect, opacity, p_z, z_list, z_last_list, (CanvasItem *)ci->final_clip_owner, p_material_owner);
 	}
-
 }
 
-void VisualServerRaster::_light_mask_canvas_items(int p_z,Rasterizer::CanvasItem *p_canvas_item,Rasterizer::CanvasLight *p_masked_lights) {
+void VisualServerRaster::_light_mask_canvas_items(int p_z, Rasterizer::CanvasItem *p_canvas_item, Rasterizer::CanvasLight *p_masked_lights) {
 
 	if (!p_masked_lights)
 		return;
 
-	Rasterizer::CanvasItem *ci=p_canvas_item;
+	Rasterizer::CanvasItem *ci = p_canvas_item;
 
-	while(ci) {
+	while (ci) {
 
-		Rasterizer::CanvasLight *light=p_masked_lights;
-		while(light) {
+		Rasterizer::CanvasLight *light = p_masked_lights;
+		while (light) {
 
-			if (ci->light_mask&light->item_mask && p_z>=light->z_min && p_z<=light->z_max && ci->global_rect_cache.intersects_transformed(light->xform_cache,light->rect_cache)) {
-				ci->light_masked=true;
+			if (ci->light_mask & light->item_mask && p_z >= light->z_min && p_z <= light->z_max && ci->global_rect_cache.intersects_transformed(light->xform_cache, light->rect_cache)) {
+				ci->light_masked = true;
 			}
 
-			light=light->mask_next_ptr;
+			light = light->mask_next_ptr;
 		}
 
-		ci=ci->next;
+		ci = ci->next;
 	}
-
-
-
-
 }
 
-void VisualServerRaster::_render_canvas(Canvas *p_canvas,const Matrix32 &p_transform,Rasterizer::CanvasLight *p_lights,Rasterizer::CanvasLight *p_masked_lights) {
+void VisualServerRaster::_render_canvas(Canvas *p_canvas, const Matrix32 &p_transform, Rasterizer::CanvasLight *p_lights, Rasterizer::CanvasLight *p_masked_lights) {
 
 	rasterizer->canvas_begin();
 
 	int l = p_canvas->child_items.size();
-	Canvas::ChildItem *ci=p_canvas->child_items.ptr();
+	Canvas::ChildItem *ci = p_canvas->child_items.ptr();
 
-	bool has_mirror=false;
-	for(int i=0;i<l;i++) {
+	bool has_mirror = false;
+	for (int i = 0; i < l; i++) {
 		if (ci[i].mirror.x || ci[i].mirror.y) {
-			has_mirror=true;
+			has_mirror = true;
 			break;
 		}
 	}
 
-	Rect2 clip_rect(viewport_rect.x,viewport_rect.y,viewport_rect.width,viewport_rect.height);
+	Rect2 clip_rect(viewport_rect.x, viewport_rect.y, viewport_rect.width, viewport_rect.height);
 	if (!has_mirror) {
 
-		static const int z_range = CANVAS_ITEM_Z_MAX-CANVAS_ITEM_Z_MIN+1;
+		static const int z_range = CANVAS_ITEM_Z_MAX - CANVAS_ITEM_Z_MIN + 1;
 		Rasterizer::CanvasItem *z_list[z_range];
 		Rasterizer::CanvasItem *z_last_list[z_range];
 
-		for(int i=0;i<z_range;i++) {
-			z_list[i]=NULL;
-			z_last_list[i]=NULL;
+		for (int i = 0; i < z_range; i++) {
+			z_list[i] = NULL;
+			z_last_list[i] = NULL;
 		}
-		for(int i=0;i<l;i++) {
-			_render_canvas_item(ci[i].item,p_transform,clip_rect,1.0,0,z_list,z_last_list,NULL,NULL);
+		for (int i = 0; i < l; i++) {
+			_render_canvas_item(ci[i].item, p_transform, clip_rect, 1.0, 0, z_list, z_last_list, NULL, NULL);
 		}
 
-		for(int i=0;i<z_range;i++) {
+		for (int i = 0; i < z_range; i++) {
 			if (!z_list[i])
 				continue;
 
 			if (p_masked_lights) {
-				_light_mask_canvas_items(CANVAS_ITEM_Z_MIN+i,z_list[i],p_masked_lights);
+				_light_mask_canvas_items(CANVAS_ITEM_Z_MIN + i, z_list[i], p_masked_lights);
 			}
 
-			rasterizer->canvas_render_items(z_list[i],CANVAS_ITEM_Z_MIN+i,p_canvas->modulate,p_lights);
+			rasterizer->canvas_render_items(z_list[i], CANVAS_ITEM_Z_MIN + i, p_canvas->modulate, p_lights);
 		}
 	} else {
 
-		for(int i=0;i<l;i++) {
+		for (int i = 0; i < l; i++) {
 
-			Canvas::ChildItem& ci=p_canvas->child_items[i];
-			_render_canvas_item_tree(ci.item,p_transform,clip_rect,p_canvas->modulate,p_lights);
+			Canvas::ChildItem &ci = p_canvas->child_items[i];
+			_render_canvas_item_tree(ci.item, p_transform, clip_rect, p_canvas->modulate, p_lights);
 
 			//mirroring (useful for scrolling backgrounds)
-			if (ci.mirror.x!=0) {
+			if (ci.mirror.x != 0) {
 
-				Matrix32 xform2 = p_transform * Matrix32(0,Vector2(ci.mirror.x,0));
-				_render_canvas_item_tree(ci.item,xform2,clip_rect,p_canvas->modulate,p_lights);
+				Matrix32 xform2 = p_transform * Matrix32(0, Vector2(ci.mirror.x, 0));
+				_render_canvas_item_tree(ci.item, xform2, clip_rect, p_canvas->modulate, p_lights);
 			}
-			if (ci.mirror.y!=0) {
+			if (ci.mirror.y != 0) {
 
-				Matrix32 xform2 = p_transform * Matrix32(0,Vector2(0,ci.mirror.y));
-				_render_canvas_item_tree(ci.item,xform2,clip_rect,p_canvas->modulate,p_lights);
+				Matrix32 xform2 = p_transform * Matrix32(0, Vector2(0, ci.mirror.y));
+				_render_canvas_item_tree(ci.item, xform2, clip_rect, p_canvas->modulate, p_lights);
 			}
-			if (ci.mirror.y!=0 && ci.mirror.x!=0) {
+			if (ci.mirror.y != 0 && ci.mirror.x != 0) {
 
-				Matrix32 xform2 = p_transform * Matrix32(0,ci.mirror);
-				_render_canvas_item_tree(ci.item,xform2,clip_rect,p_canvas->modulate,p_lights);
+				Matrix32 xform2 = p_transform * Matrix32(0, ci.mirror);
+				_render_canvas_item_tree(ci.item, xform2, clip_rect, p_canvas->modulate, p_lights);
 			}
-
 		}
 	}
-
 }
 
+void VisualServerRaster::_draw_viewport_camera(Viewport *p_viewport, bool p_ignore_camera) {
 
-void VisualServerRaster::_draw_viewport_camera(Viewport *p_viewport,bool p_ignore_camera) {
-
-
-	Camera *camera=NULL;
-	if (camera_owner.owns( p_viewport->camera ))
-		camera=camera_owner.get( p_viewport->camera );
-	Scenario *scenario = scenario_owner.get( p_viewport->scenario );
+	Camera *camera = NULL;
+	if (camera_owner.owns(p_viewport->camera))
+		camera = camera_owner.get(p_viewport->camera);
+	Scenario *scenario = scenario_owner.get(p_viewport->scenario);
 
 	_update_instances(); // check dirty instances before rendering
 
 	if (p_ignore_camera)
-		_render_no_camera(p_viewport, camera,scenario );
+		_render_no_camera(p_viewport, camera, scenario);
 	else
-		_render_camera(p_viewport, camera,scenario );
-
+		_render_camera(p_viewport, camera, scenario);
 }
 
-void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_ofs_y,int p_parent_w,int p_parent_h) {
+void VisualServerRaster::_draw_viewport(Viewport *p_viewport, int p_ofs_x, int p_ofs_y, int p_parent_w, int p_parent_h) {
 
-	ViewportRect desired_rect=p_viewport->rect;
+	ViewportRect desired_rect = p_viewport->rect;
 	ViewportRect old_rect = viewport_rect;
-//	bool vpchanged=false;
+	//	bool vpchanged=false;
 	// convert default expanding viewports to actual size
 	//if (desired_rect.x==0 && desired_rect.y==0 && desired_rect.width==0 && desired_rect.height==0) {
 	if (p_parent_w != 0 && p_parent_h != 0) {
 
-		desired_rect.width=p_parent_w;
-		desired_rect.height=p_parent_h;
+		desired_rect.width = p_parent_w;
+		desired_rect.height = p_parent_h;
 	}
 
-	ERR_FAIL_COND(desired_rect.width<=0 || desired_rect.height<=0);
-
-	desired_rect.x+=p_ofs_x;
-	desired_rect.y+=p_ofs_y;
+	ERR_FAIL_COND(desired_rect.width <= 0 || desired_rect.height <= 0);
 
+	desired_rect.x += p_ofs_x;
+	desired_rect.y += p_ofs_y;
 
 	// if the viewport is different than the actual one, change it
 
-	if ( p_viewport->render_target.is_valid() || viewport_rect.x != desired_rect.x ||
-		viewport_rect.y != desired_rect.y ||
-		viewport_rect.width != desired_rect.width ||
-		viewport_rect.height != desired_rect.height ) {
-
+	if (p_viewport->render_target.is_valid() || viewport_rect.x != desired_rect.x ||
+			viewport_rect.y != desired_rect.y ||
+			viewport_rect.width != desired_rect.width ||
+			viewport_rect.height != desired_rect.height) {
 
-		viewport_rect=desired_rect;
+		viewport_rect = desired_rect;
 		rasterizer->set_viewport(viewport_rect);
-
 	}
 
 	/* Camera should always be BEFORE any other 3D */
 
-	bool scenario_draw_canvas_bg=false;
-	int scenario_canvas_max_layer=0;
+	bool scenario_draw_canvas_bg = false;
+	int scenario_canvas_max_layer = 0;
 
 	if (!p_viewport->hide_canvas && !p_viewport->disable_environment && scenario_owner.owns(p_viewport->scenario)) {
 
-		Scenario *scenario=scenario_owner.get(p_viewport->scenario);
+		Scenario *scenario = scenario_owner.get(p_viewport->scenario);
 		if (scenario->environment.is_valid()) {
 			if (rasterizer->is_environment(scenario->environment)) {
-				scenario_draw_canvas_bg=rasterizer->environment_get_background(scenario->environment)==VS::ENV_BG_CANVAS;
-				scenario_canvas_max_layer=rasterizer->environment_get_background_param(scenario->environment,VS::ENV_BG_PARAM_CANVAS_MAX_LAYER);
+				scenario_draw_canvas_bg = rasterizer->environment_get_background(scenario->environment) == VS::ENV_BG_CANVAS;
+				scenario_canvas_max_layer = rasterizer->environment_get_background_param(scenario->environment, VS::ENV_BG_PARAM_CANVAS_MAX_LAYER);
 			}
 		}
 	}
 
-	bool can_draw_3d=!p_viewport->hide_scenario && camera_owner.owns(p_viewport->camera) && scenario_owner.owns(p_viewport->scenario);
-
+	bool can_draw_3d = !p_viewport->hide_scenario && camera_owner.owns(p_viewport->camera) && scenario_owner.owns(p_viewport->scenario);
 
 	if (scenario_draw_canvas_bg) {
 
@@ -7195,177 +6626,161 @@ void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_
 
 	if (!scenario_draw_canvas_bg && can_draw_3d) {
 
-		_draw_viewport_camera(p_viewport,false);
+		_draw_viewport_camera(p_viewport, false);
 
-	} else if (true /*|| !p_viewport->canvas_list.empty()*/){
+	} else if (true /*|| !p_viewport->canvas_list.empty()*/) {
 
 		//clear the viewport black because of no camera? i seriously should..
 		if (p_viewport->render_target_clear_on_new_frame || p_viewport->render_target_clear) {
 			if (p_viewport->transparent_bg) {
-				rasterizer->clear_viewport(Color(0,0,0,0));
-			}
-			else {
-				Color cc=clear_color;
+				rasterizer->clear_viewport(Color(0, 0, 0, 0));
+			} else {
+				Color cc = clear_color;
 				if (scenario_draw_canvas_bg)
-					cc.a=0;
+					cc.a = 0;
 				rasterizer->clear_viewport(cc);
 			}
-			p_viewport->render_target_clear=false;
+			p_viewport->render_target_clear = false;
 		}
 	}
 
 	if (!p_viewport->hide_canvas) {
-		int i=0;
+		int i = 0;
 
-		Map<Viewport::CanvasKey,Viewport::CanvasData*> canvas_map;
+		Map<Viewport::CanvasKey, Viewport::CanvasData *> canvas_map;
 
-		Rect2 clip_rect(0,0,viewport_rect.width,viewport_rect.height);
-		Rasterizer::CanvasLight *lights=NULL;
-		Rasterizer::CanvasLight *lights_with_shadow=NULL;
-		Rasterizer::CanvasLight *lights_with_mask=NULL;
+		Rect2 clip_rect(0, 0, viewport_rect.width, viewport_rect.height);
+		Rasterizer::CanvasLight *lights = NULL;
+		Rasterizer::CanvasLight *lights_with_shadow = NULL;
+		Rasterizer::CanvasLight *lights_with_mask = NULL;
 		Rect2 shadow_rect;
 
-		int light_count=0;
+		int light_count = 0;
 
-		for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
+		for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
 
 			Matrix32 xf = p_viewport->global_transform * E->get().transform;
 
 			//find lights in canvas
 
+			for (Set<Rasterizer::CanvasLight *>::Element *F = E->get().canvas->lights.front(); F; F = F->next()) {
 
-			for(Set<Rasterizer::CanvasLight*>::Element *F=E->get().canvas->lights.front();F;F=F->next()) {
-
-
-				Rasterizer::CanvasLight* cl=F->get();
+				Rasterizer::CanvasLight *cl = F->get();
 				if (cl->enabled && cl->texture.is_valid()) {
 					//not super efficient..
-					Size2 tsize(rasterizer->texture_get_width(cl->texture),rasterizer->texture_get_height(cl->texture));
-					tsize*=cl->scale;
+					Size2 tsize(rasterizer->texture_get_width(cl->texture), rasterizer->texture_get_height(cl->texture));
+					tsize *= cl->scale;
 
-					Vector2 offset=tsize/2.0;
-					cl->rect_cache=Rect2(-offset+cl->texture_offset,tsize);
-					cl->xform_cache=xf * cl->xform;
+					Vector2 offset = tsize / 2.0;
+					cl->rect_cache = Rect2(-offset + cl->texture_offset, tsize);
+					cl->xform_cache = xf * cl->xform;
 
+					if (clip_rect.intersects_transformed(cl->xform_cache, cl->rect_cache)) {
 
-					if (clip_rect.intersects_transformed(cl->xform_cache,cl->rect_cache)) {
-
-						cl->filter_next_ptr=lights;
-						lights=cl;
-						cl->texture_cache=NULL;
+						cl->filter_next_ptr = lights;
+						lights = cl;
+						cl->texture_cache = NULL;
 						Matrix32 scale;
 						scale.scale(cl->rect_cache.size);
-						scale.elements[2]=cl->rect_cache.pos;
+						scale.elements[2] = cl->rect_cache.pos;
 						cl->light_shader_xform = (cl->xform_cache * scale).affine_inverse();
-						cl->light_shader_pos=cl->xform_cache[2];
+						cl->light_shader_pos = cl->xform_cache[2];
 						if (cl->shadow_buffer.is_valid()) {
 
-							cl->shadows_next_ptr=lights_with_shadow;
-							if (lights_with_shadow==NULL) {
+							cl->shadows_next_ptr = lights_with_shadow;
+							if (lights_with_shadow == NULL) {
 								shadow_rect = cl->xform_cache.xform(cl->rect_cache);
 							} else {
-								shadow_rect=shadow_rect.merge( cl->xform_cache.xform(cl->rect_cache) );
+								shadow_rect = shadow_rect.merge(cl->xform_cache.xform(cl->rect_cache));
 							}
-							lights_with_shadow=cl;
-							cl->radius_cache=cl->rect_cache.size.length();
-
+							lights_with_shadow = cl;
+							cl->radius_cache = cl->rect_cache.size.length();
 						}
-						if (cl->mode==CANVAS_LIGHT_MODE_MASK) {
-							cl->mask_next_ptr=lights_with_mask;
-							lights_with_mask=cl;
+						if (cl->mode == CANVAS_LIGHT_MODE_MASK) {
+							cl->mask_next_ptr = lights_with_mask;
+							lights_with_mask = cl;
 						}
 
 						light_count++;
 					}
-
 				}
 			}
 
 			//print_line("lights: "+itos(light_count));
-			canvas_map[ Viewport::CanvasKey( E->key(), E->get().layer) ]=&E->get();
-
+			canvas_map[Viewport::CanvasKey(E->key(), E->get().layer)] = &E->get();
 		}
 
 		if (lights_with_shadow) {
 			//update shadows if any
 
-			Rasterizer::CanvasLightOccluderInstance * occluders=NULL;
+			Rasterizer::CanvasLightOccluderInstance *occluders = NULL;
 
 			//make list of occluders
-			for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
+			for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
 
 				Matrix32 xf = p_viewport->global_transform * E->get().transform;
 
-				for(Set<Rasterizer::CanvasLightOccluderInstance*>::Element *F=E->get().canvas->occluders.front();F;F=F->next()) {
+				for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *F = E->get().canvas->occluders.front(); F; F = F->next()) {
 
 					if (!F->get()->enabled)
 						continue;
 					F->get()->xform_cache = xf * F->get()->xform;
-					if (shadow_rect.intersects_transformed(F->get()->xform_cache,F->get()->aabb_cache)) {
-
-						F->get()->next=occluders;
-						occluders=F->get();
+					if (shadow_rect.intersects_transformed(F->get()->xform_cache, F->get()->aabb_cache)) {
 
+						F->get()->next = occluders;
+						occluders = F->get();
 					}
 				}
 			}
 			//update the light shadowmaps with them
-			Rasterizer::CanvasLight *light=lights_with_shadow;
-			while(light) {
+			Rasterizer::CanvasLight *light = lights_with_shadow;
+			while (light) {
 
-				rasterizer->canvas_light_shadow_buffer_update(light->shadow_buffer,light->xform_cache.affine_inverse(),light->item_mask,light->radius_cache/1000.0,light->radius_cache*1.1,occluders,&light->shadow_matrix_cache);
-				light=light->shadows_next_ptr;
+				rasterizer->canvas_light_shadow_buffer_update(light->shadow_buffer, light->xform_cache.affine_inverse(), light->item_mask, light->radius_cache / 1000.0, light->radius_cache * 1.1, occluders, &light->shadow_matrix_cache);
+				light = light->shadows_next_ptr;
 			}
 
 			rasterizer->set_viewport(viewport_rect); //must reset viewport afterwards
 		}
 
+		if (scenario_draw_canvas_bg && canvas_map.front() && canvas_map.front()->key().layer > scenario_canvas_max_layer) {
 
-
-
-		if (scenario_draw_canvas_bg && canvas_map.front() && canvas_map.front()->key().layer>scenario_canvas_max_layer) {
-
-			_draw_viewport_camera(p_viewport,!can_draw_3d);
-			scenario_draw_canvas_bg=false;
-
+			_draw_viewport_camera(p_viewport, !can_draw_3d);
+			scenario_draw_canvas_bg = false;
 		}
 
-		for (Map<Viewport::CanvasKey,Viewport::CanvasData*>::Element *E=canvas_map.front();E;E=E->next()) {
-
+		for (Map<Viewport::CanvasKey, Viewport::CanvasData *>::Element *E = canvas_map.front(); E; E = E->next()) {
 
-	//		print_line("canvas "+itos(i)+" size: "+itos(I->get()->canvas->child_items.size()));
+			//		print_line("canvas "+itos(i)+" size: "+itos(I->get()->canvas->child_items.size()));
 			//print_line("GT "+p_viewport->global_transform+". CT: "+E->get()->transform);
 			Matrix32 xform = p_viewport->global_transform * E->get()->transform;
 
-			Rasterizer::CanvasLight *canvas_lights=NULL;
+			Rasterizer::CanvasLight *canvas_lights = NULL;
 
-			Rasterizer::CanvasLight *ptr=lights;
-			while(ptr) {
-				if (E->get()->layer>=ptr->layer_min && E->get()->layer<=ptr->layer_max) {
-					ptr->next_ptr=canvas_lights;
-					canvas_lights=ptr;
+			Rasterizer::CanvasLight *ptr = lights;
+			while (ptr) {
+				if (E->get()->layer >= ptr->layer_min && E->get()->layer <= ptr->layer_max) {
+					ptr->next_ptr = canvas_lights;
+					canvas_lights = ptr;
 				}
-				ptr=ptr->filter_next_ptr;
+				ptr = ptr->filter_next_ptr;
 			}
 
-			_render_canvas( E->get()->canvas,xform,canvas_lights,lights_with_mask );
+			_render_canvas(E->get()->canvas, xform, canvas_lights, lights_with_mask);
 			i++;
 
-			if (scenario_draw_canvas_bg && E->key().layer>=scenario_canvas_max_layer) {
-				_draw_viewport_camera(p_viewport,!can_draw_3d);
-				scenario_draw_canvas_bg=false;
+			if (scenario_draw_canvas_bg && E->key().layer >= scenario_canvas_max_layer) {
+				_draw_viewport_camera(p_viewport, !can_draw_3d);
+				scenario_draw_canvas_bg = false;
 			}
-
-
 		}
 
 		if (scenario_draw_canvas_bg) {
-			_draw_viewport_camera(p_viewport,!can_draw_3d);
-			scenario_draw_canvas_bg=false;
+			_draw_viewport_camera(p_viewport, !can_draw_3d);
+			scenario_draw_canvas_bg = false;
 		}
 
-
-//		rasterizer->canvas_debug_viewport_shadows(lights_with_shadow);
+		//		rasterizer->canvas_debug_viewport_shadows(lights_with_shadow);
 	}
 
 	//capture
@@ -7377,64 +6792,59 @@ void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_
 	}
 
 	//restore
-	if ( viewport_rect.x != old_rect.x ||
-		viewport_rect.y != old_rect.y ||
-		viewport_rect.width != old_rect.width ||
-		viewport_rect.height != old_rect.height ) {
+	if (viewport_rect.x != old_rect.x ||
+			viewport_rect.y != old_rect.y ||
+			viewport_rect.width != old_rect.width ||
+			viewport_rect.height != old_rect.height) {
 
-		viewport_rect=old_rect;
+		viewport_rect = old_rect;
 
 		rasterizer->set_viewport(viewport_rect);
 	}
-
-
 }
 
 void VisualServerRaster::_draw_viewports() {
 
 	//draw viewports for render targets
 
-	List<Viewport*> to_blit;
-	List<Viewport*> to_disable;
-	for(SelfList<Viewport> *E=viewport_update_list.first();E;E=E->next()) {
+	List<Viewport *> to_blit;
+	List<Viewport *> to_disable;
+	for (SelfList<Viewport> *E = viewport_update_list.first(); E; E = E->next()) {
 
 		Viewport *vp = E->self();
 		ERR_CONTINUE(!vp);
 		if (
-			vp->render_target_update_mode==RENDER_TARGET_UPDATE_WHEN_VISIBLE &&
-			!vp->rendered_in_prev_frame &&
-			!vp->queue_capture
-		    ) {
+				vp->render_target_update_mode == RENDER_TARGET_UPDATE_WHEN_VISIBLE &&
+				!vp->rendered_in_prev_frame &&
+				!vp->queue_capture) {
 
 			continue;
 		}
 
-		if (vp->rt_to_screen_rect!=Rect2())
+		if (vp->rt_to_screen_rect != Rect2())
 			to_blit.push_back(vp);
 
-		rasterizer->set_render_target(vp->render_target,vp->transparent_bg,vp->render_target_vflip);
-		_draw_viewport(vp,0,0,vp->rect.width,vp->rect.height);
+		rasterizer->set_render_target(vp->render_target, vp->transparent_bg, vp->render_target_vflip);
+		_draw_viewport(vp, 0, 0, vp->rect.width, vp->rect.height);
 
-		if ( (vp->queue_capture && vp->render_target_update_mode==RENDER_TARGET_UPDATE_DISABLED) || vp->render_target_update_mode==RENDER_TARGET_UPDATE_ONCE) {
+		if ((vp->queue_capture && vp->render_target_update_mode == RENDER_TARGET_UPDATE_DISABLED) || vp->render_target_update_mode == RENDER_TARGET_UPDATE_ONCE) {
 			//was only enabled for capture
 			to_disable.push_back(vp);
-			vp->render_target_update_mode=RENDER_TARGET_UPDATE_DISABLED;
+			vp->render_target_update_mode = RENDER_TARGET_UPDATE_DISABLED;
 		}
-
 	}
 
 	rasterizer->set_render_target(RID());
 
-	while(to_disable.size()) {
+	while (to_disable.size()) {
 		//disable again because it was only for capture
 		viewport_update_list.remove(&to_disable.front()->get()->update_list);
 		to_disable.pop_front();
 	}
 
-
 	//draw RTs directly to screen when requested
 
-	for (List<Viewport*>::Element *E=to_blit.front();E;E=E->next()) {
+	for (List<Viewport *>::Element *E = to_blit.front(); E; E = E->next()) {
 
 		int window_w = OS::get_singleton()->get_video_mode().width;
 		int window_h = OS::get_singleton()->get_video_mode().height;
@@ -7444,12 +6854,12 @@ void VisualServerRaster::_draw_viewports() {
 		desired_rect.width = window_w;
 		desired_rect.height = window_h;
 
-		if ( viewport_rect.x != desired_rect.x ||
-			viewport_rect.y != desired_rect.y ||
-			viewport_rect.width != desired_rect.width ||
-			viewport_rect.height != desired_rect.height ) {
+		if (viewport_rect.x != desired_rect.x ||
+				viewport_rect.y != desired_rect.y ||
+				viewport_rect.width != desired_rect.width ||
+				viewport_rect.height != desired_rect.height) {
 
-			viewport_rect=desired_rect;
+			viewport_rect = desired_rect;
 
 			rasterizer->set_viewport(viewport_rect);
 		}
@@ -7457,15 +6867,12 @@ void VisualServerRaster::_draw_viewports() {
 		rasterizer->canvas_begin();
 		rasterizer->canvas_disable_blending();
 		rasterizer->canvas_begin_rect(Matrix32());
-		rasterizer->canvas_draw_rect(E->get()->rt_to_screen_rect,0,Rect2(Point2(),E->get()->rt_to_screen_rect.size),E->get()->render_target_texture,Color(1,1,1));
-
+		rasterizer->canvas_draw_rect(E->get()->rt_to_screen_rect, 0, Rect2(Point2(), E->get()->rt_to_screen_rect.size), E->get()->render_target_texture, Color(1, 1, 1));
 	}
 
-
-
 	//draw viewports attached to screen
 
-	for(Map<RID,int>::Element *E=screen_viewports.front();E;E=E->next()) {
+	for (Map<RID, int>::Element *E = screen_viewports.front(); E; E = E->next()) {
 
 		Viewport *vp = viewport_owner.get(E->key());
 		ERR_CONTINUE(!vp);
@@ -7473,32 +6880,27 @@ void VisualServerRaster::_draw_viewports() {
 		int window_w = OS::get_singleton()->get_video_mode(E->get()).width;
 		int window_h = OS::get_singleton()->get_video_mode(E->get()).height;
 
-		Rect2 r(0,0,vp->rect.width,vp->rect.height);
-		if (r.size.width==0)
-			r.size.width=window_w;
-		if (r.size.height==0)
-			r.size.height=window_h;
+		Rect2 r(0, 0, vp->rect.width, vp->rect.height);
+		if (r.size.width == 0)
+			r.size.width = window_w;
+		if (r.size.height == 0)
+			r.size.height = window_h;
 
-
-		_draw_viewport(vp,r.pos.x,r.pos.y,r.size.width,r.size.height);
+		_draw_viewport(vp, r.pos.x, r.pos.y, r.size.width, r.size.height);
 	}
 
-
 	//check when a viewport associated to a render target was drawn
 
-	for(SelfList<Viewport> *E=viewport_update_list.first();E;E=E->next()) {
+	for (SelfList<Viewport> *E = viewport_update_list.first(); E; E = E->next()) {
 
 		Viewport *vp = E->self();
 		ERR_CONTINUE(!vp);
-		if (vp->render_target_update_mode!=RENDER_TARGET_UPDATE_WHEN_VISIBLE)
+		if (vp->render_target_update_mode != RENDER_TARGET_UPDATE_WHEN_VISIBLE)
 			continue;
-		vp->rendered_in_prev_frame=rasterizer->render_target_renedered_in_frame(vp->render_target);
+		vp->rendered_in_prev_frame = rasterizer->render_target_renedered_in_frame(vp->render_target);
 	}
-
 }
 
-
-
 void VisualServerRaster::_draw_cursors_and_margins() {
 
 	int window_w = OS::get_singleton()->get_video_mode().width;
@@ -7509,12 +6911,12 @@ void VisualServerRaster::_draw_cursors_and_margins() {
 	desired_rect.width = window_w;
 	desired_rect.height = window_h;
 
-	if ( viewport_rect.x != desired_rect.x ||
-		viewport_rect.y != desired_rect.y ||
-		viewport_rect.width != desired_rect.width ||
-		viewport_rect.height != desired_rect.height ) {
+	if (viewport_rect.x != desired_rect.x ||
+			viewport_rect.y != desired_rect.y ||
+			viewport_rect.width != desired_rect.width ||
+			viewport_rect.height != desired_rect.height) {
 
-		viewport_rect=desired_rect;
+		viewport_rect = desired_rect;
 
 		rasterizer->set_viewport(viewport_rect);
 	}
@@ -7522,52 +6924,50 @@ void VisualServerRaster::_draw_cursors_and_margins() {
 	rasterizer->canvas_begin();
 	rasterizer->canvas_begin_rect(Matrix32());
 
-	for (int i=0; i<MAX_CURSORS; i++) {
+	for (int i = 0; i < MAX_CURSORS; i++) {
 
 		if (!cursors[i].visible) {
 
 			continue;
 		};
 
-		RID tex = cursors[i].texture?cursors[i].texture:default_cursor_texture;
-		ERR_CONTINUE( !tex );
+		RID tex = cursors[i].texture ? cursors[i].texture : default_cursor_texture;
+		ERR_CONTINUE(!tex);
 		if (cursors[i].region.has_no_area()) {
 			Point2 size(texture_get_width(tex), texture_get_height(tex));
-			rasterizer->canvas_draw_rect(Rect2(cursors[i].pos-cursors[i].center, size), 0, Rect2(), tex, Color(1, 1, 1, 1));
+			rasterizer->canvas_draw_rect(Rect2(cursors[i].pos - cursors[i].center, size), 0, Rect2(), tex, Color(1, 1, 1, 1));
 		} else {
 			Point2 size = cursors[i].region.size;
-			rasterizer->canvas_draw_rect(Rect2(cursors[i].pos-cursors[i].center, size), Rasterizer::CANVAS_RECT_REGION, cursors[i].region, tex, Color(1, 1, 1, 1));
+			rasterizer->canvas_draw_rect(Rect2(cursors[i].pos - cursors[i].center, size), Rasterizer::CANVAS_RECT_REGION, cursors[i].region, tex, Color(1, 1, 1, 1));
 		}
 	};
 
-
-
 	if (black_image[MARGIN_LEFT].is_valid()) {
-		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_LEFT]),rasterizer->texture_get_height(black_image[MARGIN_LEFT]));
-		rasterizer->canvas_draw_rect(Rect2(0,0,black_margin[MARGIN_LEFT],window_h),0,Rect2(0,0,sz.x,sz.y),black_image[MARGIN_LEFT],Color(1,1,1));
+		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_LEFT]), rasterizer->texture_get_height(black_image[MARGIN_LEFT]));
+		rasterizer->canvas_draw_rect(Rect2(0, 0, black_margin[MARGIN_LEFT], window_h), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_LEFT], Color(1, 1, 1));
 	} else if (black_margin[MARGIN_LEFT])
-		rasterizer->canvas_draw_rect(Rect2(0,0,black_margin[MARGIN_LEFT],window_h),0,Rect2(0,0,1,1),RID(),Color(0,0,0));
+		rasterizer->canvas_draw_rect(Rect2(0, 0, black_margin[MARGIN_LEFT], window_h), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
 
 	if (black_image[MARGIN_RIGHT].is_valid()) {
-		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_RIGHT]),rasterizer->texture_get_height(black_image[MARGIN_RIGHT]));
-		rasterizer->canvas_draw_rect(Rect2(window_w-black_margin[MARGIN_RIGHT],0,black_margin[MARGIN_RIGHT],window_h),0,Rect2(0,0,sz.x,sz.y),black_image[MARGIN_RIGHT],Color(1,1,1));
+		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_RIGHT]), rasterizer->texture_get_height(black_image[MARGIN_RIGHT]));
+		rasterizer->canvas_draw_rect(Rect2(window_w - black_margin[MARGIN_RIGHT], 0, black_margin[MARGIN_RIGHT], window_h), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_RIGHT], Color(1, 1, 1));
 	} else if (black_margin[MARGIN_RIGHT])
-		rasterizer->canvas_draw_rect(Rect2(window_w-black_margin[MARGIN_RIGHT],0,black_margin[MARGIN_RIGHT],window_h),0,Rect2(0,0,1,1),RID(),Color(0,0,0));
+		rasterizer->canvas_draw_rect(Rect2(window_w - black_margin[MARGIN_RIGHT], 0, black_margin[MARGIN_RIGHT], window_h), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
 
 	if (black_image[MARGIN_TOP].is_valid()) {
-		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_TOP]),rasterizer->texture_get_height(black_image[MARGIN_TOP]));
-		rasterizer->canvas_draw_rect(Rect2(0,0,window_w,black_margin[MARGIN_TOP]),0,Rect2(0,0,sz.x,sz.y),black_image[MARGIN_TOP],Color(1,1,1));
+		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_TOP]), rasterizer->texture_get_height(black_image[MARGIN_TOP]));
+		rasterizer->canvas_draw_rect(Rect2(0, 0, window_w, black_margin[MARGIN_TOP]), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_TOP], Color(1, 1, 1));
 
 	} else if (black_margin[MARGIN_TOP]) {
-		rasterizer->canvas_draw_rect(Rect2(0,0,window_w,black_margin[MARGIN_TOP]),0,Rect2(0,0,1,1),RID(),Color(0,0,0));
+		rasterizer->canvas_draw_rect(Rect2(0, 0, window_w, black_margin[MARGIN_TOP]), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
 	}
 
 	if (black_image[MARGIN_BOTTOM].is_valid()) {
 
-		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_BOTTOM]),rasterizer->texture_get_height(black_image[MARGIN_BOTTOM]));
-		rasterizer->canvas_draw_rect(Rect2(0,window_h-black_margin[MARGIN_BOTTOM],window_w,black_margin[MARGIN_BOTTOM]),0,Rect2(0,0,sz.x,sz.y),black_image[MARGIN_BOTTOM],Color(1,1,1));
+		Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_BOTTOM]), rasterizer->texture_get_height(black_image[MARGIN_BOTTOM]));
+		rasterizer->canvas_draw_rect(Rect2(0, window_h - black_margin[MARGIN_BOTTOM], window_w, black_margin[MARGIN_BOTTOM]), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_BOTTOM], Color(1, 1, 1));
 	} else if (black_margin[MARGIN_BOTTOM]) {
-		rasterizer->canvas_draw_rect(Rect2(0,window_h-black_margin[MARGIN_BOTTOM],window_w,black_margin[MARGIN_BOTTOM]),0,Rect2(0,0,1,1),RID(),Color(0,0,0));
+		rasterizer->canvas_draw_rect(Rect2(0, window_h - black_margin[MARGIN_BOTTOM], window_w, black_margin[MARGIN_BOTTOM]), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
 	}
 
 	rasterizer->canvas_end_rect();
@@ -7580,20 +6980,20 @@ void VisualServerRaster::sync() {
 void VisualServerRaster::draw() {
 	//if (changes)
 	//	print_line("changes: "+itos(changes));
-	changes=0;
-	shadows_enabled=GLOBAL_DEF("render/shadows_enabled",true);
-	room_cull_enabled = GLOBAL_DEF("render/room_cull_enabled",true);
-	light_discard_enabled = GLOBAL_DEF("render/light_discard_enabled",true);
+	changes = 0;
+	shadows_enabled = GLOBAL_DEF("render/shadows_enabled", true);
+	room_cull_enabled = GLOBAL_DEF("render/room_cull_enabled", true);
+	light_discard_enabled = GLOBAL_DEF("render/light_discard_enabled", true);
 	rasterizer->begin_frame();
 	_draw_viewports();
 	_draw_cursors_and_margins();
 	rasterizer->end_frame();
-	draw_extra_frame=rasterizer->needs_to_draw_next_frame();
+	draw_extra_frame = rasterizer->needs_to_draw_next_frame();
 }
 
 bool VisualServerRaster::has_changed() const {
 
-	return changes>0 || draw_extra_frame;
+	return changes > 0 || draw_extra_frame;
 }
 
 int VisualServerRaster::get_render_info(RenderInfo p_info) {
@@ -7606,9 +7006,9 @@ bool VisualServerRaster::has_feature(Features p_feature) const {
 	return rasterizer->has_feature(p_feature); // lies for now
 }
 
-void VisualServerRaster::set_default_clear_color(const Color& p_color) {
+void VisualServerRaster::set_default_clear_color(const Color &p_color) {
 
-	clear_color=p_color;
+	clear_color = p_color;
 }
 
 Color VisualServerRaster::get_default_clear_color() const {
@@ -7616,7 +7016,7 @@ Color VisualServerRaster::get_default_clear_color() const {
 	return clear_color;
 }
 
-void VisualServerRaster::set_boot_image(const Image& p_image, const Color& p_color,bool p_scale) {
+void VisualServerRaster::set_boot_image(const Image &p_image, const Color &p_color, bool p_scale) {
 
 	if (p_image.empty())
 		return;
@@ -7628,18 +7028,18 @@ void VisualServerRaster::set_boot_image(const Image& p_image, const Color& p_col
 	int window_w = OS::get_singleton()->get_video_mode(0).width;
 	int window_h = OS::get_singleton()->get_video_mode(0).height;
 	ViewportRect vr;
-	vr.x=0;
-	vr.y=0;
-	vr.width=OS::get_singleton()->get_video_mode(0).width;
-	vr.height=OS::get_singleton()->get_video_mode(0).height;
+	vr.x = 0;
+	vr.y = 0;
+	vr.width = OS::get_singleton()->get_video_mode(0).width;
+	vr.height = OS::get_singleton()->get_video_mode(0).height;
 	rasterizer->set_viewport(vr);
 	rasterizer->clear_viewport(p_color);
 	rasterizer->canvas_begin();
 	RID texture = texture_create();
-	texture_allocate(texture,p_image.get_width(),p_image.get_height(),p_image.get_format(),TEXTURE_FLAG_FILTER);
-	texture_set_data(texture,p_image);
+	texture_allocate(texture, p_image.get_width(), p_image.get_height(), p_image.get_format(), TEXTURE_FLAG_FILTER);
+	texture_set_data(texture, p_image);
 	rasterizer->canvas_begin_rect(Matrix32());
-	Rect2 imgrect(0,0,p_image.get_width(),p_image.get_height());
+	Rect2 imgrect(0, 0, p_image.get_width(), p_image.get_height());
 	Rect2 screenrect;
 	if (p_scale) {
 
@@ -7647,59 +7047,57 @@ void VisualServerRaster::set_boot_image(const Image& p_image, const Color& p_col
 			//scale horizontally
 			screenrect.size.y = window_h;
 			screenrect.size.x = imgrect.size.x * window_h / imgrect.size.y;
-			screenrect.pos.x = (window_w - screenrect.size.x)/2;
+			screenrect.pos.x = (window_w - screenrect.size.x) / 2;
 
 		} else {
 			//scale vertically
 			screenrect.size.x = window_w;
 			screenrect.size.y = imgrect.size.y * window_w / imgrect.size.x;
-			screenrect.pos.y = (window_h - screenrect.size.y)/2;
+			screenrect.pos.y = (window_h - screenrect.size.y) / 2;
 		}
 	} else {
 
-		screenrect=imgrect;
-		screenrect.pos+=((Size2(vr.width,vr.height)-screenrect.size)/2.0).floor();
-
+		screenrect = imgrect;
+		screenrect.pos += ((Size2(vr.width, vr.height) - screenrect.size) / 2.0).floor();
 	}
-	rasterizer->canvas_draw_rect(screenrect,0,imgrect,texture,Color(1,1,1,1));
+	rasterizer->canvas_draw_rect(screenrect, 0, imgrect, texture, Color(1, 1, 1, 1));
 	rasterizer->canvas_end_rect();
 
 	rasterizer->end_frame();
 	rasterizer->flush_frame();
 
 	free(texture); // free since it's only one frame that stays there
-
 }
 
 void VisualServerRaster::init() {
 
 	rasterizer->init();
 
-	shadows_enabled=GLOBAL_DEF("render/shadows_enabled",true);
+	shadows_enabled = GLOBAL_DEF("render/shadows_enabled", true);
 	//default_scenario = scenario_create();
 	//default_viewport = viewport_create();
-	for(int i=0;i<4;i++)
-		black_margin[i]=0;
+	for (int i = 0; i < 4; i++)
+		black_margin[i] = 0;
 
 	Image img;
 	img.create(default_mouse_cursor_xpm);
 	//img.convert(Image::FORMAT_RGB);
 	default_cursor_texture = texture_create_from_image(img, 0);
 
-	aabb_random_points.resize( GLOBAL_DEF("render/aabb_random_points",16) );
-	for(int i=0;i<aabb_random_points.size();i++)
-		aabb_random_points[i]=Vector3(Math::random(0,1),Math::random(0,1),Math::random(0,1));
+	aabb_random_points.resize(GLOBAL_DEF("render/aabb_random_points", 16));
+	for (int i = 0; i < aabb_random_points.size(); i++)
+		aabb_random_points[i] = Vector3(Math::random(0, 1), Math::random(0, 1), Math::random(0, 1));
 	transformed_aabb_random_points.resize(aabb_random_points.size());
-	changes=0;
+	changes = 0;
 }
 
-void VisualServerRaster::_clean_up_owner(RID_OwnerBase *p_owner,String p_type) {
+void VisualServerRaster::_clean_up_owner(RID_OwnerBase *p_owner, String p_type) {
 
 	List<RID> rids;
 	p_owner->get_owned_list(&rids);
 
-	int lost=0;
-	for(List<RID>::Element *I=rids.front();I;I=I->next()) {
+	int lost = 0;
+	for (List<RID>::Element *I = rids.front(); I; I = I->next()) {
 		if (OS::get_singleton()->is_stdout_verbose()) {
 			lost++;
 		}
@@ -7707,66 +7105,57 @@ void VisualServerRaster::_clean_up_owner(RID_OwnerBase *p_owner,String p_type) {
 	}
 
 	if (lost)
-		print_line("VisualServerRaster: WARNING: Lost "+itos(lost)+" RIDs of type "+p_type);
-
+		print_line("VisualServerRaster: WARNING: Lost " + itos(lost) + " RIDs of type " + p_type);
 }
 
 void VisualServerRaster::finish() {
 
-
 	free(default_cursor_texture);
 	if (test_cube.is_valid())
 		free(test_cube);
 
 	_free_internal_rids();
 
-	_clean_up_owner( &room_owner,"Room" );
-	_clean_up_owner( &portal_owner,"Portal" );
+	_clean_up_owner(&room_owner, "Room");
+	_clean_up_owner(&portal_owner, "Portal");
 
-	_clean_up_owner( &camera_owner,"Camera" );
-	_clean_up_owner( &viewport_owner,"Viewport" );
+	_clean_up_owner(&camera_owner, "Camera");
+	_clean_up_owner(&viewport_owner, "Viewport");
 
-	_clean_up_owner( &scenario_owner,"Scenario" );
-	_clean_up_owner( &instance_owner,"Instance" );
+	_clean_up_owner(&scenario_owner, "Scenario");
+	_clean_up_owner(&instance_owner, "Instance");
 
-	_clean_up_owner( &canvas_owner,"Canvas" );
-	_clean_up_owner( &canvas_item_owner,"CanvasItem" );
+	_clean_up_owner(&canvas_owner, "Canvas");
+	_clean_up_owner(&canvas_item_owner, "CanvasItem");
 
 	rasterizer->finish();
 	octree_allocator.clear();
 
 	if (instance_dependency_map.size()) {
-		print_line("Base resources missing amount: "+itos(instance_dependency_map.size()));
+		print_line("Base resources missing amount: " + itos(instance_dependency_map.size()));
 	}
-	ERR_FAIL_COND( instance_dependency_map.size() );
+	ERR_FAIL_COND(instance_dependency_map.size());
 }
 
-
-RID VisualServerRaster::get_test_cube()  {
+RID VisualServerRaster::get_test_cube() {
 
 	if (test_cube.is_valid())
 		return test_cube;
 
-	test_cube=_make_test_cube();
+	test_cube = _make_test_cube();
 	return test_cube;
-
 }
 
-
-
 VisualServerRaster::VisualServerRaster(Rasterizer *p_rasterizer) {
 
-	rasterizer=p_rasterizer;
-	rasterizer->draw_viewport_func=_render_canvas_item_viewport;
-	instance_update_list=NULL;
-	render_pass=0;
-	clear_color=Color(0.3,0.3,0.3,1.0);
-	OctreeAllocator::allocator=&octree_allocator;
-	draw_extra_frame=false;
-
+	rasterizer = p_rasterizer;
+	rasterizer->draw_viewport_func = _render_canvas_item_viewport;
+	instance_update_list = NULL;
+	render_pass = 0;
+	clear_color = Color(0.3, 0.3, 0.3, 1.0);
+	OctreeAllocator::allocator = &octree_allocator;
+	draw_extra_frame = false;
 }
 
-
-VisualServerRaster::~VisualServerRaster()
-{
+VisualServerRaster::~VisualServerRaster() {
 }
diff --git a/servers/visual/visual_server_raster.h b/servers/visual/visual_server_raster.h
index 13564f3dc..e06aad2be 100644
--- a/servers/visual/visual_server_raster.h
+++ b/servers/visual/visual_server_raster.h
@@ -29,31 +29,27 @@
 #ifndef VISUAL_SERVER_RASTER_H
 #define VISUAL_SERVER_RASTER_H
 
-
-#include "servers/visual_server.h"
-#include "servers/visual/rasterizer.h"
 #include "allocators.h"
 #include "octree.h"
+#include "servers/visual/rasterizer.h"
+#include "servers/visual_server.h"
 
 /**
 	@author Juan Linietsky <reduzio@gmail.com>
 */
 
-
 class VisualServerRaster : public VisualServer {
 
-
 	enum {
 
-		MAX_INSTANCE_CULL=8192,
-		MAX_INSTANCE_LIGHTS=4,
-		LIGHT_CACHE_DIRTY=-1,
-		MAX_LIGHTS_CULLED=256,
-		MAX_ROOM_CULL=32,
-		MAX_EXTERIOR_PORTALS=128,
-		MAX_LIGHT_SAMPLERS=256,
-		INSTANCE_ROOMLESS_MASK=(1<<20)
-
+		MAX_INSTANCE_CULL = 8192,
+		MAX_INSTANCE_LIGHTS = 4,
+		LIGHT_CACHE_DIRTY = -1,
+		MAX_LIGHTS_CULLED = 256,
+		MAX_ROOM_CULL = 32,
+		MAX_EXTERIOR_PORTALS = 128,
+		MAX_LIGHT_SAMPLERS = 256,
+		INSTANCE_ROOMLESS_MASK = (1 << 20)
 
 	};
 
@@ -61,10 +57,9 @@ class VisualServerRaster : public VisualServer {
 
 		bool occlude_exterior;
 		BSP_Tree bounds;
-		Room() { occlude_exterior=true; }
+		Room() { occlude_exterior = true; }
 	};
 
-
 	BalloonAllocator<> octree_allocator;
 
 	struct OctreeAllocator {
@@ -73,7 +68,6 @@ class VisualServerRaster : public VisualServer {
 
 		_FORCE_INLINE_ static void *alloc(size_t p_size) { return allocator->alloc(p_size); }
 		_FORCE_INLINE_ static void free(void *p_ptr) { return allocator->free(p_ptr); }
-
 	};
 
 	struct Portal {
@@ -85,8 +79,12 @@ class VisualServerRaster : public VisualServer {
 		Vector<Point2> shape;
 		Rect2 bounds;
 
-
-		Portal() { enabled=true; disable_distance=50; disable_color=Color(); connect_range=0.8; }
+		Portal() {
+			enabled = true;
+			disable_distance = 50;
+			disable_color = Color();
+			connect_range = 0.8;
+		}
 	};
 
 	struct BakedLight {
@@ -96,7 +94,6 @@ class VisualServerRaster : public VisualServer {
 		AABB octree_aabb;
 		Size2i octree_tex_size;
 		Size2i light_tex_size;
-
 	};
 
 	struct BakedLightSampler {
@@ -106,16 +103,16 @@ class VisualServerRaster : public VisualServer {
 		Vector<Vector3> dp_cache;
 
 		BakedLightSampler() {
-			params[BAKED_LIGHT_SAMPLER_STRENGTH]=1.0;
-			params[BAKED_LIGHT_SAMPLER_ATTENUATION]=1.0;
-			params[BAKED_LIGHT_SAMPLER_RADIUS]=1.0;
-			params[BAKED_LIGHT_SAMPLER_DETAIL_RATIO]=0.1;
-			resolution=16;
+			params[BAKED_LIGHT_SAMPLER_STRENGTH] = 1.0;
+			params[BAKED_LIGHT_SAMPLER_ATTENUATION] = 1.0;
+			params[BAKED_LIGHT_SAMPLER_RADIUS] = 1.0;
+			params[BAKED_LIGHT_SAMPLER_DETAIL_RATIO] = 0.1;
+			resolution = 16;
 		}
 	};
 
-	void _update_baked_light_sampler_dp_cache(BakedLightSampler * blsamp);
-	struct Camera  {
+	void _update_baked_light_sampler_dp_cache(BakedLightSampler *blsamp);
+	struct Camera {
 
 		enum Type {
 			PERSPECTIVE,
@@ -123,7 +120,7 @@ class VisualServerRaster : public VisualServer {
 		};
 		Type type;
 		float fov;
-		float znear,zfar;
+		float znear, zfar;
 		float size;
 		uint32_t visible_layers;
 		bool vaspect;
@@ -131,28 +128,27 @@ class VisualServerRaster : public VisualServer {
 
 		Transform transform;
 
- 		Camera() {
-
-			visible_layers=0xFFFFFFFF;
-			fov=60;
-			type=PERSPECTIVE;
-			znear=0.1; zfar=100;
-			size=1.0;
-			vaspect=false;
-
- 		}
- 	};
+		Camera() {
 
+			visible_layers = 0xFFFFFFFF;
+			fov = 60;
+			type = PERSPECTIVE;
+			znear = 0.1;
+			zfar = 100;
+			size = 1.0;
+			vaspect = false;
+		}
+	};
 
 	struct Instance;
-	typedef Set<Instance*,Comparator<Instance*>,OctreeAllocator> InstanceSet;
+	typedef Set<Instance *, Comparator<Instance *>, OctreeAllocator> InstanceSet;
 	struct Scenario;
 
 	struct Instance {
 
 		enum {
 
-			MAX_LIGHTS=4
+			MAX_LIGHTS = 4
 		};
 
 		RID self;
@@ -176,17 +172,14 @@ class VisualServerRaster : public VisualServer {
 		float draw_range_end;
 		float extra_margin;
 
-
-
 		Rasterizer::InstanceData data;
 
-
-		Set<Instance*> auto_rooms;
-		Set<Instance*> valid_auto_rooms;
+		Set<Instance *> auto_rooms;
+		Set<Instance *> valid_auto_rooms;
 		Instance *room;
-		List<Instance*>::Element *RE;
+		List<Instance *>::Element *RE;
 		Instance *baked_light;
-		List<Instance*>::Element *BLE;
+		List<Instance *>::Element *BLE;
 		Instance *sampled_light;
 		bool exterior;
 
@@ -198,35 +191,34 @@ class VisualServerRaster : public VisualServer {
 		InstanceSet lights;
 		bool light_cache_dirty;
 
-
-
 		struct RoomInfo {
 
 			Transform affine_inverse;
 			Room *room;
-			List<Instance*> owned_geometry_instances;
-			List<Instance*> owned_portal_instances;
-			List<Instance*> owned_room_instances;
-			List<Instance*> owned_light_instances; //not used, but just for the sake of it
-			Set<Instance*> disconnected_child_portals;
-			Set<Instance*> owned_autoroom_geometry;
+			List<Instance *> owned_geometry_instances;
+			List<Instance *> owned_portal_instances;
+			List<Instance *> owned_room_instances;
+			List<Instance *> owned_light_instances; //not used, but just for the sake of it
+			Set<Instance *> disconnected_child_portals;
+			Set<Instance *> owned_autoroom_geometry;
 			uint64_t last_visited_pass;
-			RoomInfo() { last_visited_pass=0; }
-
+			RoomInfo() { last_visited_pass = 0; }
 		};
 
 		struct PortalInfo {
 
 			Portal *portal;
-			Set<Instance*> candidate_set;
+			Set<Instance *> candidate_set;
 			Instance *connected;
 			uint64_t last_visited_pass;
 
 			Plane plane_cache;
 			Vector<Vector3> transformed_point_cache;
 
-
-			PortalInfo() { connected=NULL; last_visited_pass=0;}
+			PortalInfo() {
+				connected = NULL;
+				last_visited_pass = 0;
+			}
 		};
 
 		struct LightInfo {
@@ -240,13 +232,12 @@ class VisualServerRaster : public VisualServer {
 			bool enabled;
 			float dtc; //distance to camera, used for sorting
 
-
 			LightInfo() {
 
-				D=NULL;
-				light_set_index=-1;
-				last_add_pass=0;
-				enabled=true;
+				D = NULL;
+				light_set_index = -1;
+				last_add_pass = 0;
+				enabled = true;
 			}
 		};
 
@@ -254,13 +245,13 @@ class VisualServerRaster : public VisualServer {
 
 			BakedLight *baked_light;
 			Transform affine_inverse;
-			List<Instance*> owned_instances;
+			List<Instance *> owned_instances;
 		};
 
 		struct BakedLightSamplerInfo {
 
-			Set<Instance*> baked_lights;
-			Set<Instance*> owned_instances;
+			Set<Instance *> baked_lights;
+			Set<Instance *> owned_instances;
 			BakedLightSampler *sampler;
 			int resolution;
 			Vector<Color> light_bufer;
@@ -268,9 +259,9 @@ class VisualServerRaster : public VisualServer {
 			uint64_t last_pass;
 			Transform xform; // viewspace normal to lightspace, might not use one.
 			BakedLightSamplerInfo() {
-				sampler=NULL;
-				last_pass=0;
-				resolution=0;
+				sampler = NULL;
+				last_pass = 0;
+				resolution = 0;
 			}
 		};
 
@@ -279,56 +270,53 @@ class VisualServerRaster : public VisualServer {
 			RID instance;
 		};
 
-
 		RoomInfo *room_info;
 		LightInfo *light_info;
 		ParticlesInfo *particles_info;
-		PortalInfo * portal_info;
-		BakedLightInfo * baked_light_info;
-		BakedLightSamplerInfo * baked_light_sampler_info;
-
+		PortalInfo *portal_info;
+		BakedLightInfo *baked_light_info;
+		BakedLightSamplerInfo *baked_light_sampler_info;
 
 		Instance() {
-			octree_id=0;
-			update_next=0;
-			object_ID=0;
-			last_render_pass=0;
-			last_frame_pass=0;
-			light_info=0;
-			particles_info=0;
-			update_next=NULL;
-			update=false;
-			visible=true;
-			data.cast_shadows=SHADOW_CASTING_SETTING_ON;
-			data.receive_shadows=true;
-			data.depth_scale=false;
-			data.billboard=false;
-			data.billboard_y=false;
-			data.baked_light=NULL;
-			data.baked_light_octree_xform=NULL;
-			data.baked_lightmap_id=-1;
-			version=1;
-			room_info=NULL;
-			room=NULL;
-			RE=NULL;
-			portal_info=NULL;
-			exterior=false;
-			layer_mask=1;
-			draw_range_begin=0;
-			draw_range_end=0;
-			extra_margin=0;
-			visible_in_all_rooms=false;
-			update_aabb=false;
-			update_materials=false;
+			octree_id = 0;
+			update_next = 0;
+			object_ID = 0;
+			last_render_pass = 0;
+			last_frame_pass = 0;
+			light_info = 0;
+			particles_info = 0;
+			update_next = NULL;
+			update = false;
+			visible = true;
+			data.cast_shadows = SHADOW_CASTING_SETTING_ON;
+			data.receive_shadows = true;
+			data.depth_scale = false;
+			data.billboard = false;
+			data.billboard_y = false;
+			data.baked_light = NULL;
+			data.baked_light_octree_xform = NULL;
+			data.baked_lightmap_id = -1;
+			version = 1;
+			room_info = NULL;
+			room = NULL;
+			RE = NULL;
+			portal_info = NULL;
+			exterior = false;
+			layer_mask = 1;
+			draw_range_begin = 0;
+			draw_range_end = 0;
+			extra_margin = 0;
+			visible_in_all_rooms = false;
+			update_aabb = false;
+			update_materials = false;
 
-			baked_light=NULL;
-			baked_light_info=NULL;
-			baked_light_sampler_info=NULL;
-			sampled_light=NULL;
-			BLE=NULL;
-
-			light_cache_dirty=true;
+			baked_light = NULL;
+			baked_light_info = NULL;
+			baked_light_sampler_info = NULL;
+			sampled_light = NULL;
+			BLE = NULL;
 
+			light_cache_dirty = true;
 		}
 
 		~Instance() {
@@ -348,16 +336,15 @@ class VisualServerRaster : public VisualServer {
 
 	struct _InstanceLightsort {
 
-		bool operator()(const Instance* p_A, const Instance* p_B) const { return p_A->light_info->dtc < p_B->light_info->dtc; }
+		bool operator()(const Instance *p_A, const Instance *p_B) const { return p_A->light_info->dtc < p_B->light_info->dtc; }
 	};
 
 	struct Scenario {
 
-
 		ScenarioDebugMode debug;
 		RID self;
 		// well wtf, balloon allocator is slower?
-		typedef ::Octree<Instance,true> Octree;
+		typedef ::Octree<Instance, true> Octree;
 
 		Octree octree;
 
@@ -367,18 +354,18 @@ class VisualServerRaster : public VisualServer {
 
 		Instance *dirty_instances;
 
-		Scenario() { dirty_instances=NULL; debug=SCENARIO_DEBUG_DISABLED; }
+		Scenario() {
+			dirty_instances = NULL;
+			debug = SCENARIO_DEBUG_DISABLED;
+		}
 	};
 
-
-
 	mutable RID_Owner<Rasterizer::CanvasItemMaterial> canvas_item_material_owner;
 
 	struct CanvasItem : public Rasterizer::CanvasItem {
 
-
 		RID parent; // canvas it belongs to
-		List<CanvasItem*>::Element *E;
+		List<CanvasItem *>::Element *E;
 		RID viewport;
 		int z;
 		bool z_relative;
@@ -387,27 +374,24 @@ class VisualServerRaster : public VisualServer {
 		float self_opacity;
 		bool use_parent_material;
 
-
-		Vector<CanvasItem*> child_items;
-
+		Vector<CanvasItem *> child_items;
 
 		CanvasItem() {
-			E=NULL;
-			z=0;
-			opacity=1;
-			self_opacity=1;
-			sort_y=false;
-			use_parent_material=false;
-			z_relative=true;
+			E = NULL;
+			z = 0;
+			opacity = 1;
+			self_opacity = 1;
+			sort_y = false;
+			use_parent_material = false;
+			z_relative = true;
 		}
 	};
 
-
 	struct CanvasItemPtrSort {
 
-		_FORCE_INLINE_ bool operator()(const CanvasItem* p_left,const CanvasItem* p_right) const {
+		_FORCE_INLINE_ bool operator()(const CanvasItem *p_left, const CanvasItem *p_right) const {
 
-			if(Math::abs(p_left->xform.elements[2].y - p_right->xform.elements[2].y) < CMP_EPSILON )
+			if (Math::abs(p_left->xform.elements[2].y - p_right->xform.elements[2].y) < CMP_EPSILON)
 				return p_left->xform.elements[2].x < p_right->xform.elements[2].x;
 			else
 				return p_left->xform.elements[2].y < p_right->xform.elements[2].y;
@@ -422,12 +406,14 @@ class VisualServerRaster : public VisualServer {
 		Rect2 aabb;
 		CanvasOccluderPolygonCullMode cull_mode;
 		RID occluder;
-		Set<Rasterizer::CanvasLightOccluderInstance*> owners;
+		Set<Rasterizer::CanvasLightOccluderInstance *> owners;
 
-		CanvasLightOccluderPolygon() { active=false; cull_mode=CANVAS_OCCLUDER_POLYGON_CULL_DISABLED; }
+		CanvasLightOccluderPolygon() {
+			active = false;
+			cull_mode = CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+		}
 	};
 
-
 	RID_Owner<CanvasLightOccluderPolygon> canvas_light_occluder_polygon_owner;
 
 	RID_Owner<Rasterizer::CanvasLightOccluderInstance> canvas_light_occluder_owner;
@@ -443,33 +429,30 @@ class VisualServerRaster : public VisualServer {
 			CanvasItem *item;
 		};
 
-		Set<Rasterizer::CanvasLight*> lights;
-		Set<Rasterizer::CanvasLightOccluderInstance*> occluders;
+		Set<Rasterizer::CanvasLight *> lights;
+		Set<Rasterizer::CanvasLightOccluderInstance *> occluders;
 
 		Vector<ChildItem> child_items;
 		Color modulate;
 
 		int find_item(CanvasItem *p_item) {
-			for(int i=0;i<child_items.size();i++) {
-				if (child_items[i].item==p_item)
+			for (int i = 0; i < child_items.size(); i++) {
+				if (child_items[i].item == p_item)
 					return i;
 			}
 			return -1;
 		}
 		void erase_item(CanvasItem *p_item) {
-			int idx=find_item(p_item);
-			if (idx>=0)
+			int idx = find_item(p_item);
+			if (idx >= 0)
 				child_items.remove(idx);
 		}
 
-		Canvas() { modulate=Color(1,1,1,1); }
-
+		Canvas() { modulate = Color(1, 1, 1, 1); }
 	};
 
-
 	RID_Owner<Rasterizer::CanvasLight> canvas_light_owner;
 
-
 	struct Viewport {
 
 		RID self;
@@ -503,9 +486,15 @@ class VisualServerRaster : public VisualServer {
 
 			int layer;
 			RID canvas;
-			bool operator<(const CanvasKey& p_canvas) const { if (layer==p_canvas.layer) return canvas < p_canvas.canvas; return layer<p_canvas.layer; }
-			CanvasKey() { layer=0; }
-			CanvasKey(const RID& p_canvas, int p_layer) { canvas=p_canvas; layer=p_layer; }
+			bool operator<(const CanvasKey &p_canvas) const {
+				if (layer == p_canvas.layer) return canvas < p_canvas.canvas;
+				return layer < p_canvas.layer;
+			}
+			CanvasKey() { layer = 0; }
+			CanvasKey(const RID &p_canvas, int p_layer) {
+				canvas = p_canvas;
+				layer = p_layer;
+			}
 		};
 
 		struct CanvasData {
@@ -517,26 +506,34 @@ class VisualServerRaster : public VisualServer {
 
 		Matrix32 global_transform;
 
-		Map<RID,CanvasData> canvas_map;
+		Map<RID, CanvasData> canvas_map;
 
 		SelfList<Viewport> update_list;
 
-		Viewport() : update_list(this) { transparent_bg=false; render_target_update_mode=RENDER_TARGET_UPDATE_WHEN_VISIBLE; queue_capture=false; rendered_in_prev_frame=false; render_target_vflip=false; render_target_clear_on_new_frame=true; render_target_clear=true; disable_environment=false; }
+		Viewport()
+			: update_list(this) {
+			transparent_bg = false;
+			render_target_update_mode = RENDER_TARGET_UPDATE_WHEN_VISIBLE;
+			queue_capture = false;
+			rendered_in_prev_frame = false;
+			render_target_vflip = false;
+			render_target_clear_on_new_frame = true;
+			render_target_clear = true;
+			disable_environment = false;
+		}
 	};
 
 	SelfList<Viewport>::List viewport_update_list;
 
-	Map<RID,int> screen_viewports;
+	Map<RID, int> screen_viewports;
 
 	struct CullRange {
 
 		Plane nearp;
-		float min,max;
-		float z_near,z_far;
-
-		void add_aabb(const AABB& p_aabb) {
-
+		float min, max;
+		float z_near, z_far;
 
+		void add_aabb(const AABB &p_aabb) {
 		}
 	};
 
@@ -561,8 +558,8 @@ class VisualServerRaster : public VisualServer {
 	Cursor cursors[MAX_CURSORS];
 	RID default_cursor_texture;
 
-	static void* instance_pair(void *p_self, OctreeElementID,Instance *p_A,int, OctreeElementID,Instance *p_B,int);
-	static void instance_unpair(void *p_self, OctreeElementID,Instance *p_A,int, OctreeElementID,Instance *p_B,int,void*);
+	static void *instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int);
+	static void instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *);
 
 	Instance *instance_cull_result[MAX_INSTANCE_CULL];
 	Instance *instance_shadow_cull_result[MAX_INSTANCE_CULL]; //used for generating shadowmaps
@@ -589,15 +586,15 @@ class VisualServerRaster : public VisualServer {
 
 	void _instance_validate_autorooms(Instance *p_geometry);
 
-	void _portal_disconnect(Instance *p_portal,bool p_cleanup=false);
+	void _portal_disconnect(Instance *p_portal, bool p_cleanup = false);
 	void _portal_attempt_connect(Instance *p_portal);
-	void _dependency_queue_update(RID p_rid, bool p_update_aabb=false, bool p_update_materials=false);
-	_FORCE_INLINE_ void _instance_queue_update(Instance *p_instance,bool p_update_aabb=false,bool p_update_materials=false);
+	void _dependency_queue_update(RID p_rid, bool p_update_aabb = false, bool p_update_materials = false);
+	_FORCE_INLINE_ void _instance_queue_update(Instance *p_instance, bool p_update_aabb = false, bool p_update_materials = false);
 	void _update_instances();
 	void _update_instance_aabb(Instance *p_instance);
 	void _update_instance(Instance *p_instance);
-	void _free_attached_instances(RID p_rid,bool p_free_scenario=false);
-	void _clean_up_owner(RID_OwnerBase *p_owner,String p_type);
+	void _free_attached_instances(RID p_rid, bool p_free_scenario = false);
+	void _clean_up_owner(RID_OwnerBase *p_owner, String p_type);
 
 	Instance *instance_update_list;
 
@@ -606,7 +603,6 @@ class VisualServerRaster : public VisualServer {
 
 	RID test_cube;
 
-
 	mutable RID_Owner<Room> room_owner;
 	mutable RID_Owner<Portal> portal_owner;
 
@@ -622,85 +618,81 @@ class VisualServerRaster : public VisualServer {
 	mutable RID_Owner<Canvas> canvas_owner;
 	mutable RID_Owner<CanvasItem> canvas_item_owner;
 
-	Map< RID, Set<RID> > instance_dependency_map;
-	Map< RID, Set<Instance*> > skeleton_dependency_map;
-
+	Map<RID, Set<RID> > instance_dependency_map;
+	Map<RID, Set<Instance *> > skeleton_dependency_map;
 
 	ViewportRect viewport_rect;
 	_FORCE_INLINE_ void _instance_draw(Instance *p_instance);
 
 	bool _test_portal_cull(Camera *p_camera, Instance *p_portal_from, Instance *p_portal_to);
-	void _cull_portal(Camera *p_camera, Instance *p_portal,Instance *p_from_portal);
-	void _cull_room(Camera *p_camera, Instance *p_room,Instance *p_from_portal=NULL);
+	void _cull_portal(Camera *p_camera, Instance *p_portal, Instance *p_from_portal);
+	void _cull_room(Camera *p_camera, Instance *p_room, Instance *p_from_portal = NULL);
 	void _process_sampled_light(const Transform &p_camera, Instance *p_sampled_light, bool p_linear_colorspace);
 
-	void _render_no_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario);
-	void _render_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario);
-	static void _render_canvas_item_viewport(VisualServer* p_self,void *p_vp,const Rect2& p_rect);
-	void _render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32& p_transform, const Rect2& p_clip_rect, const Color &p_modulate, Rasterizer::CanvasLight *p_lights);
-	void _render_canvas_item(CanvasItem *p_canvas_item, const Matrix32& p_transform, const Rect2& p_clip_rect, float p_opacity, int p_z, Rasterizer::CanvasItem **z_list, Rasterizer::CanvasItem **z_last_list, CanvasItem *p_canvas_clip, CanvasItem *p_material_owner);
+	void _render_no_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario);
+	void _render_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario);
+	static void _render_canvas_item_viewport(VisualServer *p_self, void *p_vp, const Rect2 &p_rect);
+	void _render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, Rasterizer::CanvasLight *p_lights);
+	void _render_canvas_item(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, float p_opacity, int p_z, Rasterizer::CanvasItem **z_list, Rasterizer::CanvasItem **z_last_list, CanvasItem *p_canvas_clip, CanvasItem *p_material_owner);
 	void _render_canvas(Canvas *p_canvas, const Matrix32 &p_transform, Rasterizer::CanvasLight *p_lights, Rasterizer::CanvasLight *p_masked_lights);
-	void _light_mask_canvas_items(int p_z,Rasterizer::CanvasItem *p_canvas_item,Rasterizer::CanvasLight *p_masked_lights);
+	void _light_mask_canvas_items(int p_z, Rasterizer::CanvasItem *p_canvas_item, Rasterizer::CanvasLight *p_masked_lights);
 
-	Vector<Vector3> _camera_generate_endpoints(Instance *p_light,Camera *p_camera,float p_range_min, float p_range_max);
-	Vector<Plane> _camera_generate_orthogonal_planes(Instance *p_light,Camera *p_camera,float p_range_min, float p_range_max);
+	Vector<Vector3> _camera_generate_endpoints(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max);
+	Vector<Plane> _camera_generate_orthogonal_planes(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max);
 
-	void _light_instance_update_lispsm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range);
-	void _light_instance_update_pssm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range);
+	void _light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range);
+	void _light_instance_update_pssm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range);
 
-	void _light_instance_update_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range);
+	void _light_instance_update_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range);
 
 	uint64_t render_pass;
 	int changes;
 	bool draw_extra_frame;
 
 	void _draw_viewport_camera(Viewport *p_viewport, bool p_ignore_camera);
-	void _draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_ofs_y,int p_parent_w,int p_parent_h);
+	void _draw_viewport(Viewport *p_viewport, int p_ofs_x, int p_ofs_y, int p_parent_w, int p_parent_h);
 	void _draw_viewports();
 	void _draw_cursors_and_margins();
 
-
 	Rasterizer *rasterizer;
-public:
 
+public:
 	virtual RID texture_create();
-	virtual void texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags=TEXTURE_FLAGS_DEFAULT);
-	virtual void texture_set_data(RID p_texture,const Image& p_image,CubeMapSide p_cube_side=CUBEMAP_LEFT);
-	virtual Image texture_get_data(RID p_texture,CubeMapSide p_cube_side=CUBEMAP_LEFT) const;
-	virtual void texture_set_flags(RID p_texture,uint32_t p_flags) ;
+	virtual void texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags = TEXTURE_FLAGS_DEFAULT);
+	virtual void texture_set_data(RID p_texture, const Image &p_image, CubeMapSide p_cube_side = CUBEMAP_LEFT);
+	virtual Image texture_get_data(RID p_texture, CubeMapSide p_cube_side = CUBEMAP_LEFT) const;
+	virtual void texture_set_flags(RID p_texture, uint32_t p_flags);
 	virtual uint32_t texture_get_flags(RID p_texture) const;
 	virtual Image::Format texture_get_format(RID p_texture) const;
 	virtual uint32_t texture_get_width(RID p_texture) const;
 	virtual uint32_t texture_get_height(RID p_texture) const;
-	virtual void texture_set_size_override(RID p_texture,int p_width, int p_height);
+	virtual void texture_set_size_override(RID p_texture, int p_width, int p_height);
 	virtual bool texture_can_stream(RID p_texture) const;
-	virtual void texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName& p_function) const;
+	virtual void texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function) const;
 
-	virtual void texture_set_path(RID p_texture,const String& p_path);
+	virtual void texture_set_path(RID p_texture, const String &p_path);
 	virtual String texture_get_path(RID p_texture) const;
 
 	virtual void texture_debug_usage(List<TextureInfo> *r_info);
 
 	virtual void texture_set_shrink_all_x2_on_set_data(bool p_enable);
 
-
 	/* SHADER API */
 
-	virtual RID shader_create(ShaderMode p_mode=SHADER_MATERIAL);
+	virtual RID shader_create(ShaderMode p_mode = SHADER_MATERIAL);
 
-	virtual void shader_set_mode(RID p_shader,ShaderMode p_mode);
+	virtual void shader_set_mode(RID p_shader, ShaderMode p_mode);
 	virtual ShaderMode shader_get_mode(RID p_shader) const;
 
-	virtual void shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs=0,int p_fragment_ofs=0,int p_light_ofs=0);
+	virtual void shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs = 0, int p_fragment_ofs = 0, int p_light_ofs = 0);
 	virtual String shader_get_vertex_code(RID p_shader) const;
 	virtual String shader_get_fragment_code(RID p_shader) const;
 	virtual String shader_get_light_code(RID p_shader) const;
 
 	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
 
-	virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture);
-	virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const;
-
+	virtual void shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture);
+	virtual RID shader_get_default_texture_param(RID p_shader, const StringName &p_name) const;
 
 	/* COMMON MATERIAL API */
 
@@ -709,64 +701,62 @@ public:
 	virtual void material_set_shader(RID p_shader_material, RID p_shader);
 	virtual RID material_get_shader(RID p_shader_material) const;
 
-	virtual void material_set_param(RID p_material, const StringName& p_param, const Variant& p_value);
-	virtual Variant material_get_param(RID p_material, const StringName& p_param) const;
+	virtual void material_set_param(RID p_material, const StringName &p_param, const Variant &p_value);
+	virtual Variant material_get_param(RID p_material, const StringName &p_param) const;
 
-	virtual void material_set_flag(RID p_material, MaterialFlag p_flag,bool p_enabled);
-	virtual bool material_get_flag(RID p_material,MaterialFlag p_flag) const;
+	virtual void material_set_flag(RID p_material, MaterialFlag p_flag, bool p_enabled);
+	virtual bool material_get_flag(RID p_material, MaterialFlag p_flag) const;
 
 	virtual void material_set_depth_draw_mode(RID p_material, MaterialDepthDrawMode p_mode);
 	virtual MaterialDepthDrawMode material_get_depth_draw_mode(RID p_material) const;
 
-	virtual void material_set_blend_mode(RID p_material,MaterialBlendMode p_mode);
+	virtual void material_set_blend_mode(RID p_material, MaterialBlendMode p_mode);
 	virtual MaterialBlendMode material_get_blend_mode(RID p_material) const;
 
-	virtual void material_set_line_width(RID p_material,float p_line_width);
+	virtual void material_set_line_width(RID p_material, float p_line_width);
 	virtual float material_get_line_width(RID p_material) const;
 
 	/* FIXED MATERIAL */
 
-
 	virtual RID fixed_material_create();
 
 	virtual void fixed_material_set_flag(RID p_material, FixedMaterialFlags p_flag, bool p_enabled);
 	virtual bool fixed_material_get_flag(RID p_material, FixedMaterialFlags p_flag) const;
 
-	virtual void fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant& p_value);
-	virtual Variant fixed_material_get_param(RID p_material,FixedMaterialParam p_parameter) const;
-
-	virtual void fixed_material_set_texture(RID p_material,FixedMaterialParam p_parameter, RID p_texture);
-	virtual RID fixed_material_get_texture(RID p_material,FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant &p_value);
+	virtual Variant fixed_material_get_param(RID p_material, FixedMaterialParam p_parameter) const;
 
-	virtual void fixed_material_set_texcoord_mode(RID p_material,FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode);
-	virtual FixedMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material,FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_texture(RID p_material, FixedMaterialParam p_parameter, RID p_texture);
+	virtual RID fixed_material_get_texture(RID p_material, FixedMaterialParam p_parameter) const;
 
+	virtual void fixed_material_set_texcoord_mode(RID p_material, FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode);
+	virtual FixedMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material, FixedMaterialParam p_parameter) const;
 
-	virtual void fixed_material_set_uv_transform(RID p_material,const Transform& p_transform);
+	virtual void fixed_material_set_uv_transform(RID p_material, const Transform &p_transform);
 	virtual Transform fixed_material_get_uv_transform(RID p_material) const;
 
-	virtual void fixed_material_set_light_shader(RID p_material,FixedMaterialLightShader p_shader);
+	virtual void fixed_material_set_light_shader(RID p_material, FixedMaterialLightShader p_shader);
 	virtual FixedMaterialLightShader fixed_material_get_light_shader(RID p_material) const;
 
-	virtual void fixed_material_set_point_size(RID p_material,float p_size);
+	virtual void fixed_material_set_point_size(RID p_material, float p_size);
 	virtual float fixed_material_get_point_size(RID p_material) const;
 
 	/* SURFACE API */
 	virtual RID mesh_create();
 
-	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount);
+	virtual void mesh_set_morph_target_count(RID p_mesh, int p_amount);
 	virtual int mesh_get_morph_target_count(RID p_mesh) const;
 
-	virtual void mesh_set_morph_target_mode(RID p_mesh,MorphTargetMode p_mode);
+	virtual void mesh_set_morph_target_mode(RID p_mesh, MorphTargetMode p_mode);
 	virtual MorphTargetMode mesh_get_morph_target_mode(RID p_mesh) const;
 
-	virtual void mesh_add_custom_surface(RID p_mesh,const Variant& p_dat); //this is used by each platform in a different way
+	virtual void mesh_add_custom_surface(RID p_mesh, const Variant &p_dat); //this is used by each platform in a different way
 
-	virtual void mesh_add_surface(RID p_mesh,PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes=Array(),bool p_alpha_sort=false);
-	virtual Array mesh_get_surface_arrays(RID p_mesh,int p_surface) const;
-	virtual Array mesh_get_surface_morph_arrays(RID p_mesh,int p_surface) const;
+	virtual void mesh_add_surface(RID p_mesh, PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes = Array(), bool p_alpha_sort = false);
+	virtual Array mesh_get_surface_arrays(RID p_mesh, int p_surface) const;
+	virtual Array mesh_get_surface_morph_arrays(RID p_mesh, int p_surface) const;
 
-	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material,bool p_owned=false);
+	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned = false);
 	virtual RID mesh_surface_get_material(RID p_mesh, int p_surface) const;
 
 	virtual int mesh_surface_get_array_len(RID p_mesh, int p_surface) const;
@@ -774,10 +764,10 @@ public:
 	virtual uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const;
 	virtual PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const;
 
-	virtual void mesh_remove_surface(RID p_mesh,int p_index);
+	virtual void mesh_remove_surface(RID p_mesh, int p_index);
 	virtual int mesh_get_surface_count(RID p_mesh) const;
 
-	virtual void mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb);
+	virtual void mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb);
 	virtual AABB mesh_get_custom_aabb(RID p_mesh) const;
 
 	virtual void mesh_clear(RID p_mesh);
@@ -785,38 +775,37 @@ public:
 	/* MULTIMESH API */
 
 	virtual RID multimesh_create();
-	virtual void multimesh_set_instance_count(RID p_multimesh,int p_count);
+	virtual void multimesh_set_instance_count(RID p_multimesh, int p_count);
 	virtual int multimesh_get_instance_count(RID p_multimesh) const;
 
-	virtual void multimesh_set_mesh(RID p_multimesh,RID p_mesh);
-	virtual void multimesh_set_aabb(RID p_multimesh,const AABB& p_aabb);
-	virtual void multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform);
-	virtual void multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color);
+	virtual void multimesh_set_mesh(RID p_multimesh, RID p_mesh);
+	virtual void multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb);
+	virtual void multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform);
+	virtual void multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color);
 
 	virtual RID multimesh_get_mesh(RID p_multimesh) const;
-	virtual AABB multimesh_get_aabb(RID p_multimesh,const AABB& p_aabb) const;
-	virtual Transform multimesh_instance_get_transform(RID p_multimesh,int p_index) const;
-	virtual Color multimesh_instance_get_color(RID p_multimesh,int p_index) const;
+	virtual AABB multimesh_get_aabb(RID p_multimesh, const AABB &p_aabb) const;
+	virtual Transform multimesh_instance_get_transform(RID p_multimesh, int p_index) const;
+	virtual Color multimesh_instance_get_color(RID p_multimesh, int p_index) const;
 
-	virtual void multimesh_set_visible_instances(RID p_multimesh,int p_visible);
+	virtual void multimesh_set_visible_instances(RID p_multimesh, int p_visible);
 	virtual int multimesh_get_visible_instances(RID p_multimesh) const;
 
 	/* IMMEDIATE API */
 
 	virtual RID immediate_create();
-	virtual void immediate_begin(RID p_immediate,PrimitiveType p_rimitive,RID p_texture=RID());
-	virtual void immediate_vertex(RID p_immediate,const Vector3& p_vertex);
-	virtual void immediate_normal(RID p_immediate,const Vector3& p_normal);
-	virtual void immediate_tangent(RID p_immediate,const Plane& p_tangent);
-	virtual void immediate_color(RID p_immediate,const Color& p_color);
-	virtual void immediate_uv(RID p_immediate, const Vector2& p_uv);
-	virtual void immediate_uv2(RID p_immediate,const Vector2& tex_uv);
+	virtual void immediate_begin(RID p_immediate, PrimitiveType p_rimitive, RID p_texture = RID());
+	virtual void immediate_vertex(RID p_immediate, const Vector3 &p_vertex);
+	virtual void immediate_normal(RID p_immediate, const Vector3 &p_normal);
+	virtual void immediate_tangent(RID p_immediate, const Plane &p_tangent);
+	virtual void immediate_color(RID p_immediate, const Color &p_color);
+	virtual void immediate_uv(RID p_immediate, const Vector2 &p_uv);
+	virtual void immediate_uv2(RID p_immediate, const Vector2 &tex_uv);
 	virtual void immediate_end(RID p_immediate);
 	virtual void immediate_clear(RID p_immediate);
-	virtual void immediate_set_material(RID p_immediate,RID p_material);
+	virtual void immediate_set_material(RID p_immediate, RID p_material);
 	virtual RID immediate_get_material(RID p_immediate) const;
 
-
 	/* PARTICLES API */
 
 	virtual RID particles_create();
@@ -827,25 +816,25 @@ public:
 	virtual void particles_set_emitting(RID p_particles, bool p_emitting);
 	virtual bool particles_is_emitting(RID p_particles) const;
 
-	virtual void particles_set_visibility_aabb(RID p_particles, const AABB& p_visibility);
+	virtual void particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility);
 	virtual AABB particles_get_visibility_aabb(RID p_particles) const;
 
-	virtual void particles_set_emission_half_extents(RID p_particles, const Vector3& p_half_extents);
+	virtual void particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents);
 	virtual Vector3 particles_get_emission_half_extents(RID p_particles) const;
 
-	virtual void particles_set_emission_base_velocity(RID p_particles, const Vector3& p_base_velocity);
+	virtual void particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity);
 	virtual Vector3 particles_get_emission_base_velocity(RID p_particles) const;
 
-	virtual void particles_set_emission_points(RID p_particles, const DVector<Vector3>& p_points);
+	virtual void particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points);
 	virtual DVector<Vector3> particles_get_emission_points(RID p_particles) const;
 
-	virtual void particles_set_gravity_normal(RID p_particles, const Vector3& p_normal);
+	virtual void particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal);
 	virtual Vector3 particles_get_gravity_normal(RID p_particles) const;
 
-	virtual void particles_set_variable(RID p_particles, ParticleVariable p_variable,float p_value);
+	virtual void particles_set_variable(RID p_particles, ParticleVariable p_variable, float p_value);
 	virtual float particles_get_variable(RID p_particles, ParticleVariable p_variable) const;
 
-	virtual void particles_set_randomness(RID p_particles, ParticleVariable p_variable,float p_randomness);
+	virtual void particles_set_randomness(RID p_particles, ParticleVariable p_variable, float p_randomness);
 	virtual float particles_get_randomness(RID p_particles, ParticleVariable p_variable) const;
 
 	virtual void particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos);
@@ -854,19 +843,19 @@ public:
 	virtual void particles_set_color_phases(RID p_particles, int p_phases);
 	virtual int particles_get_color_phases(RID p_particles) const;
 
-	virtual void particles_set_color_phase_color(RID p_particles, int p_phase, const Color& p_color);
+	virtual void particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color);
 	virtual Color particles_get_color_phase_color(RID p_particles, int p_phase) const;
 
 	virtual void particles_set_attractors(RID p_particles, int p_attractors);
 	virtual int particles_get_attractors(RID p_particles) const;
 
-	virtual void particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3& p_pos);
-	virtual Vector3 particles_get_attractor_pos(RID p_particles,int p_attractor) const;
+	virtual void particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos);
+	virtual Vector3 particles_get_attractor_pos(RID p_particles, int p_attractor) const;
 
 	virtual void particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force);
-	virtual float particles_get_attractor_strength(RID p_particles,int p_attractor) const;
+	virtual float particles_get_attractor_strength(RID p_particles, int p_attractor) const;
 
-	virtual void particles_set_material(RID p_particles, RID p_material,bool p_owned=false);
+	virtual void particles_set_material(RID p_particles, RID p_material, bool p_owned = false);
 	virtual RID particles_get_material(RID p_particles) const;
 
 	virtual void particles_set_height_from_velocity(RID p_particles, bool p_enable);
@@ -875,64 +864,61 @@ public:
 	virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable);
 	virtual bool particles_is_using_local_coordinates(RID p_particles) const;
 
-
 	/* Light API */
 
 	virtual RID light_create(LightType p_type);
 	virtual LightType light_get_type(RID p_light) const;
 
-	virtual void light_set_color(RID p_light,LightColor p_type, const Color& p_color);
-	virtual Color light_get_color(RID p_light,LightColor p_type) const;
-
+	virtual void light_set_color(RID p_light, LightColor p_type, const Color &p_color);
+	virtual Color light_get_color(RID p_light, LightColor p_type) const;
 
-	virtual void light_set_shadow(RID p_light,bool p_enabled);
+	virtual void light_set_shadow(RID p_light, bool p_enabled);
 	virtual bool light_has_shadow(RID p_light) const;
 
-	virtual void light_set_volumetric(RID p_light,bool p_enabled);
+	virtual void light_set_volumetric(RID p_light, bool p_enabled);
 	virtual bool light_is_volumetric(RID p_light) const;
 
-	virtual void light_set_projector(RID p_light,RID p_texture);
+	virtual void light_set_projector(RID p_light, RID p_texture);
 	virtual RID light_get_projector(RID p_light) const;
 
 	virtual void light_set_param(RID p_light, LightParam p_var, float p_value);
 	virtual float light_get_param(RID p_light, LightParam p_var) const;
 
-	virtual void light_set_operator(RID p_light,LightOp p_op);
+	virtual void light_set_operator(RID p_light, LightOp p_op);
 	virtual LightOp light_get_operator(RID p_light) const;
 
-	virtual void light_omni_set_shadow_mode(RID p_light,LightOmniShadowMode p_mode);
+	virtual void light_omni_set_shadow_mode(RID p_light, LightOmniShadowMode p_mode);
 	virtual LightOmniShadowMode light_omni_get_shadow_mode(RID p_light) const;
 
-	virtual void light_directional_set_shadow_mode(RID p_light,LightDirectionalShadowMode p_mode);
+	virtual void light_directional_set_shadow_mode(RID p_light, LightDirectionalShadowMode p_mode);
 	virtual LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light) const;
-	virtual void light_directional_set_shadow_param(RID p_light,LightDirectionalShadowParam p_param, float p_value);
-	virtual float light_directional_get_shadow_param(RID p_light,LightDirectionalShadowParam p_param) const;
-
+	virtual void light_directional_set_shadow_param(RID p_light, LightDirectionalShadowParam p_param, float p_value);
+	virtual float light_directional_get_shadow_param(RID p_light, LightDirectionalShadowParam p_param) const;
 
 	/* SKELETON API */
 
 	virtual RID skeleton_create();
-	virtual void skeleton_resize(RID p_skeleton,int p_bones);
+	virtual void skeleton_resize(RID p_skeleton, int p_bones);
 	virtual int skeleton_get_bone_count(RID p_skeleton) const;
-	virtual void skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform);
-	virtual Transform skeleton_bone_get_transform(RID p_skeleton,int p_bone);
+	virtual void skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform);
+	virtual Transform skeleton_bone_get_transform(RID p_skeleton, int p_bone);
 
 	/* ROOM API */
 
 	virtual RID room_create();
-	virtual void room_set_bounds(RID p_room, const BSP_Tree& p_bounds);
+	virtual void room_set_bounds(RID p_room, const BSP_Tree &p_bounds);
 	virtual BSP_Tree room_get_bounds(RID p_room) const;
 
 	/* PORTAL API */
 
 	virtual RID portal_create();
-	virtual void portal_set_shape(RID p_portal, const Vector<Point2>& p_shape);
+	virtual void portal_set_shape(RID p_portal, const Vector<Point2> &p_shape);
 	virtual Vector<Point2> portal_get_shape(RID p_portal) const;
 	virtual void portal_set_enabled(RID p_portal, bool p_enabled);
 	virtual bool portal_is_enabled(RID p_portal) const;
 	virtual void portal_set_disable_distance(RID p_portal, float p_distance);
 	virtual float portal_get_disable_distance(RID p_portal) const;
-	virtual void portal_set_disabled_color(RID p_portal, const Color& p_color);
+	virtual void portal_set_disabled_color(RID p_portal, const Color &p_color);
 	virtual Color portal_get_disabled_color(RID p_portal) const;
 	virtual void portal_set_connect_range(RID p_portal, float p_range);
 	virtual float portal_get_connect_range(RID p_portal) const;
@@ -941,28 +927,28 @@ public:
 
 	virtual RID baked_light_create();
 
-	virtual void baked_light_set_mode(RID p_baked_light,BakedLightMode p_mode);
+	virtual void baked_light_set_mode(RID p_baked_light, BakedLightMode p_mode);
 	virtual BakedLightMode baked_light_get_mode(RID p_baked_light) const;
 
-	virtual void baked_light_set_octree(RID p_baked_light,const DVector<uint8_t> p_octree);
+	virtual void baked_light_set_octree(RID p_baked_light, const DVector<uint8_t> p_octree);
 	virtual DVector<uint8_t> baked_light_get_octree(RID p_baked_light) const;
 
-	virtual void baked_light_set_light(RID p_baked_light,const DVector<uint8_t> p_light);
+	virtual void baked_light_set_light(RID p_baked_light, const DVector<uint8_t> p_light);
 	virtual DVector<uint8_t> baked_light_get_light(RID p_baked_light) const;
 
-	virtual void baked_light_set_sampler_octree(RID p_baked_light,const DVector<int> &p_sampler);
+	virtual void baked_light_set_sampler_octree(RID p_baked_light, const DVector<int> &p_sampler);
 	virtual DVector<int> baked_light_get_sampler_octree(RID p_baked_light) const;
 
-	virtual void baked_light_set_lightmap_multiplier(RID p_baked_light,float p_multiplier);
+	virtual void baked_light_set_lightmap_multiplier(RID p_baked_light, float p_multiplier);
 	virtual float baked_light_get_lightmap_multiplier(RID p_baked_light) const;
 
-	virtual void baked_light_add_lightmap(RID p_baked_light,const RID p_texture,int p_id);
+	virtual void baked_light_add_lightmap(RID p_baked_light, const RID p_texture, int p_id);
 	virtual void baked_light_clear_lightmaps(RID p_baked_light);
 
 	virtual void baked_light_set_realtime_color_enabled(RID p_baked_light, const bool p_enabled);
 	virtual bool baked_light_get_realtime_color_enabled(RID p_baked_light) const;
 
-	virtual void baked_light_set_realtime_color(RID p_baked_light, const Color& p_color);
+	virtual void baked_light_set_realtime_color(RID p_baked_light, const Color &p_color);
 	virtual Color baked_light_get_realtime_color(RID p_baked_light) const;
 
 	virtual void baked_light_set_realtime_energy(RID p_baked_light, const float p_energy);
@@ -972,101 +958,95 @@ public:
 
 	virtual RID baked_light_sampler_create();
 
-	virtual void baked_light_sampler_set_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param,float p_value);
-	virtual float baked_light_sampler_get_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param) const;
+	virtual void baked_light_sampler_set_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param, float p_value);
+	virtual float baked_light_sampler_get_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param) const;
 
-	virtual void baked_light_sampler_set_resolution(RID p_baked_light_sampler,int p_resolution);
+	virtual void baked_light_sampler_set_resolution(RID p_baked_light_sampler, int p_resolution);
 	virtual int baked_light_sampler_get_resolution(RID p_baked_light_sampler) const;
 
 	/* CAMERA API */
 
 	virtual RID camera_create();
-	virtual void camera_set_perspective(RID p_camera,float p_fovy_degrees, float p_z_near, float p_z_far);
-	virtual void camera_set_orthogonal(RID p_camera,float p_size, float p_z_near, float p_z_far);
-	virtual void camera_set_transform(RID p_camera,const Transform& p_transform);
+	virtual void camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far);
+	virtual void camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far);
+	virtual void camera_set_transform(RID p_camera, const Transform &p_transform);
 
-	virtual void camera_set_visible_layers(RID p_camera,uint32_t p_layers);
+	virtual void camera_set_visible_layers(RID p_camera, uint32_t p_layers);
 	virtual uint32_t camera_get_visible_layers(RID p_camera) const;
 
-	virtual void camera_set_environment(RID p_camera,RID p_env);
+	virtual void camera_set_environment(RID p_camera, RID p_env);
 	virtual RID camera_get_environment(RID p_camera) const;
 
-	virtual void camera_set_use_vertical_aspect(RID p_camera,bool p_enable);
-	virtual bool camera_is_using_vertical_aspect(RID p_camera,bool p_enable) const;
+	virtual void camera_set_use_vertical_aspect(RID p_camera, bool p_enable);
+	virtual bool camera_is_using_vertical_aspect(RID p_camera, bool p_enable) const;
 
 	/* VIEWPORT API */
 
 	virtual RID viewport_create();
 
-	virtual void viewport_attach_to_screen(RID p_viewport,int p_screen=0);
+	virtual void viewport_attach_to_screen(RID p_viewport, int p_screen = 0);
 	virtual void viewport_detach(RID p_viewport);
 
-	virtual void viewport_set_as_render_target(RID p_viewport,bool p_enable);
-	virtual void viewport_set_render_target_update_mode(RID p_viewport,RenderTargetUpdateMode p_mode);
+	virtual void viewport_set_as_render_target(RID p_viewport, bool p_enable);
+	virtual void viewport_set_render_target_update_mode(RID p_viewport, RenderTargetUpdateMode p_mode);
 	virtual RenderTargetUpdateMode viewport_get_render_target_update_mode(RID p_viewport) const;
 	virtual RID viewport_get_render_target_texture(RID p_viewport) const;
-	virtual void viewport_set_render_target_vflip(RID p_viewport,bool p_enable);
+	virtual void viewport_set_render_target_vflip(RID p_viewport, bool p_enable);
 	virtual bool viewport_get_render_target_vflip(RID p_viewport) const;
-	virtual void viewport_set_render_target_clear_on_new_frame(RID p_viewport,bool p_enable);
+	virtual void viewport_set_render_target_clear_on_new_frame(RID p_viewport, bool p_enable);
 	virtual bool viewport_get_render_target_clear_on_new_frame(RID p_viewport) const;
 	virtual void viewport_render_target_clear(RID p_viewport);
-	virtual void viewport_set_render_target_to_screen_rect(RID p_viewport,const Rect2& p_rect);
-
+	virtual void viewport_set_render_target_to_screen_rect(RID p_viewport, const Rect2 &p_rect);
 
 	virtual void viewport_queue_screen_capture(RID p_viewport);
 	virtual Image viewport_get_screen_capture(RID p_viewport) const;
 
-	virtual void viewport_set_rect(RID p_viewport,const ViewportRect& p_rect);
+	virtual void viewport_set_rect(RID p_viewport, const ViewportRect &p_rect);
 	virtual ViewportRect viewport_get_rect(RID p_viewport) const;
 
-	virtual void viewport_set_hide_scenario(RID p_viewport,bool p_hide);
-	virtual void viewport_set_hide_canvas(RID p_viewport,bool p_hide);
-	virtual void viewport_set_disable_environment(RID p_viewport,bool p_disable);
-	virtual void viewport_attach_camera(RID p_viewport,RID p_camera);
-	virtual void viewport_set_scenario(RID p_viewport,RID p_scenario);
+	virtual void viewport_set_hide_scenario(RID p_viewport, bool p_hide);
+	virtual void viewport_set_hide_canvas(RID p_viewport, bool p_hide);
+	virtual void viewport_set_disable_environment(RID p_viewport, bool p_disable);
+	virtual void viewport_attach_camera(RID p_viewport, RID p_camera);
+	virtual void viewport_set_scenario(RID p_viewport, RID p_scenario);
 
-	virtual RID viewport_get_attached_camera(RID  p_viewport) const;
-	virtual RID viewport_get_scenario(RID  p_viewport) const;
-	virtual void viewport_attach_canvas(RID p_viewport,RID p_canvas);
-	virtual void viewport_remove_canvas(RID p_viewport,RID p_canvas);
-	virtual void viewport_set_canvas_transform(RID p_viewport,RID p_canvas,const Matrix32& p_offset);
-	virtual Matrix32 viewport_get_canvas_transform(RID p_viewport,RID p_canvas) const;
-	virtual void viewport_set_global_canvas_transform(RID p_viewport,const Matrix32& p_transform);
+	virtual RID viewport_get_attached_camera(RID p_viewport) const;
+	virtual RID viewport_get_scenario(RID p_viewport) const;
+	virtual void viewport_attach_canvas(RID p_viewport, RID p_canvas);
+	virtual void viewport_remove_canvas(RID p_viewport, RID p_canvas);
+	virtual void viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Matrix32 &p_offset);
+	virtual Matrix32 viewport_get_canvas_transform(RID p_viewport, RID p_canvas) const;
+	virtual void viewport_set_global_canvas_transform(RID p_viewport, const Matrix32 &p_transform);
 	virtual Matrix32 viewport_get_global_canvas_transform(RID p_viewport) const;
-	virtual void viewport_set_canvas_layer(RID p_viewport,RID p_canvas,int p_layer);
-	virtual void viewport_set_transparent_background(RID p_viewport,bool p_enabled);
+	virtual void viewport_set_canvas_layer(RID p_viewport, RID p_canvas, int p_layer);
+	virtual void viewport_set_transparent_background(RID p_viewport, bool p_enabled);
 	virtual bool viewport_has_transparent_background(RID p_viewport) const;
 
-
 	/* ENVIRONMENT API */
 
 	virtual RID environment_create();
 
-	virtual void environment_set_background(RID p_env,EnvironmentBG p_bg);
+	virtual void environment_set_background(RID p_env, EnvironmentBG p_bg);
 	virtual EnvironmentBG environment_get_background(RID p_env) const;
 
-	virtual void environment_set_background_param(RID p_env,EnvironmentBGParam p_param, const Variant& p_value);
-	virtual Variant environment_get_background_param(RID p_env,EnvironmentBGParam p_param) const;
-
-	virtual void environment_set_enable_fx(RID p_env,EnvironmentFx p_effect,bool p_enabled);
-	virtual bool environment_is_fx_enabled(RID p_env,EnvironmentFx p_effect) const;
-
+	virtual void environment_set_background_param(RID p_env, EnvironmentBGParam p_param, const Variant &p_value);
+	virtual Variant environment_get_background_param(RID p_env, EnvironmentBGParam p_param) const;
 
-	virtual void environment_fx_set_param(RID p_env,EnvironmentFxParam p_effect,const Variant& p_param);
-	virtual Variant environment_fx_get_param(RID p_env,EnvironmentFxParam p_effect) const;
+	virtual void environment_set_enable_fx(RID p_env, EnvironmentFx p_effect, bool p_enabled);
+	virtual bool environment_is_fx_enabled(RID p_env, EnvironmentFx p_effect) const;
 
+	virtual void environment_fx_set_param(RID p_env, EnvironmentFxParam p_effect, const Variant &p_param);
+	virtual Variant environment_fx_get_param(RID p_env, EnvironmentFxParam p_effect) const;
 
 	/* SCENARIO API */
 
 	virtual RID scenario_create();
 
-	virtual void scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode);
+	virtual void scenario_set_debug(RID p_scenario, ScenarioDebugMode p_debug_mode);
 	virtual void scenario_set_environment(RID p_scenario, RID p_environment);
 	virtual RID scenario_get_environment(RID p_scenario, RID p_environment) const;
 	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment);
 
-
-
 	/* INSTANCING API */
 
 	virtual RID instance_create();
@@ -1082,36 +1062,35 @@ public:
 
 	virtual AABB instance_get_base_aabb(RID p_instance) const;
 
-	virtual void instance_attach_object_instance_ID(RID p_instance,uint32_t p_ID);
+	virtual void instance_attach_object_instance_ID(RID p_instance, uint32_t p_ID);
 	virtual uint32_t instance_get_object_instance_ID(RID p_instance) const;
 
-	virtual void instance_attach_skeleton(RID p_instance,RID p_skeleton);
+	virtual void instance_attach_skeleton(RID p_instance, RID p_skeleton);
 	virtual RID instance_get_skeleton(RID p_instance) const;
 
-	virtual void instance_set_morph_target_weight(RID p_instance,int p_shape, float p_weight);
-	virtual float instance_get_morph_target_weight(RID p_instance,int p_shape) const;
-
-	virtual void instance_set_surface_material(RID p_instance,int p_surface, RID p_material);
+	virtual void instance_set_morph_target_weight(RID p_instance, int p_shape, float p_weight);
+	virtual float instance_get_morph_target_weight(RID p_instance, int p_shape) const;
 
+	virtual void instance_set_surface_material(RID p_instance, int p_surface, RID p_material);
 
-	virtual void instance_set_transform(RID p_instance, const Transform& p_transform);
+	virtual void instance_set_transform(RID p_instance, const Transform &p_transform);
 	virtual Transform instance_get_transform(RID p_instance) const;
 
-	virtual void instance_set_exterior( RID p_instance, bool p_enabled );
-	virtual bool instance_is_exterior( RID p_instance) const;
+	virtual void instance_set_exterior(RID p_instance, bool p_enabled);
+	virtual bool instance_is_exterior(RID p_instance) const;
 
-	virtual void instance_set_room( RID p_instance, RID p_room );
-	virtual RID instance_get_room( RID p_instance ) const ;
+	virtual void instance_set_room(RID p_instance, RID p_room);
+	virtual RID instance_get_room(RID p_instance) const;
 
-	virtual void instance_set_extra_visibility_margin( RID p_instance, real_t p_margin );
-	virtual real_t instance_get_extra_visibility_margin( RID p_instance ) const;
+	virtual void instance_set_extra_visibility_margin(RID p_instance, real_t p_margin);
+	virtual real_t instance_get_extra_visibility_margin(RID p_instance) const;
 
-	virtual Vector<RID> instances_cull_aabb(const AABB& p_aabb, RID p_scenario=RID()) const;
-	virtual Vector<RID> instances_cull_ray(const Vector3& p_from, const Vector3& p_to, RID p_scenario=RID()) const;
-	virtual Vector<RID> instances_cull_convex(const Vector<Plane>& p_convex, RID p_scenario=RID()) const;
+	virtual Vector<RID> instances_cull_aabb(const AABB &p_aabb, RID p_scenario = RID()) const;
+	virtual Vector<RID> instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario = RID()) const;
+	virtual Vector<RID> instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario = RID()) const;
 
-	virtual void instance_geometry_set_flag(RID p_instance,InstanceFlags p_flags,bool p_enabled);
-	virtual bool instance_geometry_get_flag(RID p_instance,InstanceFlags p_flags) const;
+	virtual void instance_geometry_set_flag(RID p_instance, InstanceFlags p_flags, bool p_enabled);
+	virtual bool instance_geometry_get_flag(RID p_instance, InstanceFlags p_flags) const;
 
 	virtual void instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting);
 	virtual VS::ShadowCastingSetting instance_geometry_get_cast_shadows_setting(RID p_instance) const;
@@ -1119,48 +1098,45 @@ public:
 	virtual void instance_geometry_set_material_override(RID p_instance, RID p_material);
 	virtual RID instance_geometry_get_material_override(RID p_instance) const;
 
-	virtual void instance_geometry_set_draw_range(RID p_instance,float p_min,float p_max);
+	virtual void instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max);
 	virtual float instance_geometry_get_draw_range_max(RID p_instance) const;
 	virtual float instance_geometry_get_draw_range_min(RID p_instance) const;
 
-	virtual void instance_geometry_set_baked_light(RID p_instance,RID p_baked_light);
+	virtual void instance_geometry_set_baked_light(RID p_instance, RID p_baked_light);
 	virtual RID instance_geometry_get_baked_light(RID p_instance) const;
 
-	virtual void instance_geometry_set_baked_light_sampler(RID p_instance,RID p_baked_light_sampler);
+	virtual void instance_geometry_set_baked_light_sampler(RID p_instance, RID p_baked_light_sampler);
 	virtual RID instance_geometry_get_baked_light_sampler(RID p_instance) const;
 
-	virtual void instance_geometry_set_baked_light_texture_index(RID p_instance,int p_tex_id);
+	virtual void instance_geometry_set_baked_light_texture_index(RID p_instance, int p_tex_id);
 	virtual int instance_geometry_get_baked_light_texture_index(RID p_instance) const;
 
-	virtual void instance_light_set_enabled(RID p_instance,bool p_enabled);
+	virtual void instance_light_set_enabled(RID p_instance, bool p_enabled);
 	virtual bool instance_light_is_enabled(RID p_instance) const;
 
 	/* CANVAS (2D) */
 
 	virtual RID canvas_create();
-	virtual void canvas_set_item_mirroring(RID p_canvas,RID p_item,const Point2& p_mirroring);
-	virtual Point2 canvas_get_item_mirroring(RID p_canvas,RID p_item) const;
-	virtual void canvas_set_modulate(RID p_canvas,const Color& p_color);
-
+	virtual void canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring);
+	virtual Point2 canvas_get_item_mirroring(RID p_canvas, RID p_item) const;
+	virtual void canvas_set_modulate(RID p_canvas, const Color &p_color);
 
 	virtual RID canvas_item_create();
 
-	virtual void canvas_item_set_parent(RID p_item,RID p_parent_item);
+	virtual void canvas_item_set_parent(RID p_item, RID p_parent_item);
 	virtual RID canvas_item_get_parent(RID p_canvas_item) const;
 
-	virtual void canvas_item_set_visible(RID p_item,bool p_visible);
+	virtual void canvas_item_set_visible(RID p_item, bool p_visible);
 	virtual bool canvas_item_is_visible(RID p_item) const;
 
-	virtual void canvas_item_set_blend_mode(RID p_canvas_item,MaterialBlendMode p_blend);
-	virtual void canvas_item_set_light_mask(RID p_canvas_item,int p_mask);
-
-
+	virtual void canvas_item_set_blend_mode(RID p_canvas_item, MaterialBlendMode p_blend);
+	virtual void canvas_item_set_light_mask(RID p_canvas_item, int p_mask);
 
 	//virtual void canvas_item_set_rect(RID p_item, const Rect2& p_rect);
-	virtual void canvas_item_set_transform(RID p_item, const Matrix32& p_transform);
+	virtual void canvas_item_set_transform(RID p_item, const Matrix32 &p_transform);
 	virtual void canvas_item_set_clip(RID p_item, bool p_clip);
 	virtual void canvas_item_set_distance_field_mode(RID p_item, bool p_enable);
-	virtual void canvas_item_set_custom_rect(RID p_item, bool p_custom_rect,const Rect2& p_rect=Rect2());
+	virtual void canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect = Rect2());
 	virtual void canvas_item_set_opacity(RID p_item, float p_opacity);
 	virtual float canvas_item_get_opacity(RID p_item, float p_opacity) const;
 	virtual void canvas_item_set_on_top(RID p_item, bool p_on_top);
@@ -1171,39 +1147,39 @@ public:
 
 	virtual void canvas_item_attach_viewport(RID p_item, RID p_viewport);
 
-	virtual void canvas_item_add_line(RID p_item, const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width=1.0);
-	virtual void canvas_item_add_rect(RID p_item, const Rect2& p_rect, const Color& p_color);
-	virtual void canvas_item_add_circle(RID p_item, const Point2& p_pos, float p_radius,const Color& p_color);
-	virtual void canvas_item_add_texture_rect(RID p_item, const Rect2& p_rect, RID p_texture,bool p_tile=false,const Color& p_modulate=Color(1,1,1),bool p_transpose=false);
-	virtual void canvas_item_add_texture_rect_region(RID p_item, const Rect2& p_rect, RID p_texture,const Rect2& p_src_rect,const Color& p_modulate=Color(1,1,1),bool p_transpose=false);
-	virtual void canvas_item_add_style_box(RID p_item, const Rect2& p_rect, const Rect2& p_source, RID p_texture,const Vector2& p_topleft, const Vector2& p_bottomright, bool p_draw_center=true,const Color& p_modulate=Color(1,1,1));
-	virtual void canvas_item_add_primitive(RID p_item, const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture,float p_width=1.0);
-	virtual void canvas_item_add_polygon(RID p_item, const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs=Vector<Point2>(), RID p_texture=RID());
-	virtual void canvas_item_add_triangle_array(RID p_item, const Vector<int>& p_indices, const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs=Vector<Point2>(), RID p_texture=RID(), int p_count=-1);
-	virtual void canvas_item_add_triangle_array_ptr(RID p_item, int p_count, const int* p_indices, const Point2* p_points, const Color* p_colors,const Point2* p_uvs=NULL, RID p_texture=RID());
-	virtual void canvas_item_add_set_transform(RID p_item,const Matrix32& p_transform);
+	virtual void canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width = 1.0);
+	virtual void canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color);
+	virtual void canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color);
+	virtual void canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false);
+	virtual void canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false);
+	virtual void canvas_item_add_style_box(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, bool p_draw_center = true, const Color &p_modulate = Color(1, 1, 1));
+	virtual void canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width = 1.0);
+	virtual void canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), RID p_texture = RID());
+	virtual void canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), RID p_texture = RID(), int p_count = -1);
+	virtual void canvas_item_add_triangle_array_ptr(RID p_item, int p_count, const int *p_indices, const Point2 *p_points, const Color *p_colors, const Point2 *p_uvs = NULL, RID p_texture = RID());
+	virtual void canvas_item_add_set_transform(RID p_item, const Matrix32 &p_transform);
 	virtual void canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend);
 	virtual void canvas_item_add_clip_ignore(RID p_item, bool p_ignore);
 	virtual void canvas_item_set_sort_children_by_y(RID p_item, bool p_enable);
 	virtual void canvas_item_set_z(RID p_item, int p_z);
 	virtual void canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable);
-	virtual void canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable,const Rect2& p_rect);
+	virtual void canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect);
 
 	virtual void canvas_item_set_material(RID p_item, RID p_material);
 	virtual void canvas_item_set_use_parent_material(RID p_item, bool p_enable);
 
 	virtual RID canvas_light_create();
-	virtual void canvas_light_attach_to_canvas(RID p_light,RID p_canvas);
+	virtual void canvas_light_attach_to_canvas(RID p_light, RID p_canvas);
 	virtual void canvas_light_set_enabled(RID p_light, bool p_enabled);
-	virtual void canvas_light_set_transform(RID p_light, const Matrix32& p_transform);
+	virtual void canvas_light_set_transform(RID p_light, const Matrix32 &p_transform);
 	virtual void canvas_light_set_scale(RID p_light, float p_scale);
 	virtual void canvas_light_set_texture(RID p_light, RID p_texture);
-	virtual void canvas_light_set_texture_offset(RID p_light, const Vector2& p_offset);
-	virtual void canvas_light_set_color(RID p_light, const Color& p_color);
+	virtual void canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset);
+	virtual void canvas_light_set_color(RID p_light, const Color &p_color);
 	virtual void canvas_light_set_height(RID p_light, float p_height);
 	virtual void canvas_light_set_energy(RID p_light, float p_energy);
-	virtual void canvas_light_set_z_range(RID p_light, int p_min_z,int p_max_z);
-	virtual void canvas_light_set_layer_range(RID p_light, int p_min_layer,int p_max_layer);
+	virtual void canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z);
+	virtual void canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer);
 	virtual void canvas_light_set_item_mask(RID p_light, int p_mask);
 	virtual void canvas_light_set_item_shadow_mask(RID p_light, int p_mask);
 
@@ -1211,24 +1187,19 @@ public:
 	virtual void canvas_light_set_shadow_enabled(RID p_light, bool p_enabled);
 	virtual void canvas_light_set_shadow_buffer_size(RID p_light, int p_size);
 	virtual void canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier);
-	virtual void canvas_light_set_shadow_color(RID p_light, const Color& p_color);
-
-
+	virtual void canvas_light_set_shadow_color(RID p_light, const Color &p_color);
 
 	virtual RID canvas_light_occluder_create();
-	virtual void canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas);
-	virtual void canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled);
-	virtual void canvas_light_occluder_set_polygon(RID p_occluder,RID p_polygon);
-	virtual void canvas_light_occluder_set_transform(RID p_occluder,const Matrix32& p_xform);
-	virtual void canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask);
-
+	virtual void canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas);
+	virtual void canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled);
+	virtual void canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon);
+	virtual void canvas_light_occluder_set_transform(RID p_occluder, const Matrix32 &p_xform);
+	virtual void canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask);
 
 	virtual RID canvas_occluder_polygon_create();
-	virtual void canvas_occluder_polygon_set_shape(RID p_occluder_polygon,const DVector<Vector2>& p_shape,bool p_close);
-	virtual void canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const DVector<Vector2>& p_shape);
-	virtual void canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,CanvasOccluderPolygonCullMode p_mode);
-
-
+	virtual void canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2> &p_shape, bool p_close);
+	virtual void canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const DVector<Vector2> &p_shape);
+	virtual void canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, CanvasOccluderPolygonCullMode p_mode);
 
 	virtual void canvas_item_clear(RID p_item);
 	virtual void canvas_item_raise(RID p_item);
@@ -1237,17 +1208,15 @@ public:
 
 	virtual RID canvas_item_material_create();
 	virtual void canvas_item_material_set_shader(RID p_material, RID p_shader);
-	virtual void canvas_item_material_set_shader_param(RID p_material, const StringName& p_param, const Variant& p_value);
-	virtual Variant canvas_item_material_get_shader_param(RID p_material, const StringName& p_param) const;
+	virtual void canvas_item_material_set_shader_param(RID p_material, const StringName &p_param, const Variant &p_value);
+	virtual Variant canvas_item_material_get_shader_param(RID p_material, const StringName &p_param) const;
 	virtual void canvas_item_material_set_shading_mode(RID p_material, CanvasItemShadingMode p_mode);
 
-
-
 	/* CURSOR */
 	virtual void cursor_set_rotation(float p_rotation, int p_cursor = 0); // radians
-	virtual void cursor_set_texture(RID p_texture, const Point2 &p_center_offset, int p_cursor=0, const Rect2 &p_region=Rect2());
+	virtual void cursor_set_texture(RID p_texture, const Point2 &p_center_offset, int p_cursor = 0, const Rect2 &p_region = Rect2());
 	virtual void cursor_set_visible(bool p_visible, int p_cursor = 0);
-	virtual void cursor_set_pos(const Point2& p_pos, int p_cursor = 0);
+	virtual void cursor_set_pos(const Point2 &p_pos, int p_cursor = 0);
 
 	/* BLACK BARS */
 
@@ -1256,16 +1225,16 @@ public:
 
 	/* FREE */
 
-	virtual void free( RID p_rid );
+	virtual void free(RID p_rid);
 
 	/* CUSTOM SHADE MODEL */
 
 	virtual void custom_shade_model_set_shader(int p_model, RID p_shader);
 	virtual RID custom_shade_model_get_shader(int p_model) const;
-	virtual void custom_shade_model_set_name(int p_model, const String& p_name);
+	virtual void custom_shade_model_set_name(int p_model, const String &p_name);
 	virtual String custom_shade_model_get_name(int p_model) const;
-	virtual void custom_shade_model_set_param_info(int p_model, const List<PropertyInfo>& p_info);
-	virtual void custom_shade_model_get_param_info(int p_model, List<PropertyInfo>* p_info) const;
+	virtual void custom_shade_model_set_param_info(int p_model, const List<PropertyInfo> &p_info);
+	virtual void custom_shade_model_get_param_info(int p_model, List<PropertyInfo> *p_info) const;
 
 	/* EVENT QUEUING */
 
@@ -1284,13 +1253,12 @@ public:
 
 	RID get_test_cube();
 
-	virtual void set_boot_image(const Image& p_image, const Color& p_color, bool p_scale);
-	virtual void set_default_clear_color(const Color& p_color);
+	virtual void set_boot_image(const Image &p_image, const Color &p_color, bool p_scale);
+	virtual void set_default_clear_color(const Color &p_color);
 	virtual Color get_default_clear_color() const;
 
 	VisualServerRaster(Rasterizer *p_rasterizer);
 	~VisualServerRaster();
-
 };
 
 #endif
diff --git a/servers/visual/visual_server_wrap_mt.cpp b/servers/visual/visual_server_wrap_mt.cpp
index e673158ba..87ccce0fc 100644
--- a/servers/visual/visual_server_wrap_mt.cpp
+++ b/servers/visual/visual_server_wrap_mt.cpp
@@ -27,20 +27,19 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "visual_server_wrap_mt.h"
-#include "os/os.h"
 #include "globals.h"
+#include "os/os.h"
 void VisualServerWrapMT::thread_exit() {
 
-	exit=true;
+	exit = true;
 }
 
 void VisualServerWrapMT::thread_draw() {
 
-
 	draw_mutex->lock();
 
 	draw_pending--;
-	bool draw=(draw_pending==0);// only draw when no more flushes are pending
+	bool draw = (draw_pending == 0); // only draw when no more flushes are pending
 
 	draw_mutex->unlock();
 
@@ -48,41 +47,35 @@ void VisualServerWrapMT::thread_draw() {
 
 		visual_server->draw();
 	}
-
 }
 
 void VisualServerWrapMT::thread_flush() {
 
-
 	draw_mutex->lock();
 
 	draw_pending--;
 
 	draw_mutex->unlock();
-
 }
 
-
-
 void VisualServerWrapMT::_thread_callback(void *_instance) {
 
-	VisualServerWrapMT *vsmt = reinterpret_cast<VisualServerWrapMT*>(_instance);
-
+	VisualServerWrapMT *vsmt = reinterpret_cast<VisualServerWrapMT *>(_instance);
 
 	vsmt->thread_loop();
 }
 
 void VisualServerWrapMT::thread_loop() {
 
-	server_thread=Thread::get_caller_ID();
+	server_thread = Thread::get_caller_ID();
 
 	OS::get_singleton()->make_rendering_thread();
 
 	visual_server->init();
 
-	exit=false;
-	draw_thread_up=true;
-	while(!exit) {
+	exit = false;
+	draw_thread_up = true;
+	while (!exit) {
 		// flush commands one by one, until exit is requested
 		command_queue.wait_and_flush_one();
 	}
@@ -90,10 +83,8 @@ void VisualServerWrapMT::thread_loop() {
 	command_queue.flush_all(); // flush all
 
 	visual_server->finish();
-
 }
 
-
 /* EVENT QUEUING */
 
 void VisualServerWrapMT::sync() {
@@ -113,12 +104,10 @@ void VisualServerWrapMT::sync() {
 
 		command_queue.flush_all(); //flush all pending from other threads
 	}
-
 }
 
 void VisualServerWrapMT::draw() {
 
-
 	if (create_thread) {
 
 		/* TODO: Make it draw
@@ -135,7 +124,6 @@ void VisualServerWrapMT::draw() {
 	}
 }
 
-
 void VisualServerWrapMT::init() {
 
 	if (create_thread) {
@@ -144,10 +132,10 @@ void VisualServerWrapMT::init() {
 		print_line("CREATING RENDER THREAD");
 		OS::get_singleton()->release_rendering_thread();
 		if (create_thread) {
-			thread = Thread::create( _thread_callback, this );
+			thread = Thread::create(_thread_callback, this);
 			print_line("STARTING RENDER THREAD");
 		}
-		while(!draw_thread_up) {
+		while (!draw_thread_up) {
 			OS::get_singleton()->delay_usec(1000);
 		}
 		print_line("DONE RENDER THREAD");
@@ -155,58 +143,50 @@ void VisualServerWrapMT::init() {
 
 		visual_server->init();
 	}
-
 }
 
 void VisualServerWrapMT::finish() {
 
-
 	if (thread) {
 
-		command_queue.push( this, &VisualServerWrapMT::thread_exit);
-		Thread::wait_to_finish( thread );
+		command_queue.push(this, &VisualServerWrapMT::thread_exit);
+		Thread::wait_to_finish(thread);
 		memdelete(thread);
 
-
 		texture_free_cached_ids();
 		mesh_free_cached_ids();
 
-		thread=NULL;
+		thread = NULL;
 	} else {
 		visual_server->finish();
 	}
 
 	if (draw_mutex)
 		memdelete(draw_mutex);
-
 }
 
+VisualServerWrapMT::VisualServerWrapMT(VisualServer *p_contained, bool p_create_thread)
+	: command_queue(p_create_thread) {
 
-VisualServerWrapMT::VisualServerWrapMT(VisualServer* p_contained,bool p_create_thread) : command_queue(p_create_thread) {
-
-	visual_server=p_contained;
-	create_thread=p_create_thread;
-	thread=NULL;
-	draw_mutex=NULL;
-	draw_pending=0;
-	draw_thread_up=false;
-	alloc_mutex=Mutex::create();
-	texture_pool_max_size=GLOBAL_DEF("render/thread_textures_prealloc",5);
-	mesh_pool_max_size=GLOBAL_DEF("core/rid_pool_prealloc",20);
+	visual_server = p_contained;
+	create_thread = p_create_thread;
+	thread = NULL;
+	draw_mutex = NULL;
+	draw_pending = 0;
+	draw_thread_up = false;
+	alloc_mutex = Mutex::create();
+	texture_pool_max_size = GLOBAL_DEF("render/thread_textures_prealloc", 5);
+	mesh_pool_max_size = GLOBAL_DEF("core/rid_pool_prealloc", 20);
 	if (!p_create_thread) {
-		server_thread=Thread::get_caller_ID();
+		server_thread = Thread::get_caller_ID();
 	} else {
-		server_thread=0;
+		server_thread = 0;
 	}
 }
 
-
 VisualServerWrapMT::~VisualServerWrapMT() {
 
 	memdelete(visual_server);
 	memdelete(alloc_mutex);
 	//finish();
-
 }
-
-
diff --git a/servers/visual/visual_server_wrap_mt.h b/servers/visual/visual_server_wrap_mt.h
index e30f5aa12..965f7e670 100644
--- a/servers/visual/visual_server_wrap_mt.h
+++ b/servers/visual/visual_server_wrap_mt.h
@@ -29,10 +29,9 @@
 #ifndef VISUAL_SERVER_WRAP_MT_H
 #define VISUAL_SERVER_WRAP_MT_H
 
-
-#include "servers/visual_server.h"
 #include "command_queue_mt.h"
 #include "os/thread.h"
+#include "servers/visual_server.h"
 
 /**
 	@author Juan Linietsky <reduzio@gmail.com>
@@ -60,8 +59,7 @@ class VisualServerWrapMT : public VisualServer {
 
 	void thread_exit();
 
-	Mutex*alloc_mutex;
-
+	Mutex *alloc_mutex;
 
 	int texture_pool_max_size;
 	List<RID> texture_id_pool;
@@ -72,13 +70,12 @@ class VisualServerWrapMT : public VisualServer {
 //#define DEBUG_SYNC
 
 #ifdef DEBUG_SYNC
-#define SYNC_DEBUG print_line("sync on: "+String(__FUNCTION__));
+#define SYNC_DEBUG print_line("sync on: " + String(__FUNCTION__));
 #else
 #define SYNC_DEBUG
 #endif
 
 public:
-
 #define ServerName VisualServer
 #define ServerNameWrapMT VisualServerWrapMT
 #define server_name visual_server
@@ -86,43 +83,41 @@ public:
 
 	//FUNC0R(RID,texture_create);
 	FUNCRID(texture);
-	FUNC5(texture_allocate,RID,int,int,Image::Format,uint32_t);
-	FUNC3(texture_set_data,RID,const Image&,CubeMapSide);
-	FUNC2RC(Image,texture_get_data,RID,CubeMapSide);
-	FUNC2(texture_set_flags,RID,uint32_t);
-	FUNC1RC(Image::Format,texture_get_format,RID);
-	FUNC1RC(uint32_t,texture_get_flags,RID);
-	FUNC1RC(uint32_t,texture_get_width,RID);
-	FUNC1RC(uint32_t,texture_get_height,RID);
-	FUNC3(texture_set_size_override,RID,int,int);
-	FUNC1RC(bool,texture_can_stream,RID);
-	FUNC3C(texture_set_reload_hook,RID,ObjectID,const StringName&);
+	FUNC5(texture_allocate, RID, int, int, Image::Format, uint32_t);
+	FUNC3(texture_set_data, RID, const Image &, CubeMapSide);
+	FUNC2RC(Image, texture_get_data, RID, CubeMapSide);
+	FUNC2(texture_set_flags, RID, uint32_t);
+	FUNC1RC(Image::Format, texture_get_format, RID);
+	FUNC1RC(uint32_t, texture_get_flags, RID);
+	FUNC1RC(uint32_t, texture_get_width, RID);
+	FUNC1RC(uint32_t, texture_get_height, RID);
+	FUNC3(texture_set_size_override, RID, int, int);
+	FUNC1RC(bool, texture_can_stream, RID);
+	FUNC3C(texture_set_reload_hook, RID, ObjectID, const StringName &);
 
-	FUNC2(texture_set_path,RID,const String&);
-	FUNC1RC(String,texture_get_path,RID);
+	FUNC2(texture_set_path, RID, const String &);
+	FUNC1RC(String, texture_get_path, RID);
 
-	FUNC1(texture_set_shrink_all_x2_on_set_data,bool);
+	FUNC1(texture_set_shrink_all_x2_on_set_data, bool);
 
 	virtual void texture_debug_usage(List<TextureInfo> *r_info) {
 		//pass directly, should lock the server anyway
 		visual_server->texture_debug_usage(r_info);
 	}
 
-
 	/* SHADER API */
 
-	FUNC1R(RID,shader_create,ShaderMode);
-	FUNC2(shader_set_mode,RID,ShaderMode);
-	FUNC1RC(ShaderMode,shader_get_mode,RID);
-	FUNC7(shader_set_code,RID,const String&,const String&,const String&,int,int,int);
-	FUNC1RC(String,shader_get_vertex_code,RID);
-	FUNC1RC(String,shader_get_fragment_code,RID);
-	FUNC1RC(String,shader_get_light_code,RID);
-	FUNC2SC(shader_get_param_list,RID,List<PropertyInfo>*);
-
-	FUNC3(shader_set_default_texture_param,RID,const StringName&,RID);
-	FUNC2RC(RID,shader_get_default_texture_param,RID,const StringName&);
+	FUNC1R(RID, shader_create, ShaderMode);
+	FUNC2(shader_set_mode, RID, ShaderMode);
+	FUNC1RC(ShaderMode, shader_get_mode, RID);
+	FUNC7(shader_set_code, RID, const String &, const String &, const String &, int, int, int);
+	FUNC1RC(String, shader_get_vertex_code, RID);
+	FUNC1RC(String, shader_get_fragment_code, RID);
+	FUNC1RC(String, shader_get_light_code, RID);
+	FUNC2SC(shader_get_param_list, RID, List<PropertyInfo> *);
 
+	FUNC3(shader_set_default_texture_param, RID, const StringName &, RID);
+	FUNC2RC(RID, shader_get_default_texture_param, RID, const StringName &);
 
 	/*virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) {
 		if (Thread::get_caller_ID()!=server_thread) {
@@ -132,604 +127,576 @@ public:
 		}
 	}*/
 
-//	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list);
-
+	//	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list);
 
 	/* COMMON MATERIAL API */
 
-	FUNC0R(RID,material_create);
-	FUNC2(material_set_shader,RID,RID);
-	FUNC1RC(RID,material_get_shader,RID);
+	FUNC0R(RID, material_create);
+	FUNC2(material_set_shader, RID, RID);
+	FUNC1RC(RID, material_get_shader, RID);
 
-	FUNC3(material_set_param,RID,const StringName&,const Variant&);
-	FUNC2RC(Variant,material_get_param,RID,const StringName&);
+	FUNC3(material_set_param, RID, const StringName &, const Variant &);
+	FUNC2RC(Variant, material_get_param, RID, const StringName &);
 
-	FUNC3(material_set_flag,RID,MaterialFlag,bool);
-	FUNC2RC(bool,material_get_flag,RID,MaterialFlag);
+	FUNC3(material_set_flag, RID, MaterialFlag, bool);
+	FUNC2RC(bool, material_get_flag, RID, MaterialFlag);
 
-	FUNC2(material_set_depth_draw_mode,RID,MaterialDepthDrawMode);
-	FUNC1RC(MaterialDepthDrawMode,material_get_depth_draw_mode,RID);
+	FUNC2(material_set_depth_draw_mode, RID, MaterialDepthDrawMode);
+	FUNC1RC(MaterialDepthDrawMode, material_get_depth_draw_mode, RID);
 
-	FUNC2(material_set_blend_mode,RID,MaterialBlendMode);
-	FUNC1RC(MaterialBlendMode,material_get_blend_mode,RID);
+	FUNC2(material_set_blend_mode, RID, MaterialBlendMode);
+	FUNC1RC(MaterialBlendMode, material_get_blend_mode, RID);
 
-	FUNC2(material_set_line_width,RID,float);
-	FUNC1RC(float,material_get_line_width,RID);
+	FUNC2(material_set_line_width, RID, float);
+	FUNC1RC(float, material_get_line_width, RID);
 
 	/* FIXED MATERIAL */
 
+	FUNC0R(RID, fixed_material_create);
 
-	FUNC0R(RID,fixed_material_create);
-
-	FUNC3(fixed_material_set_flag,RID, FixedMaterialFlags , bool );
-	FUNC2RC(bool, fixed_material_get_flag,RID, FixedMaterialFlags);
+	FUNC3(fixed_material_set_flag, RID, FixedMaterialFlags, bool);
+	FUNC2RC(bool, fixed_material_get_flag, RID, FixedMaterialFlags);
 
-	FUNC3(fixed_material_set_param,RID, FixedMaterialParam, const Variant& );
-	FUNC2RC(Variant, fixed_material_get_param,RID ,FixedMaterialParam);
+	FUNC3(fixed_material_set_param, RID, FixedMaterialParam, const Variant &);
+	FUNC2RC(Variant, fixed_material_get_param, RID, FixedMaterialParam);
 
-	FUNC3(fixed_material_set_texture,RID ,FixedMaterialParam, RID );
-	FUNC2RC(RID, fixed_material_get_texture,RID,FixedMaterialParam);
+	FUNC3(fixed_material_set_texture, RID, FixedMaterialParam, RID);
+	FUNC2RC(RID, fixed_material_get_texture, RID, FixedMaterialParam);
 
+	FUNC3(fixed_material_set_texcoord_mode, RID, FixedMaterialParam, FixedMaterialTexCoordMode);
+	FUNC2RC(FixedMaterialTexCoordMode, fixed_material_get_texcoord_mode, RID, FixedMaterialParam);
 
+	FUNC2(fixed_material_set_light_shader, RID, FixedMaterialLightShader);
+	FUNC1RC(FixedMaterialLightShader, fixed_material_get_light_shader, RID);
 
-	FUNC3(fixed_material_set_texcoord_mode,RID,FixedMaterialParam, FixedMaterialTexCoordMode );
-	FUNC2RC(FixedMaterialTexCoordMode, fixed_material_get_texcoord_mode,RID,FixedMaterialParam);
+	FUNC2(fixed_material_set_uv_transform, RID, const Transform &);
+	FUNC1RC(Transform, fixed_material_get_uv_transform, RID);
 
-	FUNC2(fixed_material_set_light_shader,RID,FixedMaterialLightShader);
-	FUNC1RC(FixedMaterialLightShader, fixed_material_get_light_shader,RID);
-
-	FUNC2(fixed_material_set_uv_transform,RID,const Transform&);
-	FUNC1RC(Transform, fixed_material_get_uv_transform,RID);
-
-	FUNC2(fixed_material_set_point_size,RID ,float);
-	FUNC1RC(float,fixed_material_get_point_size,RID);
+	FUNC2(fixed_material_set_point_size, RID, float);
+	FUNC1RC(float, fixed_material_get_point_size, RID);
 
 	/* SURFACE API */
 	FUNCRID(mesh);
 
-	FUNC2(mesh_set_morph_target_count,RID,int);
-	FUNC1RC(int,mesh_get_morph_target_count,RID);
-
-
-	FUNC2(mesh_set_morph_target_mode,RID,MorphTargetMode);
-	FUNC1RC(MorphTargetMode,mesh_get_morph_target_mode,RID);
-
-	FUNC2(mesh_add_custom_surface,RID,const Variant&); //this is used by each platform in a different way
+	FUNC2(mesh_set_morph_target_count, RID, int);
+	FUNC1RC(int, mesh_get_morph_target_count, RID);
 
-	FUNC5(mesh_add_surface,RID,PrimitiveType,const Array&,const Array&,bool);
-	FUNC2RC(Array,mesh_get_surface_arrays,RID,int);
-	FUNC2RC(Array,mesh_get_surface_morph_arrays,RID,int);
+	FUNC2(mesh_set_morph_target_mode, RID, MorphTargetMode);
+	FUNC1RC(MorphTargetMode, mesh_get_morph_target_mode, RID);
 
-	FUNC4(mesh_surface_set_material,RID, int, RID,bool);
-	FUNC2RC(RID,mesh_surface_get_material,RID, int);
+	FUNC2(mesh_add_custom_surface, RID, const Variant &); //this is used by each platform in a different way
 
-	FUNC2RC(int,mesh_surface_get_array_len,RID, int);
-	FUNC2RC(int,mesh_surface_get_array_index_len,RID, int);
-	FUNC2RC(uint32_t,mesh_surface_get_format,RID, int);
-	FUNC2RC(PrimitiveType,mesh_surface_get_primitive_type,RID, int);
+	FUNC5(mesh_add_surface, RID, PrimitiveType, const Array &, const Array &, bool);
+	FUNC2RC(Array, mesh_get_surface_arrays, RID, int);
+	FUNC2RC(Array, mesh_get_surface_morph_arrays, RID, int);
 
-	FUNC2(mesh_remove_surface,RID,int);
-	FUNC1RC(int,mesh_get_surface_count,RID);
-	FUNC1(mesh_clear,RID);
+	FUNC4(mesh_surface_set_material, RID, int, RID, bool);
+	FUNC2RC(RID, mesh_surface_get_material, RID, int);
 
+	FUNC2RC(int, mesh_surface_get_array_len, RID, int);
+	FUNC2RC(int, mesh_surface_get_array_index_len, RID, int);
+	FUNC2RC(uint32_t, mesh_surface_get_format, RID, int);
+	FUNC2RC(PrimitiveType, mesh_surface_get_primitive_type, RID, int);
 
-	FUNC2(mesh_set_custom_aabb,RID,const AABB&);
-	FUNC1RC(AABB,mesh_get_custom_aabb,RID);
+	FUNC2(mesh_remove_surface, RID, int);
+	FUNC1RC(int, mesh_get_surface_count, RID);
+	FUNC1(mesh_clear, RID);
 
+	FUNC2(mesh_set_custom_aabb, RID, const AABB &);
+	FUNC1RC(AABB, mesh_get_custom_aabb, RID);
 
 	/* MULTIMESH API */
 
-	FUNC0R(RID,multimesh_create);
-	FUNC2(multimesh_set_instance_count,RID,int);
-	FUNC1RC(int,multimesh_get_instance_count,RID);
+	FUNC0R(RID, multimesh_create);
+	FUNC2(multimesh_set_instance_count, RID, int);
+	FUNC1RC(int, multimesh_get_instance_count, RID);
 
-	FUNC2(multimesh_set_mesh,RID,RID);
-	FUNC2(multimesh_set_aabb,RID,const AABB&);
-	FUNC3(multimesh_instance_set_transform,RID,int,const Transform&);
-	FUNC3(multimesh_instance_set_color,RID,int,const Color&);
+	FUNC2(multimesh_set_mesh, RID, RID);
+	FUNC2(multimesh_set_aabb, RID, const AABB &);
+	FUNC3(multimesh_instance_set_transform, RID, int, const Transform &);
+	FUNC3(multimesh_instance_set_color, RID, int, const Color &);
 
-	FUNC1RC(RID,multimesh_get_mesh,RID);
-	FUNC2RC(AABB,multimesh_get_aabb,RID,const AABB&);
-	FUNC2RC(Transform,multimesh_instance_get_transform,RID,int);
-	FUNC2RC(Color,multimesh_instance_get_color,RID,int);
+	FUNC1RC(RID, multimesh_get_mesh, RID);
+	FUNC2RC(AABB, multimesh_get_aabb, RID, const AABB &);
+	FUNC2RC(Transform, multimesh_instance_get_transform, RID, int);
+	FUNC2RC(Color, multimesh_instance_get_color, RID, int);
 
-	FUNC2(multimesh_set_visible_instances,RID,int);
-	FUNC1RC(int,multimesh_get_visible_instances,RID);
+	FUNC2(multimesh_set_visible_instances, RID, int);
+	FUNC1RC(int, multimesh_get_visible_instances, RID);
 
 	/* IMMEDIATE API */
 
-
-	FUNC0R(RID,immediate_create);
-	FUNC3(immediate_begin,RID,PrimitiveType,RID);
-	FUNC2(immediate_vertex,RID,const Vector3&);
-	FUNC2(immediate_normal,RID,const Vector3&);
-	FUNC2(immediate_tangent,RID,const Plane&);
-	FUNC2(immediate_color,RID,const Color&);
-	FUNC2(immediate_uv,RID,const Vector2&);
-	FUNC2(immediate_uv2,RID,const Vector2&);
-	FUNC1(immediate_end,RID);
-	FUNC1(immediate_clear,RID);
-	FUNC2(immediate_set_material,RID,RID);
-	FUNC1RC(RID,immediate_get_material,RID);
-
+	FUNC0R(RID, immediate_create);
+	FUNC3(immediate_begin, RID, PrimitiveType, RID);
+	FUNC2(immediate_vertex, RID, const Vector3 &);
+	FUNC2(immediate_normal, RID, const Vector3 &);
+	FUNC2(immediate_tangent, RID, const Plane &);
+	FUNC2(immediate_color, RID, const Color &);
+	FUNC2(immediate_uv, RID, const Vector2 &);
+	FUNC2(immediate_uv2, RID, const Vector2 &);
+	FUNC1(immediate_end, RID);
+	FUNC1(immediate_clear, RID);
+	FUNC2(immediate_set_material, RID, RID);
+	FUNC1RC(RID, immediate_get_material, RID);
 
 	/* PARTICLES API */
 
-	FUNC0R(RID,particles_create);
+	FUNC0R(RID, particles_create);
 
-	FUNC2(particles_set_amount,RID, int );
-	FUNC1RC(int,particles_get_amount,RID);
+	FUNC2(particles_set_amount, RID, int);
+	FUNC1RC(int, particles_get_amount, RID);
 
-	FUNC2(particles_set_emitting,RID, bool );
-	FUNC1RC(bool,particles_is_emitting,RID);
+	FUNC2(particles_set_emitting, RID, bool);
+	FUNC1RC(bool, particles_is_emitting, RID);
 
-	FUNC2(particles_set_visibility_aabb,RID, const AABB&);
-	FUNC1RC(AABB,particles_get_visibility_aabb,RID);
+	FUNC2(particles_set_visibility_aabb, RID, const AABB &);
+	FUNC1RC(AABB, particles_get_visibility_aabb, RID);
 
-	FUNC2(particles_set_emission_half_extents,RID, const Vector3&);
-	FUNC1RC(Vector3,particles_get_emission_half_extents,RID);
+	FUNC2(particles_set_emission_half_extents, RID, const Vector3 &);
+	FUNC1RC(Vector3, particles_get_emission_half_extents, RID);
 
-	FUNC2(particles_set_emission_base_velocity,RID, const Vector3&);
-	FUNC1RC(Vector3,particles_get_emission_base_velocity,RID);
+	FUNC2(particles_set_emission_base_velocity, RID, const Vector3 &);
+	FUNC1RC(Vector3, particles_get_emission_base_velocity, RID);
 
-	FUNC2(particles_set_emission_points,RID, const DVector<Vector3>& );
-	FUNC1RC(DVector<Vector3>,particles_get_emission_points,RID);
+	FUNC2(particles_set_emission_points, RID, const DVector<Vector3> &);
+	FUNC1RC(DVector<Vector3>, particles_get_emission_points, RID);
 
-	FUNC2(particles_set_gravity_normal,RID, const Vector3& );
-	FUNC1RC(Vector3,particles_get_gravity_normal,RID);
+	FUNC2(particles_set_gravity_normal, RID, const Vector3 &);
+	FUNC1RC(Vector3, particles_get_gravity_normal, RID);
 
-	FUNC3(particles_set_variable,RID, ParticleVariable ,float);
-	FUNC2RC(float,particles_get_variable,RID, ParticleVariable );
+	FUNC3(particles_set_variable, RID, ParticleVariable, float);
+	FUNC2RC(float, particles_get_variable, RID, ParticleVariable);
 
-	FUNC3(particles_set_randomness,RID, ParticleVariable ,float);
-	FUNC2RC(float,particles_get_randomness,RID, ParticleVariable );
+	FUNC3(particles_set_randomness, RID, ParticleVariable, float);
+	FUNC2RC(float, particles_get_randomness, RID, ParticleVariable);
 
-	FUNC3(particles_set_color_phase_pos,RID, int , float);
-	FUNC2RC(float,particles_get_color_phase_pos,RID, int );
+	FUNC3(particles_set_color_phase_pos, RID, int, float);
+	FUNC2RC(float, particles_get_color_phase_pos, RID, int);
 
-	FUNC2(particles_set_color_phases,RID, int );
-	FUNC1RC(int,particles_get_color_phases,RID);
+	FUNC2(particles_set_color_phases, RID, int);
+	FUNC1RC(int, particles_get_color_phases, RID);
 
-	FUNC3(particles_set_color_phase_color,RID, int , const Color& );
-	FUNC2RC(Color,particles_get_color_phase_color,RID, int );
+	FUNC3(particles_set_color_phase_color, RID, int, const Color &);
+	FUNC2RC(Color, particles_get_color_phase_color, RID, int);
 
-	FUNC2(particles_set_attractors,RID, int);
-	FUNC1RC(int,particles_get_attractors,RID);
+	FUNC2(particles_set_attractors, RID, int);
+	FUNC1RC(int, particles_get_attractors, RID);
 
-	FUNC3(particles_set_attractor_pos,RID, int, const Vector3&);
-	FUNC2RC(Vector3,particles_get_attractor_pos,RID,int);
+	FUNC3(particles_set_attractor_pos, RID, int, const Vector3 &);
+	FUNC2RC(Vector3, particles_get_attractor_pos, RID, int);
 
-	FUNC3(particles_set_attractor_strength,RID, int, float);
-	FUNC2RC(float,particles_get_attractor_strength,RID,int);
+	FUNC3(particles_set_attractor_strength, RID, int, float);
+	FUNC2RC(float, particles_get_attractor_strength, RID, int);
 
-	FUNC3(particles_set_material,RID, RID,bool);
-	FUNC1RC(RID,particles_get_material,RID);
+	FUNC3(particles_set_material, RID, RID, bool);
+	FUNC1RC(RID, particles_get_material, RID);
 
-	FUNC2(particles_set_height_from_velocity,RID, bool);
-	FUNC1RC(bool,particles_has_height_from_velocity,RID);
-
-	FUNC2(particles_set_use_local_coordinates,RID, bool);
-	FUNC1RC(bool,particles_is_using_local_coordinates,RID);
+	FUNC2(particles_set_height_from_velocity, RID, bool);
+	FUNC1RC(bool, particles_has_height_from_velocity, RID);
 
+	FUNC2(particles_set_use_local_coordinates, RID, bool);
+	FUNC1RC(bool, particles_is_using_local_coordinates, RID);
 
 	/* Light API */
 
-	FUNC1R(RID,light_create,LightType);
-	FUNC1RC(LightType,light_get_type,RID);
-
-	FUNC3(light_set_color,RID,LightColor , const Color& );
-	FUNC2RC(Color,light_get_color,RID,LightColor );
+	FUNC1R(RID, light_create, LightType);
+	FUNC1RC(LightType, light_get_type, RID);
 
+	FUNC3(light_set_color, RID, LightColor, const Color &);
+	FUNC2RC(Color, light_get_color, RID, LightColor);
 
-	FUNC2(light_set_shadow,RID,bool );
-	FUNC1RC(bool,light_has_shadow,RID);
+	FUNC2(light_set_shadow, RID, bool);
+	FUNC1RC(bool, light_has_shadow, RID);
 
-	FUNC2(light_set_volumetric,RID,bool );
-	FUNC1RC(bool,light_is_volumetric,RID);
+	FUNC2(light_set_volumetric, RID, bool);
+	FUNC1RC(bool, light_is_volumetric, RID);
 
-	FUNC2(light_set_projector,RID,RID );
-	FUNC1RC(RID,light_get_projector,RID);
+	FUNC2(light_set_projector, RID, RID);
+	FUNC1RC(RID, light_get_projector, RID);
 
-	FUNC3(light_set_param,RID, LightParam , float );
-	FUNC2RC(float,light_get_param,RID, LightParam );
+	FUNC3(light_set_param, RID, LightParam, float);
+	FUNC2RC(float, light_get_param, RID, LightParam);
 
-	FUNC2(light_set_operator,RID,LightOp);
-	FUNC1RC(LightOp,light_get_operator,RID);
+	FUNC2(light_set_operator, RID, LightOp);
+	FUNC1RC(LightOp, light_get_operator, RID);
 
-	FUNC2(light_omni_set_shadow_mode,RID,LightOmniShadowMode);
-	FUNC1RC(LightOmniShadowMode,light_omni_get_shadow_mode,RID);
-
-	FUNC2(light_directional_set_shadow_mode,RID,LightDirectionalShadowMode);
-	FUNC1RC(LightDirectionalShadowMode,light_directional_get_shadow_mode,RID);
-	FUNC3(light_directional_set_shadow_param,RID,LightDirectionalShadowParam, float );
-	FUNC2RC(float,light_directional_get_shadow_param,RID,LightDirectionalShadowParam );
+	FUNC2(light_omni_set_shadow_mode, RID, LightOmniShadowMode);
+	FUNC1RC(LightOmniShadowMode, light_omni_get_shadow_mode, RID);
 
+	FUNC2(light_directional_set_shadow_mode, RID, LightDirectionalShadowMode);
+	FUNC1RC(LightDirectionalShadowMode, light_directional_get_shadow_mode, RID);
+	FUNC3(light_directional_set_shadow_param, RID, LightDirectionalShadowParam, float);
+	FUNC2RC(float, light_directional_get_shadow_param, RID, LightDirectionalShadowParam);
 
 	/* SKELETON API */
 
-	FUNC0R(RID,skeleton_create);
-	FUNC2(skeleton_resize,RID,int );
-	FUNC1RC(int,skeleton_get_bone_count,RID) ;
-	FUNC3(skeleton_bone_set_transform,RID,int, const Transform&);
-	FUNC2R(Transform,skeleton_bone_get_transform,RID,int );
+	FUNC0R(RID, skeleton_create);
+	FUNC2(skeleton_resize, RID, int);
+	FUNC1RC(int, skeleton_get_bone_count, RID);
+	FUNC3(skeleton_bone_set_transform, RID, int, const Transform &);
+	FUNC2R(Transform, skeleton_bone_get_transform, RID, int);
 
 	/* ROOM API */
 
-	FUNC0R(RID,room_create);
-	FUNC2(room_set_bounds,RID, const BSP_Tree&);
-	FUNC1RC(BSP_Tree,room_get_bounds,RID);
+	FUNC0R(RID, room_create);
+	FUNC2(room_set_bounds, RID, const BSP_Tree &);
+	FUNC1RC(BSP_Tree, room_get_bounds, RID);
 
 	/* PORTAL API */
 
-	FUNC0R(RID,portal_create);
-	FUNC2(portal_set_shape,RID,const Vector<Point2>&);
-	FUNC1RC(Vector<Point2>,portal_get_shape,RID);
-	FUNC2(portal_set_enabled,RID, bool);
-	FUNC1RC(bool,portal_is_enabled,RID);
-	FUNC2(portal_set_disable_distance,RID, float);
-	FUNC1RC(float,portal_get_disable_distance,RID);
-	FUNC2(portal_set_disabled_color,RID, const Color&);
-	FUNC1RC(Color,portal_get_disabled_color,RID);
-	FUNC2(portal_set_connect_range,RID, float);
-	FUNC1RC(float,portal_get_connect_range,RID);
-
+	FUNC0R(RID, portal_create);
+	FUNC2(portal_set_shape, RID, const Vector<Point2> &);
+	FUNC1RC(Vector<Point2>, portal_get_shape, RID);
+	FUNC2(portal_set_enabled, RID, bool);
+	FUNC1RC(bool, portal_is_enabled, RID);
+	FUNC2(portal_set_disable_distance, RID, float);
+	FUNC1RC(float, portal_get_disable_distance, RID);
+	FUNC2(portal_set_disabled_color, RID, const Color &);
+	FUNC1RC(Color, portal_get_disabled_color, RID);
+	FUNC2(portal_set_connect_range, RID, float);
+	FUNC1RC(float, portal_get_connect_range, RID);
 
-	FUNC0R(RID,baked_light_create);
-	FUNC2(baked_light_set_mode,RID,BakedLightMode);
-	FUNC1RC(BakedLightMode,baked_light_get_mode,RID);
+	FUNC0R(RID, baked_light_create);
+	FUNC2(baked_light_set_mode, RID, BakedLightMode);
+	FUNC1RC(BakedLightMode, baked_light_get_mode, RID);
 
-	FUNC2(baked_light_set_octree,RID,DVector<uint8_t>);
-	FUNC1RC(DVector<uint8_t>,baked_light_get_octree,RID);
+	FUNC2(baked_light_set_octree, RID, DVector<uint8_t>);
+	FUNC1RC(DVector<uint8_t>, baked_light_get_octree, RID);
 
-	FUNC2(baked_light_set_light,RID,DVector<uint8_t>);
-	FUNC1RC(DVector<uint8_t>,baked_light_get_light,RID);
+	FUNC2(baked_light_set_light, RID, DVector<uint8_t>);
+	FUNC1RC(DVector<uint8_t>, baked_light_get_light, RID);
 
-	FUNC2(baked_light_set_sampler_octree,RID,const DVector<int>&);
-	FUNC1RC(DVector<int>,baked_light_get_sampler_octree,RID);
+	FUNC2(baked_light_set_sampler_octree, RID, const DVector<int> &);
+	FUNC1RC(DVector<int>, baked_light_get_sampler_octree, RID);
 
-	FUNC2(baked_light_set_lightmap_multiplier,RID,float);
-	FUNC1RC(float,baked_light_get_lightmap_multiplier,RID);
+	FUNC2(baked_light_set_lightmap_multiplier, RID, float);
+	FUNC1RC(float, baked_light_get_lightmap_multiplier, RID);
 
-	FUNC3(baked_light_add_lightmap,RID,RID,int);
-	FUNC1(baked_light_clear_lightmaps,RID);
+	FUNC3(baked_light_add_lightmap, RID, RID, int);
+	FUNC1(baked_light_clear_lightmaps, RID);
 
 	FUNC2(baked_light_set_realtime_color_enabled, RID, const bool);
 	FUNC1RC(bool, baked_light_get_realtime_color_enabled, RID);
 
-	FUNC2(baked_light_set_realtime_color, RID, const Color&);
+	FUNC2(baked_light_set_realtime_color, RID, const Color &);
 	FUNC1RC(Color, baked_light_get_realtime_color, RID);
 
 	FUNC2(baked_light_set_realtime_energy, RID, const float);
 	FUNC1RC(float, baked_light_get_realtime_energy, RID);
 
-	FUNC0R(RID,baked_light_sampler_create);
+	FUNC0R(RID, baked_light_sampler_create);
 
-	FUNC3(baked_light_sampler_set_param,RID, BakedLightSamplerParam , float );
-	FUNC2RC(float,baked_light_sampler_get_param,RID, BakedLightSamplerParam );
+	FUNC3(baked_light_sampler_set_param, RID, BakedLightSamplerParam, float);
+	FUNC2RC(float, baked_light_sampler_get_param, RID, BakedLightSamplerParam);
 
-	FUNC2(baked_light_sampler_set_resolution,RID,int);
-	FUNC1RC(int,baked_light_sampler_get_resolution,RID);
+	FUNC2(baked_light_sampler_set_resolution, RID, int);
+	FUNC1RC(int, baked_light_sampler_get_resolution, RID);
 
 	/* CAMERA API */
 
-	FUNC0R(RID,camera_create);
-	FUNC4(camera_set_perspective,RID,float , float , float );
-	FUNC4(camera_set_orthogonal,RID,float, float , float );
-	FUNC2(camera_set_transform,RID,const Transform& );
-
-	FUNC2(camera_set_visible_layers,RID,uint32_t);
-	FUNC1RC(uint32_t,camera_get_visible_layers,RID);
+	FUNC0R(RID, camera_create);
+	FUNC4(camera_set_perspective, RID, float, float, float);
+	FUNC4(camera_set_orthogonal, RID, float, float, float);
+	FUNC2(camera_set_transform, RID, const Transform &);
 
-	FUNC2(camera_set_environment,RID,RID);
-	FUNC1RC(RID,camera_get_environment,RID);
+	FUNC2(camera_set_visible_layers, RID, uint32_t);
+	FUNC1RC(uint32_t, camera_get_visible_layers, RID);
 
+	FUNC2(camera_set_environment, RID, RID);
+	FUNC1RC(RID, camera_get_environment, RID);
 
-	FUNC2(camera_set_use_vertical_aspect,RID,bool);
-	FUNC2RC(bool,camera_is_using_vertical_aspect,RID,bool);
-
+	FUNC2(camera_set_use_vertical_aspect, RID, bool);
+	FUNC2RC(bool, camera_is_using_vertical_aspect, RID, bool);
 
 	/* VIEWPORT API */
 
-	FUNC0R(RID,viewport_create);
-
-	FUNC2(viewport_attach_to_screen,RID,int );
-	FUNC1(viewport_detach,RID);
+	FUNC0R(RID, viewport_create);
 
-	FUNC2(viewport_set_as_render_target,RID,bool);
-	FUNC2(viewport_set_render_target_update_mode,RID,RenderTargetUpdateMode);
-	FUNC1RC(RenderTargetUpdateMode,viewport_get_render_target_update_mode,RID);
-	FUNC1RC(RID,viewport_get_render_target_texture,RID);
+	FUNC2(viewport_attach_to_screen, RID, int);
+	FUNC1(viewport_detach, RID);
 
-	FUNC2(viewport_set_render_target_vflip,RID,bool);
-	FUNC1RC(bool,viewport_get_render_target_vflip,RID);
-	FUNC2(viewport_set_render_target_to_screen_rect,RID,const Rect2&);
+	FUNC2(viewport_set_as_render_target, RID, bool);
+	FUNC2(viewport_set_render_target_update_mode, RID, RenderTargetUpdateMode);
+	FUNC1RC(RenderTargetUpdateMode, viewport_get_render_target_update_mode, RID);
+	FUNC1RC(RID, viewport_get_render_target_texture, RID);
 
-	FUNC2(viewport_set_render_target_clear_on_new_frame,RID,bool);
-	FUNC1RC(bool,viewport_get_render_target_clear_on_new_frame,RID);
-	FUNC1(viewport_render_target_clear,RID);
+	FUNC2(viewport_set_render_target_vflip, RID, bool);
+	FUNC1RC(bool, viewport_get_render_target_vflip, RID);
+	FUNC2(viewport_set_render_target_to_screen_rect, RID, const Rect2 &);
 
-	FUNC1(viewport_queue_screen_capture,RID);
-	FUNC1RC(Image,viewport_get_screen_capture,RID);
+	FUNC2(viewport_set_render_target_clear_on_new_frame, RID, bool);
+	FUNC1RC(bool, viewport_get_render_target_clear_on_new_frame, RID);
+	FUNC1(viewport_render_target_clear, RID);
 
-	FUNC2(viewport_set_rect,RID,const ViewportRect&);
-	FUNC1RC(ViewportRect,viewport_get_rect,RID);
+	FUNC1(viewport_queue_screen_capture, RID);
+	FUNC1RC(Image, viewport_get_screen_capture, RID);
 
-	FUNC2(viewport_set_hide_scenario,RID,bool );
-	FUNC2(viewport_set_hide_canvas,RID,bool );
-	FUNC2(viewport_attach_camera,RID,RID );
-	FUNC2(viewport_set_scenario,RID,RID );
-	FUNC2(viewport_set_disable_environment,RID,bool );
+	FUNC2(viewport_set_rect, RID, const ViewportRect &);
+	FUNC1RC(ViewportRect, viewport_get_rect, RID);
 
-	FUNC1RC(RID,viewport_get_attached_camera,RID);
-	FUNC1RC(RID,viewport_get_scenario,RID );
-	FUNC2(viewport_attach_canvas,RID,RID);
-	FUNC2(viewport_remove_canvas,RID,RID);
-	FUNC3(viewport_set_canvas_transform,RID,RID,const Matrix32&);
-	FUNC2RC(Matrix32,viewport_get_canvas_transform,RID,RID);
-	FUNC2(viewport_set_global_canvas_transform,RID,const Matrix32&);
-	FUNC1RC(Matrix32,viewport_get_global_canvas_transform,RID);
-	FUNC3(viewport_set_canvas_layer,RID,RID ,int);
-	FUNC2(viewport_set_transparent_background,RID,bool);
-	FUNC1RC(bool,viewport_has_transparent_background,RID);
+	FUNC2(viewport_set_hide_scenario, RID, bool);
+	FUNC2(viewport_set_hide_canvas, RID, bool);
+	FUNC2(viewport_attach_camera, RID, RID);
+	FUNC2(viewport_set_scenario, RID, RID);
+	FUNC2(viewport_set_disable_environment, RID, bool);
 
+	FUNC1RC(RID, viewport_get_attached_camera, RID);
+	FUNC1RC(RID, viewport_get_scenario, RID);
+	FUNC2(viewport_attach_canvas, RID, RID);
+	FUNC2(viewport_remove_canvas, RID, RID);
+	FUNC3(viewport_set_canvas_transform, RID, RID, const Matrix32 &);
+	FUNC2RC(Matrix32, viewport_get_canvas_transform, RID, RID);
+	FUNC2(viewport_set_global_canvas_transform, RID, const Matrix32 &);
+	FUNC1RC(Matrix32, viewport_get_global_canvas_transform, RID);
+	FUNC3(viewport_set_canvas_layer, RID, RID, int);
+	FUNC2(viewport_set_transparent_background, RID, bool);
+	FUNC1RC(bool, viewport_has_transparent_background, RID);
 
 	/* ENVIRONMENT API */
 
-	FUNC0R(RID,environment_create);
+	FUNC0R(RID, environment_create);
 
-	FUNC2(environment_set_background,RID,EnvironmentBG);
-	FUNC1RC(EnvironmentBG,environment_get_background,RID);
+	FUNC2(environment_set_background, RID, EnvironmentBG);
+	FUNC1RC(EnvironmentBG, environment_get_background, RID);
 
-	FUNC3(environment_set_background_param,RID,EnvironmentBGParam, const Variant&);
-	FUNC2RC(Variant,environment_get_background_param,RID,EnvironmentBGParam );
+	FUNC3(environment_set_background_param, RID, EnvironmentBGParam, const Variant &);
+	FUNC2RC(Variant, environment_get_background_param, RID, EnvironmentBGParam);
 
-	FUNC3(environment_set_enable_fx,RID,EnvironmentFx,bool);
-	FUNC2RC(bool,environment_is_fx_enabled,RID,EnvironmentFx);
-
-
-	FUNC3(environment_fx_set_param,RID,EnvironmentFxParam,const Variant&);
-	FUNC2RC(Variant,environment_fx_get_param,RID,EnvironmentFxParam);
+	FUNC3(environment_set_enable_fx, RID, EnvironmentFx, bool);
+	FUNC2RC(bool, environment_is_fx_enabled, RID, EnvironmentFx);
 
+	FUNC3(environment_fx_set_param, RID, EnvironmentFxParam, const Variant &);
+	FUNC2RC(Variant, environment_fx_get_param, RID, EnvironmentFxParam);
 
 	/* SCENARIO API */
 
-	FUNC0R(RID,scenario_create);
-
-	FUNC2(scenario_set_debug,RID,ScenarioDebugMode);
-	FUNC2(scenario_set_environment,RID, RID);
-	FUNC2RC(RID,scenario_get_environment,RID, RID);
-	FUNC2(scenario_set_fallback_environment,RID, RID);
+	FUNC0R(RID, scenario_create);
 
+	FUNC2(scenario_set_debug, RID, ScenarioDebugMode);
+	FUNC2(scenario_set_environment, RID, RID);
+	FUNC2RC(RID, scenario_get_environment, RID, RID);
+	FUNC2(scenario_set_fallback_environment, RID, RID);
 
 	/* INSTANCING API */
 
-	FUNC0R(RID,instance_create);
+	FUNC0R(RID, instance_create);
 
-	FUNC2(instance_set_base,RID, RID);
-	FUNC1RC(RID,instance_get_base,RID);
+	FUNC2(instance_set_base, RID, RID);
+	FUNC1RC(RID, instance_get_base, RID);
 
-	FUNC2(instance_set_scenario,RID, RID);
-	FUNC1RC(RID,instance_get_scenario,RID);
+	FUNC2(instance_set_scenario, RID, RID);
+	FUNC1RC(RID, instance_get_scenario, RID);
 
-	FUNC2(instance_set_layer_mask,RID, uint32_t);
-	FUNC1RC(uint32_t,instance_get_layer_mask,RID);
+	FUNC2(instance_set_layer_mask, RID, uint32_t);
+	FUNC1RC(uint32_t, instance_get_layer_mask, RID);
 
-	FUNC1RC(AABB,instance_get_base_aabb,RID);
+	FUNC1RC(AABB, instance_get_base_aabb, RID);
 
-	FUNC2(instance_attach_object_instance_ID,RID,uint32_t);
-	FUNC1RC(uint32_t,instance_get_object_instance_ID,RID);
+	FUNC2(instance_attach_object_instance_ID, RID, uint32_t);
+	FUNC1RC(uint32_t, instance_get_object_instance_ID, RID);
 
-	FUNC2(instance_attach_skeleton,RID,RID);
-	FUNC1RC(RID,instance_get_skeleton,RID);
+	FUNC2(instance_attach_skeleton, RID, RID);
+	FUNC1RC(RID, instance_get_skeleton, RID);
 
-	FUNC3(instance_set_morph_target_weight,RID,int, float);
-	FUNC2RC(float,instance_get_morph_target_weight,RID,int);
+	FUNC3(instance_set_morph_target_weight, RID, int, float);
+	FUNC2RC(float, instance_get_morph_target_weight, RID, int);
 
-	FUNC3(instance_set_surface_material,RID,int, RID);
+	FUNC3(instance_set_surface_material, RID, int, RID);
 
-	FUNC2(instance_set_transform,RID, const Transform&);
-	FUNC1RC(Transform,instance_get_transform,RID);
+	FUNC2(instance_set_transform, RID, const Transform &);
+	FUNC1RC(Transform, instance_get_transform, RID);
 
-	FUNC2(instance_set_exterior,RID, bool );
-	FUNC1RC(bool,instance_is_exterior,RID);
+	FUNC2(instance_set_exterior, RID, bool);
+	FUNC1RC(bool, instance_is_exterior, RID);
 
-	FUNC2(instance_set_room,RID, RID );
-	FUNC1RC(RID,instance_get_room,RID ) ;
+	FUNC2(instance_set_room, RID, RID);
+	FUNC1RC(RID, instance_get_room, RID);
 
-	FUNC2(instance_set_extra_visibility_margin,RID, real_t  );
-	FUNC1RC(real_t,instance_get_extra_visibility_margin,RID );
+	FUNC2(instance_set_extra_visibility_margin, RID, real_t);
+	FUNC1RC(real_t, instance_get_extra_visibility_margin, RID);
 
-	FUNC2RC(Vector<RID>,instances_cull_aabb,const AABB& , RID );
-	FUNC3RC(Vector<RID>,instances_cull_ray,const Vector3& ,const Vector3&, RID );
-	FUNC2RC(Vector<RID>,instances_cull_convex,const Vector<Plane>& , RID );
+	FUNC2RC(Vector<RID>, instances_cull_aabb, const AABB &, RID);
+	FUNC3RC(Vector<RID>, instances_cull_ray, const Vector3 &, const Vector3 &, RID);
+	FUNC2RC(Vector<RID>, instances_cull_convex, const Vector<Plane> &, RID);
 
-	FUNC3(instance_geometry_set_flag,RID,InstanceFlags ,bool );
-	FUNC2RC(bool,instance_geometry_get_flag,RID,InstanceFlags );
+	FUNC3(instance_geometry_set_flag, RID, InstanceFlags, bool);
+	FUNC2RC(bool, instance_geometry_get_flag, RID, InstanceFlags);
 
 	FUNC2(instance_geometry_set_cast_shadows_setting, RID, ShadowCastingSetting);
 	FUNC1RC(ShadowCastingSetting, instance_geometry_get_cast_shadows_setting, RID);
 
-	FUNC2(instance_geometry_set_material_override,RID, RID );
-	FUNC1RC(RID,instance_geometry_get_material_override,RID);
+	FUNC2(instance_geometry_set_material_override, RID, RID);
+	FUNC1RC(RID, instance_geometry_get_material_override, RID);
 
-	FUNC3(instance_geometry_set_draw_range,RID,float ,float);
-	FUNC1RC(float,instance_geometry_get_draw_range_max,RID);
-	FUNC1RC(float,instance_geometry_get_draw_range_min,RID);
+	FUNC3(instance_geometry_set_draw_range, RID, float, float);
+	FUNC1RC(float, instance_geometry_get_draw_range_max, RID);
+	FUNC1RC(float, instance_geometry_get_draw_range_min, RID);
 
-	FUNC2(instance_geometry_set_baked_light,RID, RID );
-	FUNC1RC(RID,instance_geometry_get_baked_light,RID);
+	FUNC2(instance_geometry_set_baked_light, RID, RID);
+	FUNC1RC(RID, instance_geometry_get_baked_light, RID);
 
-	FUNC2(instance_geometry_set_baked_light_sampler,RID, RID );
-	FUNC1RC(RID,instance_geometry_get_baked_light_sampler,RID);
+	FUNC2(instance_geometry_set_baked_light_sampler, RID, RID);
+	FUNC1RC(RID, instance_geometry_get_baked_light_sampler, RID);
 
-	FUNC2(instance_geometry_set_baked_light_texture_index,RID, int);
-	FUNC1RC(int,instance_geometry_get_baked_light_texture_index,RID);
+	FUNC2(instance_geometry_set_baked_light_texture_index, RID, int);
+	FUNC1RC(int, instance_geometry_get_baked_light_texture_index, RID);
 
-	FUNC2(instance_light_set_enabled,RID,bool);
-	FUNC1RC(bool,instance_light_is_enabled,RID);
+	FUNC2(instance_light_set_enabled, RID, bool);
+	FUNC1RC(bool, instance_light_is_enabled, RID);
 
 	/* CANVAS (2D) */
 
-	FUNC0R(RID,canvas_create);
-	FUNC3(canvas_set_item_mirroring,RID,RID,const Point2&);
-	FUNC2RC(Point2,canvas_get_item_mirroring,RID,RID);
-	FUNC2(canvas_set_modulate,RID,const Color&);
-
+	FUNC0R(RID, canvas_create);
+	FUNC3(canvas_set_item_mirroring, RID, RID, const Point2 &);
+	FUNC2RC(Point2, canvas_get_item_mirroring, RID, RID);
+	FUNC2(canvas_set_modulate, RID, const Color &);
 
-	FUNC0R(RID,canvas_item_create);
+	FUNC0R(RID, canvas_item_create);
 
-	FUNC2(canvas_item_set_parent,RID,RID );
-	FUNC1RC(RID,canvas_item_get_parent,RID);
+	FUNC2(canvas_item_set_parent, RID, RID);
+	FUNC1RC(RID, canvas_item_get_parent, RID);
 
-	FUNC2(canvas_item_set_visible,RID,bool );
-	FUNC1RC(bool,canvas_item_is_visible,RID);
+	FUNC2(canvas_item_set_visible, RID, bool);
+	FUNC1RC(bool, canvas_item_is_visible, RID);
 
-	FUNC2(canvas_item_set_blend_mode,RID,MaterialBlendMode );
-	FUNC2(canvas_item_set_light_mask,RID,int );
+	FUNC2(canvas_item_set_blend_mode, RID, MaterialBlendMode);
+	FUNC2(canvas_item_set_light_mask, RID, int);
 
 	//FUNC(canvas_item_set_rect,RID, const Rect2& p_rect);
-	FUNC2(canvas_item_set_transform,RID, const Matrix32& );
-	FUNC2(canvas_item_set_clip,RID, bool );
-	FUNC2(canvas_item_set_distance_field_mode,RID, bool );
-	FUNC3(canvas_item_set_custom_rect,RID, bool ,const Rect2&);
-	FUNC2(canvas_item_set_opacity,RID, float );
-	FUNC2RC(float,canvas_item_get_opacity,RID, float );
-	FUNC2(canvas_item_set_on_top,RID, bool );
-	FUNC1RC(bool,canvas_item_is_on_top,RID);
+	FUNC2(canvas_item_set_transform, RID, const Matrix32 &);
+	FUNC2(canvas_item_set_clip, RID, bool);
+	FUNC2(canvas_item_set_distance_field_mode, RID, bool);
+	FUNC3(canvas_item_set_custom_rect, RID, bool, const Rect2 &);
+	FUNC2(canvas_item_set_opacity, RID, float);
+	FUNC2RC(float, canvas_item_get_opacity, RID, float);
+	FUNC2(canvas_item_set_on_top, RID, bool);
+	FUNC1RC(bool, canvas_item_is_on_top, RID);
 
-	FUNC2(canvas_item_set_self_opacity,RID, float );
-	FUNC2RC(float,canvas_item_get_self_opacity,RID, float );
+	FUNC2(canvas_item_set_self_opacity, RID, float);
+	FUNC2RC(float, canvas_item_get_self_opacity, RID, float);
 
-	FUNC2(canvas_item_attach_viewport,RID, RID );
+	FUNC2(canvas_item_attach_viewport, RID, RID);
 
-	FUNC5(canvas_item_add_line,RID, const Point2& , const Point2& ,const Color& ,float );
-	FUNC3(canvas_item_add_rect,RID, const Rect2& , const Color& );
-	FUNC4(canvas_item_add_circle,RID, const Point2& , float ,const Color& );
-	FUNC6(canvas_item_add_texture_rect,RID, const Rect2& , RID ,bool ,const Color&,bool );
-	FUNC6(canvas_item_add_texture_rect_region,RID, const Rect2& , RID ,const Rect2& ,const Color&,bool );
-	FUNC8(canvas_item_add_style_box,RID, const Rect2& , const Rect2&, RID ,const Vector2& ,const Vector2&, bool ,const Color& );
-	FUNC6(canvas_item_add_primitive,RID, const Vector<Point2>& , const Vector<Color>& ,const Vector<Point2>& , RID ,float );
-	FUNC5(canvas_item_add_polygon,RID, const Vector<Point2>& , const Vector<Color>& ,const Vector<Point2>& , RID );
-	FUNC7(canvas_item_add_triangle_array,RID, const Vector<int>& , const Vector<Point2>& , const Vector<Color>& ,const Vector<Point2>& , RID , int );
-	FUNC7(canvas_item_add_triangle_array_ptr,RID, int , const int* , const Point2* , const Color* ,const Point2* , RID );
+	FUNC5(canvas_item_add_line, RID, const Point2 &, const Point2 &, const Color &, float);
+	FUNC3(canvas_item_add_rect, RID, const Rect2 &, const Color &);
+	FUNC4(canvas_item_add_circle, RID, const Point2 &, float, const Color &);
+	FUNC6(canvas_item_add_texture_rect, RID, const Rect2 &, RID, bool, const Color &, bool);
+	FUNC6(canvas_item_add_texture_rect_region, RID, const Rect2 &, RID, const Rect2 &, const Color &, bool);
+	FUNC8(canvas_item_add_style_box, RID, const Rect2 &, const Rect2 &, RID, const Vector2 &, const Vector2 &, bool, const Color &);
+	FUNC6(canvas_item_add_primitive, RID, const Vector<Point2> &, const Vector<Color> &, const Vector<Point2> &, RID, float);
+	FUNC5(canvas_item_add_polygon, RID, const Vector<Point2> &, const Vector<Color> &, const Vector<Point2> &, RID);
+	FUNC7(canvas_item_add_triangle_array, RID, const Vector<int> &, const Vector<Point2> &, const Vector<Color> &, const Vector<Point2> &, RID, int);
+	FUNC7(canvas_item_add_triangle_array_ptr, RID, int, const int *, const Point2 *, const Color *, const Point2 *, RID);
 
+	FUNC2(canvas_item_add_set_transform, RID, const Matrix32 &);
+	FUNC2(canvas_item_add_set_blend_mode, RID, MaterialBlendMode);
+	FUNC2(canvas_item_add_clip_ignore, RID, bool);
 
-	FUNC2(canvas_item_add_set_transform,RID,const Matrix32& );
-	FUNC2(canvas_item_add_set_blend_mode,RID, MaterialBlendMode );
-	FUNC2(canvas_item_add_clip_ignore,RID, bool );
+	FUNC2(canvas_item_set_sort_children_by_y, RID, bool);
+	FUNC2(canvas_item_set_z, RID, int);
+	FUNC2(canvas_item_set_z_as_relative_to_parent, RID, bool);
+	FUNC3(canvas_item_set_copy_to_backbuffer, RID, bool, const Rect2 &);
 
-	FUNC2(canvas_item_set_sort_children_by_y,RID,bool);
-	FUNC2(canvas_item_set_z,RID,int);
-	FUNC2(canvas_item_set_z_as_relative_to_parent,RID,bool);
-	FUNC3(canvas_item_set_copy_to_backbuffer,RID,bool,const Rect2&);
+	FUNC2(canvas_item_set_material, RID, RID);
 
+	FUNC2(canvas_item_set_use_parent_material, RID, bool);
 
-	FUNC2(canvas_item_set_material,RID, RID );
-
-	FUNC2(canvas_item_set_use_parent_material,RID, bool );
-
-	FUNC1(canvas_item_clear,RID);
-	FUNC1(canvas_item_raise,RID);
+	FUNC1(canvas_item_clear, RID);
+	FUNC1(canvas_item_raise, RID);
 
 	/* CANVAS LIGHT */
-	FUNC0R(RID,canvas_light_create);
-	FUNC2(canvas_light_attach_to_canvas,RID,RID);
-	FUNC2(canvas_light_set_enabled,RID,bool);
-	FUNC2(canvas_light_set_transform,RID,const Matrix32&);
-	FUNC2(canvas_light_set_scale,RID,float);
-	FUNC2(canvas_light_set_texture,RID,RID);
-	FUNC2(canvas_light_set_texture_offset,RID,const Vector2&);
-	FUNC2(canvas_light_set_color,RID,const Color&);
-	FUNC2(canvas_light_set_height,RID,float);
-	FUNC2(canvas_light_set_energy,RID,float);
-	FUNC3(canvas_light_set_layer_range,RID,int,int);
-	FUNC3(canvas_light_set_z_range,RID,int,int);
-	FUNC2(canvas_light_set_item_mask,RID,int);
-	FUNC2(canvas_light_set_item_shadow_mask,RID,int);
-
-	FUNC2(canvas_light_set_mode,RID,CanvasLightMode);
-	FUNC2(canvas_light_set_shadow_enabled,RID,bool);
-	FUNC2(canvas_light_set_shadow_buffer_size,RID,int);
-	FUNC2(canvas_light_set_shadow_esm_multiplier,RID,float);
-	FUNC2(canvas_light_set_shadow_color,RID,const Color&);
-
+	FUNC0R(RID, canvas_light_create);
+	FUNC2(canvas_light_attach_to_canvas, RID, RID);
+	FUNC2(canvas_light_set_enabled, RID, bool);
+	FUNC2(canvas_light_set_transform, RID, const Matrix32 &);
+	FUNC2(canvas_light_set_scale, RID, float);
+	FUNC2(canvas_light_set_texture, RID, RID);
+	FUNC2(canvas_light_set_texture_offset, RID, const Vector2 &);
+	FUNC2(canvas_light_set_color, RID, const Color &);
+	FUNC2(canvas_light_set_height, RID, float);
+	FUNC2(canvas_light_set_energy, RID, float);
+	FUNC3(canvas_light_set_layer_range, RID, int, int);
+	FUNC3(canvas_light_set_z_range, RID, int, int);
+	FUNC2(canvas_light_set_item_mask, RID, int);
+	FUNC2(canvas_light_set_item_shadow_mask, RID, int);
 
+	FUNC2(canvas_light_set_mode, RID, CanvasLightMode);
+	FUNC2(canvas_light_set_shadow_enabled, RID, bool);
+	FUNC2(canvas_light_set_shadow_buffer_size, RID, int);
+	FUNC2(canvas_light_set_shadow_esm_multiplier, RID, float);
+	FUNC2(canvas_light_set_shadow_color, RID, const Color &);
 
 	/* CANVAS OCCLUDER */
 
-	FUNC0R(RID,canvas_light_occluder_create);
-	FUNC2(canvas_light_occluder_attach_to_canvas,RID,RID);
-	FUNC2(canvas_light_occluder_set_enabled,RID,bool);
-	FUNC2(canvas_light_occluder_set_polygon,RID,RID);
-	FUNC2(canvas_light_occluder_set_transform,RID,const Matrix32&);
-	FUNC2(canvas_light_occluder_set_light_mask,RID,int);
+	FUNC0R(RID, canvas_light_occluder_create);
+	FUNC2(canvas_light_occluder_attach_to_canvas, RID, RID);
+	FUNC2(canvas_light_occluder_set_enabled, RID, bool);
+	FUNC2(canvas_light_occluder_set_polygon, RID, RID);
+	FUNC2(canvas_light_occluder_set_transform, RID, const Matrix32 &);
+	FUNC2(canvas_light_occluder_set_light_mask, RID, int);
 
-
-	FUNC0R(RID,canvas_occluder_polygon_create);
-	FUNC3(canvas_occluder_polygon_set_shape,RID,const DVector<Vector2>&,bool);
-	FUNC2(canvas_occluder_polygon_set_shape_as_lines,RID,const DVector<Vector2>&);
-	FUNC2(canvas_occluder_polygon_set_cull_mode,RID,CanvasOccluderPolygonCullMode);
+	FUNC0R(RID, canvas_occluder_polygon_create);
+	FUNC3(canvas_occluder_polygon_set_shape, RID, const DVector<Vector2> &, bool);
+	FUNC2(canvas_occluder_polygon_set_shape_as_lines, RID, const DVector<Vector2> &);
+	FUNC2(canvas_occluder_polygon_set_cull_mode, RID, CanvasOccluderPolygonCullMode);
 
 	/* CANVAS MATERIAL */
 
-	FUNC0R(RID,canvas_item_material_create);
-	FUNC2(canvas_item_material_set_shader,RID,RID);
-	FUNC3(canvas_item_material_set_shader_param,RID,const StringName&,const Variant&);
-	FUNC2RC(Variant,canvas_item_material_get_shader_param,RID,const StringName&);
-	FUNC2(canvas_item_material_set_shading_mode,RID,CanvasItemShadingMode);
+	FUNC0R(RID, canvas_item_material_create);
+	FUNC2(canvas_item_material_set_shader, RID, RID);
+	FUNC3(canvas_item_material_set_shader_param, RID, const StringName &, const Variant &);
+	FUNC2RC(Variant, canvas_item_material_get_shader_param, RID, const StringName &);
+	FUNC2(canvas_item_material_set_shading_mode, RID, CanvasItemShadingMode);
 
 	/* CURSOR */
-	FUNC2(cursor_set_rotation,float , int ); // radians
-	FUNC4(cursor_set_texture,RID , const Point2 &, int, const Rect2 &);
-	FUNC2(cursor_set_visible,bool , int );
-	FUNC2(cursor_set_pos,const Point2& , int );
+	FUNC2(cursor_set_rotation, float, int); // radians
+	FUNC4(cursor_set_texture, RID, const Point2 &, int, const Rect2 &);
+	FUNC2(cursor_set_visible, bool, int);
+	FUNC2(cursor_set_pos, const Point2 &, int);
 
 	/* BLACK BARS */
 
-	FUNC4(black_bars_set_margins,int , int , int , int );
-	FUNC4(black_bars_set_images,RID , RID , RID , RID );
+	FUNC4(black_bars_set_margins, int, int, int, int);
+	FUNC4(black_bars_set_images, RID, RID, RID, RID);
 
 	/* FREE */
 
-	FUNC1(free,RID);
+	FUNC1(free, RID);
 
 	/* CUSTOM SHADE MODEL */
 
-	FUNC2(custom_shade_model_set_shader,int , RID );
-	FUNC1RC(RID,custom_shade_model_get_shader,int );
-	FUNC2(custom_shade_model_set_name,int , const String& );
-	FUNC1RC(String,custom_shade_model_get_name,int );
-	FUNC2(custom_shade_model_set_param_info,int , const List<PropertyInfo>& );
-	FUNC2SC(custom_shade_model_get_param_info,int , List<PropertyInfo>* );
+	FUNC2(custom_shade_model_set_shader, int, RID);
+	FUNC1RC(RID, custom_shade_model_get_shader, int);
+	FUNC2(custom_shade_model_set_name, int, const String &);
+	FUNC1RC(String, custom_shade_model_get_name, int);
+	FUNC2(custom_shade_model_set_param_info, int, const List<PropertyInfo> &);
+	FUNC2SC(custom_shade_model_get_param_info, int, List<PropertyInfo> *);
 
 	/* EVENT QUEUING */
 
-
 	virtual void init();
 	virtual void finish();
 	virtual void draw();
 	virtual void sync();
-	FUNC0RC(bool,has_changed);
+	FUNC0RC(bool, has_changed);
 
 	/* RENDER INFO */
 
-	FUNC1R(int,get_render_info,RenderInfo );
+	FUNC1R(int, get_render_info, RenderInfo);
 	virtual bool has_feature(Features p_feature) const { return visual_server->has_feature(p_feature); }
 
-	FUNC3(set_boot_image,const Image& , const Color&,bool );
-	FUNC1(set_default_clear_color,const Color& );
-	FUNC0RC(Color,get_default_clear_color );
+	FUNC3(set_boot_image, const Image &, const Color &, bool);
+	FUNC1(set_default_clear_color, const Color &);
+	FUNC0RC(Color, get_default_clear_color);
 
-	FUNC0R(RID,get_test_cube );
+	FUNC0R(RID, get_test_cube);
 
-
-	VisualServerWrapMT(VisualServer* p_contained,bool p_create_thread);
+	VisualServerWrapMT(VisualServer *p_contained, bool p_create_thread);
 	~VisualServerWrapMT();
 
 #undef ServerName
 #undef ServerNameWrapMT
 #undef server_name
-
 };
 
 #ifdef DEBUG_SYNC