A Whole New World (clang-format edition)

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

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

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

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

1 files changed, 377 insertions, 437 deletions

diff --git a/scene/2d/particles_2d.cpp b/scene/2d/particles_2d.cpp
index 77ace0348a..c9d5bebe56 100644
--- a/scene/2d/particles_2d.cpp
+++ b/scene/2d/particles_2d.cpp
@@ -29,11 +29,9 @@
 #include "particles_2d.h"
 #include "scene/scene_string_names.h"
 
-
-
 void ParticleAttractor2D::_notification(int p_what) {
 
-	switch(p_what)	 {
+	switch (p_what) {
 
 		case NOTIFICATION_ENTER_TREE: {
 
@@ -46,16 +44,16 @@ void ParticleAttractor2D::_notification(int p_what) {
 				return;
 
 			Vector2 pv;
-			float dr = MIN(disable_radius,radius);
-			for(int i=0;i<=32;i++) {
-				Vector2 v(Math::sin(i/32.0*Math_PI*2),Math::cos(i/32.0*Math_PI*2));
-				if (i>0) {
-					draw_line(pv*radius,v*radius,Color(0,0,0.5,0.9));
-					if (dr>0) {
-						draw_line(pv*dr,v*dr,Color(0.5,0,0.0,0.9));
+			float dr = MIN(disable_radius, radius);
+			for (int i = 0; i <= 32; i++) {
+				Vector2 v(Math::sin(i / 32.0 * Math_PI * 2), Math::cos(i / 32.0 * Math_PI * 2));
+				if (i > 0) {
+					draw_line(pv * radius, v * radius, Color(0, 0, 0.5, 0.9));
+					if (dr > 0) {
+						draw_line(pv * dr, v * dr, Color(0.5, 0, 0.0, 0.9));
 					}
 				}
-				pv=v;
+				pv = v;
 			}
 
 		} break;
@@ -72,7 +70,7 @@ void ParticleAttractor2D::_owner_exited() {
 
 	ERR_FAIL_COND(!owner);
 	owner->attractors.erase(this);
-	owner=NULL;
+	owner = NULL;
 }
 
 void ParticleAttractor2D::_update_owner() {
@@ -93,63 +91,59 @@ void ParticleAttractor2D::_update_owner() {
 	_set_owner(pn);
 }
 
-void ParticleAttractor2D::_set_owner(Particles2D* p_owner) {
+void ParticleAttractor2D::_set_owner(Particles2D *p_owner) {
 
-	if (owner==p_owner)
+	if (owner == p_owner)
 		return;
 
 	if (owner) {
-		owner->disconnect("tree_exited",this,"_owner_exited");
+		owner->disconnect("tree_exited", this, "_owner_exited");
 		owner->attractors.erase(this);
-		owner=NULL;
+		owner = NULL;
 	}
-	owner=p_owner;
+	owner = p_owner;
 
 	if (owner) {
 
-		owner->connect("tree_exited",this,"_owner_exited",varray(),CONNECT_ONESHOT);
+		owner->connect("tree_exited", this, "_owner_exited", varray(), CONNECT_ONESHOT);
 		owner->attractors.insert(this);
 	}
 }
 
 void ParticleAttractor2D::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_enabled","enabled"),&ParticleAttractor2D::set_enabled);
-	ClassDB::bind_method(D_METHOD("is_enabled"),&ParticleAttractor2D::is_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_radius","radius"),&ParticleAttractor2D::set_radius);
-	ClassDB::bind_method(D_METHOD("get_radius"),&ParticleAttractor2D::get_radius);
-
-	ClassDB::bind_method(D_METHOD("set_disable_radius","radius"),&ParticleAttractor2D::set_disable_radius);
-	ClassDB::bind_method(D_METHOD("get_disable_radius"),&ParticleAttractor2D::get_disable_radius);
+	ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &ParticleAttractor2D::set_enabled);
+	ClassDB::bind_method(D_METHOD("is_enabled"), &ParticleAttractor2D::is_enabled);
 
-	ClassDB::bind_method(D_METHOD("set_gravity","gravity"),&ParticleAttractor2D::set_gravity);
-	ClassDB::bind_method(D_METHOD("get_gravity"),&ParticleAttractor2D::get_gravity);
+	ClassDB::bind_method(D_METHOD("set_radius", "radius"), &ParticleAttractor2D::set_radius);
+	ClassDB::bind_method(D_METHOD("get_radius"), &ParticleAttractor2D::get_radius);
 
-	ClassDB::bind_method(D_METHOD("set_absorption","absorption"),&ParticleAttractor2D::set_absorption);
-	ClassDB::bind_method(D_METHOD("get_absorption"),&ParticleAttractor2D::get_absorption);
+	ClassDB::bind_method(D_METHOD("set_disable_radius", "radius"), &ParticleAttractor2D::set_disable_radius);
+	ClassDB::bind_method(D_METHOD("get_disable_radius"), &ParticleAttractor2D::get_disable_radius);
 
-	ClassDB::bind_method(D_METHOD("set_particles_path","path"),&ParticleAttractor2D::set_particles_path);
-	ClassDB::bind_method(D_METHOD("get_particles_path"),&ParticleAttractor2D::get_particles_path);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"enabled"),"set_enabled","is_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"radius",PROPERTY_HINT_RANGE,"0.1,16000,0.1"),"set_radius","get_radius");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"disable_radius",PROPERTY_HINT_RANGE,"0.1,16000,0.1"),"set_disable_radius","get_disable_radius");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"gravity",PROPERTY_HINT_RANGE,"-512,512,0.01"),"set_gravity","get_gravity");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"absorption",PROPERTY_HINT_RANGE,"0,512,0.01"),"set_absorption","get_absorption");
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"particles_path",PROPERTY_HINT_RESOURCE_TYPE,"Particles2D"),"set_particles_path","get_particles_path");
+	ClassDB::bind_method(D_METHOD("set_gravity", "gravity"), &ParticleAttractor2D::set_gravity);
+	ClassDB::bind_method(D_METHOD("get_gravity"), &ParticleAttractor2D::get_gravity);
 
+	ClassDB::bind_method(D_METHOD("set_absorption", "absorption"), &ParticleAttractor2D::set_absorption);
+	ClassDB::bind_method(D_METHOD("get_absorption"), &ParticleAttractor2D::get_absorption);
 
+	ClassDB::bind_method(D_METHOD("set_particles_path", "path"), &ParticleAttractor2D::set_particles_path);
+	ClassDB::bind_method(D_METHOD("get_particles_path"), &ParticleAttractor2D::get_particles_path);
 
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enabled"), "set_enabled", "is_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius", PROPERTY_HINT_RANGE, "0.1,16000,0.1"), "set_radius", "get_radius");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "disable_radius", PROPERTY_HINT_RANGE, "0.1,16000,0.1"), "set_disable_radius", "get_disable_radius");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "gravity", PROPERTY_HINT_RANGE, "-512,512,0.01"), "set_gravity", "get_gravity");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "absorption", PROPERTY_HINT_RANGE, "0,512,0.01"), "set_absorption", "get_absorption");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "particles_path", PROPERTY_HINT_RESOURCE_TYPE, "Particles2D"), "set_particles_path", "get_particles_path");
 }
 
-
 void ParticleAttractor2D::set_enabled(bool p_enabled) {
 
-	enabled=p_enabled;
+	enabled = p_enabled;
 }
 
-bool ParticleAttractor2D::is_enabled() const{
+bool ParticleAttractor2D::is_enabled() const {
 
 	return enabled;
 }
@@ -177,8 +171,7 @@ float ParticleAttractor2D::get_disable_radius() const {
 
 void ParticleAttractor2D::set_gravity(float p_gravity) {
 
-	gravity=p_gravity;
-
+	gravity = p_gravity;
 }
 float ParticleAttractor2D::get_gravity() const {
 
@@ -187,8 +180,7 @@ float ParticleAttractor2D::get_gravity() const {
 
 void ParticleAttractor2D::set_absorption(float p_absorption) {
 
-	absorption=p_absorption;
-
+	absorption = p_absorption;
 }
 float ParticleAttractor2D::get_absorption() const {
 
@@ -197,7 +189,7 @@ float ParticleAttractor2D::get_absorption() const {
 
 void ParticleAttractor2D::set_particles_path(NodePath p_path) {
 
-	path=p_path;
+	path = p_path;
 	_update_owner();
 	update_configuration_warning();
 }
@@ -217,13 +209,13 @@ String ParticleAttractor2D::get_configuration_warning() const {
 
 ParticleAttractor2D::ParticleAttractor2D() {
 
-	owner=NULL;
-	radius=50;
-	disable_radius=0;
-	gravity=100;
-	absorption=0;
-	path=String("..");
-	enabled=true;
+	owner = NULL;
+	radius = 50;
+	disable_radius = 0;
+	gravity = 100;
+	absorption = 0;
+	path = String("..");
+	enabled = true;
 }
 
 /****************************************/
@@ -236,12 +228,12 @@ _FORCE_INLINE_ static float _rand_from_seed(uint64_t *seed) {
 
 void Particles2D::_process_particles(float p_delta) {
 
-	if (particles.size()==0 || lifetime==0)
+	if (particles.size() == 0 || lifetime == 0)
 		return;
 
-	p_delta*=time_scale;
+	p_delta *= time_scale;
 
-	float frame_time=p_delta;
+	float frame_time = p_delta;
 
 	if (emit_timeout > 0) {
 		time_to_live -= frame_time;
@@ -252,114 +244,110 @@ void Particles2D::_process_particles(float p_delta) {
 		};
 	};
 
-	float next_time = time+frame_time;
+	float next_time = time + frame_time;
 
 	if (next_time > lifetime)
-		next_time=Math::fmod(next_time,lifetime);
-
+		next_time = Math::fmod(next_time, lifetime);
 
-	Particle *pdata=&particles[0];
-	int particle_count=particles.size();
+	Particle *pdata = &particles[0];
+	int particle_count = particles.size();
 	Transform2D xform;
 	if (!local_space)
-		xform=get_global_transform();
+		xform = get_global_transform();
 
-	active_count=0;
+	active_count = 0;
 
 	PoolVector<Point2>::Read r;
-	int emission_point_count=0;
+	int emission_point_count = 0;
 	if (emission_points.size()) {
 
-		emission_point_count=emission_points.size();
-		r=emission_points.read();
+		emission_point_count = emission_points.size();
+		r = emission_points.read();
 	}
 
-	int attractor_count=0;
-	AttractorCache *attractor_ptr=NULL;
+	int attractor_count = 0;
+	AttractorCache *attractor_ptr = NULL;
 
 	if (attractors.size()) {
-		if (attractors.size()!=attractor_cache.size()) {
+		if (attractors.size() != attractor_cache.size()) {
 			attractor_cache.resize(attractors.size());
 		}
 
-		int idx=0;
+		int idx = 0;
 		Transform2D m;
 		if (local_space) {
-			m= get_global_transform().affine_inverse();
+			m = get_global_transform().affine_inverse();
 		}
-		for (Set<ParticleAttractor2D*>::Element *E=attractors.front();E;E=E->next()) {
+		for (Set<ParticleAttractor2D *>::Element *E = attractors.front(); E; E = E->next()) {
 
-			attractor_cache[idx].pos=m.xform( E->get()->get_global_position() );
-			attractor_cache[idx].attractor=E->get();
+			attractor_cache[idx].pos = m.xform(E->get()->get_global_position());
+			attractor_cache[idx].attractor = E->get();
 			idx++;
 		}
 
-		attractor_ptr=attractor_cache.ptr();
-		attractor_count=attractor_cache.size();
+		attractor_ptr = attractor_cache.ptr();
+		attractor_count = attractor_cache.size();
 	}
 
-	for(int i=0;i<particle_count;i++) {
+	for (int i = 0; i < particle_count; i++) {
 
-		Particle &p=pdata[i];
+		Particle &p = pdata[i];
 
 		float restart_time = (i * lifetime / particle_count) * explosiveness;
 
-		bool restart=false;
+		bool restart = false;
 
-		if ( next_time < time ) {
+		if (next_time < time) {
 
-			if (restart_time > time || restart_time < next_time )
-				restart=true;
+			if (restart_time > time || restart_time < next_time)
+				restart = true;
 
-		} else if (restart_time > time && restart_time < next_time ) {
-			restart=true;
+		} else if (restart_time > time && restart_time < next_time) {
+			restart = true;
 		}
 
 		if (restart) {
 
-
 			if (emitting) {
 
-				p.pos=emissor_offset;
+				p.pos = emissor_offset;
 				if (emission_point_count) {
 
-
-					Vector2 ep = r[Math::rand()%emission_point_count];
+					Vector2 ep = r[Math::rand() % emission_point_count];
 					if (!local_space) {
-						p.pos=xform.xform(p.pos+ep*extents);
+						p.pos = xform.xform(p.pos + ep * extents);
 					} else {
-						p.pos+=ep*extents;
+						p.pos += ep * extents;
 					}
 				} else {
 					if (!local_space) {
-						p.pos=xform.xform(p.pos+Vector2(Math::random(-extents.x,extents.x),Math::random(-extents.y,extents.y)));
+						p.pos = xform.xform(p.pos + Vector2(Math::random(-extents.x, extents.x), Math::random(-extents.y, extents.y)));
 					} else {
-						p.pos+=Vector2(Math::random(-extents.x,extents.x),Math::random(-extents.y,extents.y));
+						p.pos += Vector2(Math::random(-extents.x, extents.x), Math::random(-extents.y, extents.y));
 					}
 				}
-				p.seed=Math::rand() % 12345678;
-				uint64_t rand_seed=p.seed*(i+1);
+				p.seed = Math::rand() % 12345678;
+				uint64_t rand_seed = p.seed * (i + 1);
 
-				float angle = Math::deg2rad(param[PARAM_DIRECTION]+_rand_from_seed(&rand_seed)*param[PARAM_SPREAD]);
+				float angle = Math::deg2rad(param[PARAM_DIRECTION] + _rand_from_seed(&rand_seed) * param[PARAM_SPREAD]);
 
-				p.velocity=Vector2( Math::sin(angle), Math::cos(angle) );
+				p.velocity = Vector2(Math::sin(angle), Math::cos(angle));
 				if (!local_space) {
 
 					p.velocity = xform.basis_xform(p.velocity).normalized();
 				}
 
-				p.velocity*=param[PARAM_LINEAR_VELOCITY]+param[PARAM_LINEAR_VELOCITY]*_rand_from_seed(&rand_seed)*randomness[PARAM_LINEAR_VELOCITY];
-				p.velocity+=initial_velocity;
-				p.active=true;
-				p.rot=Math::deg2rad(param[PARAM_INITIAL_ANGLE]+param[PARAM_INITIAL_ANGLE]*randomness[PARAM_INITIAL_ANGLE]*_rand_from_seed(&rand_seed));
+				p.velocity *= param[PARAM_LINEAR_VELOCITY] + param[PARAM_LINEAR_VELOCITY] * _rand_from_seed(&rand_seed) * randomness[PARAM_LINEAR_VELOCITY];
+				p.velocity += initial_velocity;
+				p.active = true;
+				p.rot = Math::deg2rad(param[PARAM_INITIAL_ANGLE] + param[PARAM_INITIAL_ANGLE] * randomness[PARAM_INITIAL_ANGLE] * _rand_from_seed(&rand_seed));
 				active_count++;
 
-				p.frame=Math::fmod(param[PARAM_ANIM_INITIAL_POS]+randomness[PARAM_ANIM_INITIAL_POS]*_rand_from_seed(&rand_seed),1.0f);
-
+				p.frame = Math::fmod(param[PARAM_ANIM_INITIAL_POS] + randomness[PARAM_ANIM_INITIAL_POS] * _rand_from_seed(&rand_seed), 1.0f);
 
 			} else {
 
-				p.active=false;
+				p.active = false;
 			}
 
 		} else {
@@ -367,136 +355,122 @@ void Particles2D::_process_particles(float p_delta) {
 			if (!p.active)
 				continue;
 
-			uint64_t rand_seed=p.seed*(i+1);
+			uint64_t rand_seed = p.seed * (i + 1);
 
 			Vector2 force;
 
 			//apply gravity
-			float gravity_dir = Math::deg2rad( param[PARAM_GRAVITY_DIRECTION]+180*randomness[PARAM_GRAVITY_DIRECTION]*_rand_from_seed(&rand_seed));
-			force+=Vector2( Math::sin(gravity_dir), Math::cos(gravity_dir) ) * (param[PARAM_GRAVITY_STRENGTH]+param[PARAM_GRAVITY_STRENGTH]*randomness[PARAM_GRAVITY_STRENGTH]*_rand_from_seed(&rand_seed));
+			float gravity_dir = Math::deg2rad(param[PARAM_GRAVITY_DIRECTION] + 180 * randomness[PARAM_GRAVITY_DIRECTION] * _rand_from_seed(&rand_seed));
+			force += Vector2(Math::sin(gravity_dir), Math::cos(gravity_dir)) * (param[PARAM_GRAVITY_STRENGTH] + param[PARAM_GRAVITY_STRENGTH] * randomness[PARAM_GRAVITY_STRENGTH] * _rand_from_seed(&rand_seed));
 			//apply radial
 			Vector2 rvec = (p.pos - emissor_offset).normalized();
-			force+=rvec*(param[PARAM_RADIAL_ACCEL]+param[PARAM_RADIAL_ACCEL]*randomness[PARAM_RADIAL_ACCEL]*_rand_from_seed(&rand_seed));
+			force += rvec * (param[PARAM_RADIAL_ACCEL] + param[PARAM_RADIAL_ACCEL] * randomness[PARAM_RADIAL_ACCEL] * _rand_from_seed(&rand_seed));
 			//apply orbit
-			float orbitvel = (param[PARAM_ORBIT_VELOCITY]+param[PARAM_ORBIT_VELOCITY]*randomness[PARAM_ORBIT_VELOCITY]*_rand_from_seed(&rand_seed));
-			if (orbitvel!=0) {
+			float orbitvel = (param[PARAM_ORBIT_VELOCITY] + param[PARAM_ORBIT_VELOCITY] * randomness[PARAM_ORBIT_VELOCITY] * _rand_from_seed(&rand_seed));
+			if (orbitvel != 0) {
 				Vector2 rel = p.pos - xform.elements[2];
-				Transform2D rot(orbitvel*frame_time,Vector2());
+				Transform2D rot(orbitvel * frame_time, Vector2());
 				p.pos = rot.xform(rel) + xform.elements[2];
-
 			}
 
-			Vector2 tvec=rvec.tangent();
-			force+=tvec*(param[PARAM_TANGENTIAL_ACCEL]+param[PARAM_TANGENTIAL_ACCEL]*randomness[PARAM_TANGENTIAL_ACCEL]*_rand_from_seed(&rand_seed));
+			Vector2 tvec = rvec.tangent();
+			force += tvec * (param[PARAM_TANGENTIAL_ACCEL] + param[PARAM_TANGENTIAL_ACCEL] * randomness[PARAM_TANGENTIAL_ACCEL] * _rand_from_seed(&rand_seed));
 
-			for(int j=0;j<attractor_count;j++) {
+			for (int j = 0; j < attractor_count; j++) {
 
 				Vector2 vec = (attractor_ptr[j].pos - p.pos);
 				float vl = vec.length();
 
-				if (!attractor_ptr[j].attractor->enabled ||  vl==0 || vl > attractor_ptr[j].attractor->radius)
+				if (!attractor_ptr[j].attractor->enabled || vl == 0 || vl > attractor_ptr[j].attractor->radius)
 					continue;
 
-
-
-				force+=vec*attractor_ptr[j].attractor->gravity;
+				force += vec * attractor_ptr[j].attractor->gravity;
 				float fvl = p.velocity.length();
 				if (fvl && attractor_ptr[j].attractor->absorption) {
 					Vector2 target = vec.normalized();
-					p.velocity = p.velocity.normalized().linear_interpolate(target,MIN(frame_time*attractor_ptr[j].attractor->absorption,1))*fvl;
+					p.velocity = p.velocity.normalized().linear_interpolate(target, MIN(frame_time * attractor_ptr[j].attractor->absorption, 1)) * fvl;
 				}
 
 				if (attractor_ptr[j].attractor->disable_radius && vl < attractor_ptr[j].attractor->disable_radius) {
-					p.active=false;
+					p.active = false;
 				}
 			}
 
-			p.velocity+=force*frame_time;
+			p.velocity += force * frame_time;
 
 			if (param[PARAM_DAMPING]) {
-				float dmp = param[PARAM_DAMPING]+param[PARAM_DAMPING]*randomness[PARAM_DAMPING]*_rand_from_seed(&rand_seed);
+				float dmp = param[PARAM_DAMPING] + param[PARAM_DAMPING] * randomness[PARAM_DAMPING] * _rand_from_seed(&rand_seed);
 				float v = p.velocity.length();
 				v -= dmp * frame_time;
-				if (v<=0) {
-					p.velocity=Vector2();
+				if (v <= 0) {
+					p.velocity = Vector2();
 				} else {
-					p.velocity=p.velocity.normalized() * v;
+					p.velocity = p.velocity.normalized() * v;
 				}
-
 			}
 
-			p.pos+=p.velocity*frame_time;
-			p.rot+=Math::lerp(param[PARAM_SPIN_VELOCITY],param[PARAM_SPIN_VELOCITY]*randomness[PARAM_SPIN_VELOCITY]*_rand_from_seed(&rand_seed),randomness[PARAM_SPIN_VELOCITY])*frame_time;
-			float anim_spd=param[PARAM_ANIM_SPEED_SCALE]+param[PARAM_ANIM_SPEED_SCALE]*randomness[PARAM_ANIM_SPEED_SCALE]*_rand_from_seed(&rand_seed);
-			p.frame=Math::fposmod(p.frame+(frame_time/lifetime)*anim_spd,1.0f);
+			p.pos += p.velocity * frame_time;
+			p.rot += Math::lerp(param[PARAM_SPIN_VELOCITY], param[PARAM_SPIN_VELOCITY] * randomness[PARAM_SPIN_VELOCITY] * _rand_from_seed(&rand_seed), randomness[PARAM_SPIN_VELOCITY]) * frame_time;
+			float anim_spd = param[PARAM_ANIM_SPEED_SCALE] + param[PARAM_ANIM_SPEED_SCALE] * randomness[PARAM_ANIM_SPEED_SCALE] * _rand_from_seed(&rand_seed);
+			p.frame = Math::fposmod(p.frame + (frame_time / lifetime) * anim_spd, 1.0f);
 
 			active_count++;
-
 		}
-
-
 	}
 
-
-
-	time=Math::fmod( time+frame_time, lifetime );
-	if (!emitting && active_count==0) {
+	time = Math::fmod(time + frame_time, lifetime);
+	if (!emitting && active_count == 0) {
 		emit_signal(SceneStringNames::get_singleton()->emission_finished);
 		set_process(false);
 		set_fixed_process(false);
 	}
 
 	update();
-
-
 }
 
-
 void Particles2D::_notification(int p_what) {
 
-	switch(p_what) {
+	switch (p_what) {
 
 		case NOTIFICATION_PROCESS: {
 
-			_process_particles( get_process_delta_time() );
+			_process_particles(get_process_delta_time());
 		} break;
 
 		case NOTIFICATION_FIXED_PROCESS: {
 
-			_process_particles( get_fixed_process_delta_time() );
+			_process_particles(get_fixed_process_delta_time());
 		} break;
 
 		case NOTIFICATION_ENTER_TREE: {
 
-			float ppt=preprocess;
-			while(ppt>0) {
+			float ppt = preprocess;
+			while (ppt > 0) {
 				_process_particles(0.1);
-				ppt-=0.1;
+				ppt -= 0.1;
 			}
 		} break;
 		case NOTIFICATION_DRAW: {
 
-
-			if (particles.size()==0 || lifetime==0)
+			if (particles.size() == 0 || lifetime == 0)
 				return;
 
-			RID ci=get_canvas_item();
-			Size2 size(1,1);
+			RID ci = get_canvas_item();
+			Size2 size(1, 1);
 			Point2 center;
-			int total_frames=1;
+			int total_frames = 1;
 
 			if (!texture.is_null()) {
-				size=texture->get_size();
-				size.x/=h_frames;
-				size.y/=v_frames;
-				total_frames=h_frames*v_frames;
+				size = texture->get_size();
+				size.x /= h_frames;
+				size.y /= v_frames;
+				total_frames = h_frames * v_frames;
 			}
 
+			float time_pos = (time / lifetime);
 
-			float time_pos=(time/lifetime);
-
-			Particle *pdata=&particles[0];
-			int particle_count=particles.size();
+			Particle *pdata = &particles[0];
+			int particle_count = particles.size();
 
 			RID texrid;
 
@@ -505,64 +479,61 @@ void Particles2D::_notification(int p_what) {
 
 			Transform2D invxform;
 			if (!local_space)
-				invxform=get_global_transform().affine_inverse();
+				invxform = get_global_transform().affine_inverse();
 
 			int start_particle = (int)(time * (float)particle_count / lifetime);
 
-			for (int id=0;id<particle_count;++id) {
+			for (int id = 0; id < particle_count; ++id) {
 				int i = start_particle + id;
 				if (i >= particle_count) {
 					i -= particle_count;
 				}
 
-				Particle &p=pdata[i];
+				Particle &p = pdata[i];
 				if (!p.active)
 					continue;
 
-				float ptime = ((float)i / particle_count)*explosiveness;
+				float ptime = ((float)i / particle_count) * explosiveness;
 
-				if (ptime<time_pos)
-					ptime=time_pos-ptime;
+				if (ptime < time_pos)
+					ptime = time_pos - ptime;
 				else
-					ptime=(1.0-ptime)+time_pos;
+					ptime = (1.0 - ptime) + time_pos;
 
-				uint64_t rand_seed=p.seed*(i+1);
+				uint64_t rand_seed = p.seed * (i + 1);
 
 				Color color;
 
-				if(color_ramp.is_valid())
-				{
+				if (color_ramp.is_valid()) {
 					color = color_ramp->get_color_at_offset(ptime);
-				} else
-				{
+				} else {
 					color = default_color;
 				}
 
-
 				{
-					float huerand=_rand_from_seed(&rand_seed);
+					float huerand = _rand_from_seed(&rand_seed);
 					float huerot = param[PARAM_HUE_VARIATION] + randomness[PARAM_HUE_VARIATION] * huerand;
 
 					if (Math::abs(huerot) > CMP_EPSILON) {
 
-						float h=color.get_h();
-						float s=color.get_s();
-						float v=color.get_v();
-						float a=color.a;
+						float h = color.get_h();
+						float s = color.get_s();
+						float v = color.get_v();
+						float a = color.a;
 						//float preh=h;
-						h+=huerot;
-						h=Math::abs(Math::fposmod(h,1.0f));
+						h += huerot;
+						h = Math::abs(Math::fposmod(h, 1.0f));
 						//print_line("rand: "+rtos(randomness[PARAM_HUE_VARIATION])+" rand: "+rtos(huerand));
 						//print_line(itos(i)+":hue: "+rtos(preh)+" + "+rtos(huerot)+" = "+rtos(h));
-						color.set_hsv(h,s,v);
-						color.a=a;
+						color.set_hsv(h, s, v);
+						color.a = a;
 					}
 				}
 
-				float initial_size = param[PARAM_INITIAL_SIZE]+param[PARAM_INITIAL_SIZE]*_rand_from_seed(&rand_seed)*randomness[PARAM_INITIAL_SIZE];
-				float final_size = param[PARAM_FINAL_SIZE]+param[PARAM_FINAL_SIZE]*_rand_from_seed(&rand_seed)*randomness[PARAM_FINAL_SIZE];
+				float initial_size = param[PARAM_INITIAL_SIZE] + param[PARAM_INITIAL_SIZE] * _rand_from_seed(&rand_seed) * randomness[PARAM_INITIAL_SIZE];
+				float final_size = param[PARAM_FINAL_SIZE] + param[PARAM_FINAL_SIZE] * _rand_from_seed(&rand_seed) * randomness[PARAM_FINAL_SIZE];
 
-				float size_mult=initial_size*(1.0-ptime) + final_size*ptime;
+				float size_mult = initial_size * (1.0 - ptime) + final_size * ptime;
 
 				//Size2 rectsize=size * size_mult;
 				//rectsize=rectsize.floor();
@@ -574,57 +545,49 @@ void Particles2D::_notification(int p_what) {
 				if (p.rot) {
 
 					xform.set_rotation(p.rot);
-					xform.translate(-size*size_mult/2.0);
-					xform.elements[2]+=p.pos;
+					xform.translate(-size * size_mult / 2.0);
+					xform.elements[2] += p.pos;
 				} else {
-					xform.elements[2]=-size*size_mult/2.0;
-					xform.elements[2]+=p.pos;
+					xform.elements[2] = -size * size_mult / 2.0;
+					xform.elements[2] += p.pos;
 				}
 
 				if (!local_space) {
 					xform = invxform * xform;
 				}
 
+				xform.scale_basis(Size2(size_mult, size_mult));
 
-				xform.scale_basis(Size2(size_mult,size_mult));
-
-
-				VisualServer::get_singleton()->canvas_item_add_set_transform(ci,xform);
-
+				VisualServer::get_singleton()->canvas_item_add_set_transform(ci, xform);
 
 				if (texrid.is_valid()) {
 
 					Rect2 src_rect;
-					src_rect.size=size;
+					src_rect.size = size;
 
-					if (total_frames>1) {
-						int frame = Math::fast_ftoi(Math::floor(p.frame*total_frames)) % total_frames;
-						src_rect.pos.x = size.x * (frame%h_frames);
-						src_rect.pos.y = size.y * (frame/h_frames);
+					if (total_frames > 1) {
+						int frame = Math::fast_ftoi(Math::floor(p.frame * total_frames)) % total_frames;
+						src_rect.pos.x = size.x * (frame % h_frames);
+						src_rect.pos.y = size.y * (frame / h_frames);
 					}
 
 					if (flip_h)
-						src_rect.size.x=-src_rect.size.x;
+						src_rect.size.x = -src_rect.size.x;
 					if (flip_v)
-						src_rect.size.y=-src_rect.size.y;
+						src_rect.size.y = -src_rect.size.y;
 
-					texture->draw_rect_region(ci,Rect2(Point2(),size),src_rect,color);
+					texture->draw_rect_region(ci, Rect2(Point2(), size), src_rect, color);
 					//VisualServer::get_singleton()->canvas_item_add_texture_rect(ci,r,texrid,false,color);
 				} else {
-					VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2(),size),color);
-
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(), size), color);
 				}
-
 			}
 
-
 		} break;
-
 	}
-
 }
 
-static const char* _particlesframe_property_names[Particles2D::PARAM_MAX]={
+static const char *_particlesframe_property_names[Particles2D::PARAM_MAX] = {
 	"params/direction",
 	"params/spread",
 	"params/linear_velocity",
@@ -643,7 +606,7 @@ static const char* _particlesframe_property_names[Particles2D::PARAM_MAX]={
 	"params/anim_initial_pos",
 };
 
-static const char* _particlesframe_property_rnames[Particles2D::PARAM_MAX]={
+static const char *_particlesframe_property_rnames[Particles2D::PARAM_MAX] = {
 	"randomness/direction",
 	"randomness/spread",
 	"randomness/linear_velocity",
@@ -662,7 +625,7 @@ static const char* _particlesframe_property_rnames[Particles2D::PARAM_MAX]={
 	"randomness/anim_initial_pos",
 };
 
-static const char* _particlesframe_property_ranges[Particles2D::PARAM_MAX]={
+static const char *_particlesframe_property_ranges[Particles2D::PARAM_MAX] = {
 	"0,360,0.01",
 	"0,180,0.01",
 	"-1024,1024,0.01",
@@ -681,21 +644,20 @@ static const char* _particlesframe_property_ranges[Particles2D::PARAM_MAX]={
 	"0,1,0.01",
 };
 
-
 void Particles2D::set_emitting(bool p_emitting) {
 
-	if (emitting==p_emitting)
+	if (emitting == p_emitting)
 		return;
 
 	if (p_emitting) {
 
-		if (active_count==0)
-			time=0;
-		set_process(process_mode==PROCESS_IDLE);
-		set_fixed_process(process_mode==PROCESS_FIXED);
+		if (active_count == 0)
+			time = 0;
+		set_process(process_mode == PROCESS_IDLE);
+		set_fixed_process(process_mode == PROCESS_FIXED);
 		time_to_live = emit_timeout;
 	};
-	emitting=p_emitting;
+	emitting = p_emitting;
 	_change_notify("config/emitting");
 }
 
@@ -706,10 +668,10 @@ bool Particles2D::is_emitting() const {
 
 void Particles2D::set_process_mode(ProcessMode p_mode) {
 
-	process_mode=p_mode;
-	const bool should_process=emitting || active_count!=0;
-	set_process(should_process && process_mode==PROCESS_IDLE);
-	set_fixed_process(should_process && process_mode==PROCESS_FIXED);
+	process_mode = p_mode;
+	const bool should_process = emitting || active_count != 0;
+	set_process(should_process && process_mode == PROCESS_IDLE);
+	set_fixed_process(should_process && process_mode == PROCESS_FIXED);
 }
 
 Particles2D::ProcessMode Particles2D::get_process_mode() const {
@@ -719,7 +681,7 @@ Particles2D::ProcessMode Particles2D::get_process_mode() const {
 
 void Particles2D::set_amount(int p_amount) {
 
-	ERR_FAIL_INDEX(p_amount,1024+1);
+	ERR_FAIL_INDEX(p_amount, 1024 + 1);
 
 	particles.resize(p_amount);
 }
@@ -741,9 +703,9 @@ float Particles2D::get_emit_timeout() const {
 
 void Particles2D::set_lifetime(float p_lifetime) {
 
-	ERR_FAIL_INDEX(p_lifetime,3600+1);
+	ERR_FAIL_INDEX(p_lifetime, 3600 + 1);
 
-	lifetime=p_lifetime;
+	lifetime = p_lifetime;
 }
 float Particles2D::get_lifetime() const {
 
@@ -752,7 +714,7 @@ float Particles2D::get_lifetime() const {
 
 void Particles2D::set_time_scale(float p_time_scale) {
 
-	time_scale=p_time_scale;
+	time_scale = p_time_scale;
 }
 float Particles2D::get_time_scale() const {
 
@@ -761,42 +723,39 @@ float Particles2D::get_time_scale() const {
 
 void Particles2D::set_pre_process_time(float p_pre_process_time) {
 
-	preprocess=p_pre_process_time;
+	preprocess = p_pre_process_time;
 }
 
-float Particles2D::get_pre_process_time() const{
+float Particles2D::get_pre_process_time() const {
 
 	return preprocess;
 }
 
-
 void Particles2D::set_param(Parameter p_param, float p_value) {
 
-	ERR_FAIL_INDEX(p_param,PARAM_MAX);
-	param[p_param]=p_value;
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	param[p_param] = p_value;
 }
 float Particles2D::get_param(Parameter p_param) const {
 
-	ERR_FAIL_INDEX_V(p_param,PARAM_MAX,0);
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
 	return param[p_param];
 }
 
 void Particles2D::set_randomness(Parameter p_param, float p_value) {
 
-	ERR_FAIL_INDEX(p_param,PARAM_MAX);
-	randomness[p_param]=p_value;
-
+	ERR_FAIL_INDEX(p_param, PARAM_MAX);
+	randomness[p_param] = p_value;
 }
-float Particles2D::get_randomness(Parameter p_param) const  {
+float Particles2D::get_randomness(Parameter p_param) const {
 
-	ERR_FAIL_INDEX_V(p_param,PARAM_MAX,0);
+	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
 	return randomness[p_param];
-
 }
 
-void Particles2D::set_texture(const Ref<Texture>& p_texture) {
+void Particles2D::set_texture(const Ref<Texture> &p_texture) {
 
-	texture=p_texture;
+	texture = p_texture;
 }
 
 Ref<Texture> Particles2D::get_texture() const {
@@ -804,7 +763,7 @@ Ref<Texture> Particles2D::get_texture() const {
 	return texture;
 }
 
-void Particles2D::set_color(const Color& p_color) {
+void Particles2D::set_color(const Color &p_color) {
 
 	default_color = p_color;
 }
@@ -814,10 +773,9 @@ Color Particles2D::get_color() const {
 	return default_color;
 }
 
+void Particles2D::set_color_ramp(const Ref<ColorRamp> &p_color_ramp) {
 
-void Particles2D::set_color_ramp(const Ref<ColorRamp>& p_color_ramp) {
-
-	color_ramp=p_color_ramp;
+	color_ramp = p_color_ramp;
 }
 
 Ref<ColorRamp> Particles2D::get_color_ramp() const {
@@ -825,9 +783,9 @@ Ref<ColorRamp> Particles2D::get_color_ramp() const {
 	return color_ramp;
 }
 
-void Particles2D::set_emissor_offset(const Point2& p_offset) {
+void Particles2D::set_emissor_offset(const Point2 &p_offset) {
 
-	emissor_offset=p_offset;
+	emissor_offset = p_offset;
 }
 
 Point2 Particles2D::get_emissor_offset() const {
@@ -835,10 +793,9 @@ Point2 Particles2D::get_emissor_offset() const {
 	return emissor_offset;
 }
 
-
 void Particles2D::set_use_local_space(bool p_use) {
 
-	local_space=p_use;
+	local_space = p_use;
 }
 
 bool Particles2D::is_using_local_space() const {
@@ -851,12 +808,10 @@ void Particles2D::set_color_phases(int p_phases) {
 
 	//Create color ramp if we have 2 or more phases.
 	//Otherwise first phase phase will be assigned to default color.
-	if(p_phases > 1 && color_ramp.is_null())
-	{
-		color_ramp = Ref<ColorRamp>(memnew (ColorRamp()));
+	if (p_phases > 1 && color_ramp.is_null()) {
+		color_ramp = Ref<ColorRamp>(memnew(ColorRamp()));
 	}
-	if(color_ramp.is_valid())
-	{
+	if (color_ramp.is_valid()) {
 		color_ramp->get_points().resize(p_phases);
 	}
 }
@@ -864,24 +819,21 @@ void Particles2D::set_color_phases(int p_phases) {
 //Deprecated.
 int Particles2D::get_color_phases() const {
 
-	if(color_ramp.is_valid())
-	{
+	if (color_ramp.is_valid()) {
 		return color_ramp->get_points_count();
 	}
 	return 0;
 }
 
 //Deprecated. Converts color phases to color ramp
-void Particles2D::set_color_phase_color(int p_phase,const Color& p_color) {
+void Particles2D::set_color_phase_color(int p_phase, const Color &p_color) {
 
-	ERR_FAIL_INDEX(p_phase,MAX_COLOR_PHASES);
-	if(color_ramp.is_valid())
-	{
-		if(color_ramp->get_points_count() > p_phase)
+	ERR_FAIL_INDEX(p_phase, MAX_COLOR_PHASES);
+	if (color_ramp.is_valid()) {
+		if (color_ramp->get_points_count() > p_phase)
 			color_ramp->set_color(p_phase, p_color);
-	} else
-	{
-		if(p_phase == 0)
+	} else {
+		if (p_phase == 0)
 			default_color = p_color;
 	}
 }
@@ -889,20 +841,18 @@ void Particles2D::set_color_phase_color(int p_phase,const Color& p_color) {
 //Deprecated.
 Color Particles2D::get_color_phase_color(int p_phase) const {
 
-	ERR_FAIL_INDEX_V(p_phase,MAX_COLOR_PHASES,Color());
-	if(color_ramp.is_valid())
-	{
+	ERR_FAIL_INDEX_V(p_phase, MAX_COLOR_PHASES, Color());
+	if (color_ramp.is_valid()) {
 		return color_ramp->get_color(p_phase);
 	}
-	return Color(0,0,0,1);
+	return Color(0, 0, 0, 1);
 }
 
 //Deprecated. Converts color phases to color ramp
-void Particles2D::set_color_phase_pos(int p_phase,float p_pos) {
-	ERR_FAIL_INDEX(p_phase,MAX_COLOR_PHASES);
-	ERR_FAIL_COND(p_pos<0.0 || p_pos>1.0);
-	if(color_ramp.is_valid() && color_ramp->get_points_count() > p_phase)
-	{
+void Particles2D::set_color_phase_pos(int p_phase, float p_pos) {
+	ERR_FAIL_INDEX(p_phase, MAX_COLOR_PHASES);
+	ERR_FAIL_COND(p_pos < 0.0 || p_pos > 1.0);
+	if (color_ramp.is_valid() && color_ramp->get_points_count() > p_phase) {
 		return color_ramp->set_offset(p_phase, p_pos);
 	}
 }
@@ -910,17 +860,16 @@ void Particles2D::set_color_phase_pos(int p_phase,float p_pos) {
 //Deprecated.
 float Particles2D::get_color_phase_pos(int p_phase) const {
 
-	ERR_FAIL_INDEX_V(p_phase,MAX_COLOR_PHASES,0);
-	if(color_ramp.is_valid())
-	{
+	ERR_FAIL_INDEX_V(p_phase, MAX_COLOR_PHASES, 0);
+	if (color_ramp.is_valid()) {
 		return color_ramp->get_offset(p_phase);
 	}
 	return 0;
 }
 
-void Particles2D::set_emission_half_extents(const Vector2& p_extents) {
+void Particles2D::set_emission_half_extents(const Vector2 &p_extents) {
 
-	extents=p_extents;
+	extents = p_extents;
 }
 
 Vector2 Particles2D::get_emission_half_extents() const {
@@ -928,278 +877,269 @@ Vector2 Particles2D::get_emission_half_extents() const {
 	return extents;
 }
 
-void Particles2D::set_initial_velocity(const Vector2& p_velocity) {
-
+void Particles2D::set_initial_velocity(const Vector2 &p_velocity) {
 
-	initial_velocity=p_velocity;
+	initial_velocity = p_velocity;
 }
-Vector2 Particles2D::get_initial_velocity() const{
+Vector2 Particles2D::get_initial_velocity() const {
 
 	return initial_velocity;
 }
 
-
 void Particles2D::pre_process(float p_delta) {
 
 	_process_particles(p_delta);
 }
 
-
 void Particles2D::set_explosiveness(float p_value) {
 
-	explosiveness=p_value;
+	explosiveness = p_value;
 }
 
-float Particles2D::get_explosiveness() const{
+float Particles2D::get_explosiveness() const {
 
 	return explosiveness;
 }
 
 void Particles2D::set_flip_h(bool p_flip) {
 
-	flip_h=p_flip;
+	flip_h = p_flip;
 }
 
-bool Particles2D::is_flipped_h() const{
+bool Particles2D::is_flipped_h() const {
 
 	return flip_h;
 }
 
-void Particles2D::set_flip_v(bool p_flip){
+void Particles2D::set_flip_v(bool p_flip) {
 
-	flip_v=p_flip;
+	flip_v = p_flip;
 }
-bool Particles2D::is_flipped_v() const{
+bool Particles2D::is_flipped_v() const {
 
 	return flip_v;
 }
 
 void Particles2D::set_h_frames(int p_frames) {
 
-	ERR_FAIL_COND(p_frames<1);
-	h_frames=p_frames;
+	ERR_FAIL_COND(p_frames < 1);
+	h_frames = p_frames;
 }
 
-int Particles2D::get_h_frames() const{
+int Particles2D::get_h_frames() const {
 
 	return h_frames;
 }
 
-void Particles2D::set_v_frames(int p_frames){
+void Particles2D::set_v_frames(int p_frames) {
 
-	ERR_FAIL_COND(p_frames<1);
-	v_frames=p_frames;
+	ERR_FAIL_COND(p_frames < 1);
+	v_frames = p_frames;
 }
-int Particles2D::get_v_frames() const{
+int Particles2D::get_v_frames() const {
 
 	return v_frames;
 }
 
+void Particles2D::set_emission_points(const PoolVector<Vector2> &p_points) {
 
-
-void Particles2D::set_emission_points(const PoolVector<Vector2>& p_points) {
-
-	emission_points=p_points;
+	emission_points = p_points;
 }
 
-PoolVector<Vector2> Particles2D::get_emission_points() const{
+PoolVector<Vector2> Particles2D::get_emission_points() const {
 
 	return emission_points;
 }
 
 void Particles2D::reset() {
 
-	for(int i=0;i<particles.size();i++) {
-		particles[i].active=false;
+	for (int i = 0; i < particles.size(); i++) {
+		particles[i].active = false;
 	}
-	time=0;
-	active_count=0;
+	time = 0;
+	active_count = 0;
 }
 
 void Particles2D::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_emitting","active"),&Particles2D::set_emitting);
-	ClassDB::bind_method(D_METHOD("is_emitting"),&Particles2D::is_emitting);
+	ClassDB::bind_method(D_METHOD("set_emitting", "active"), &Particles2D::set_emitting);
+	ClassDB::bind_method(D_METHOD("is_emitting"), &Particles2D::is_emitting);
 
-	ClassDB::bind_method(D_METHOD("set_process_mode","mode"),&Particles2D::set_process_mode);
-	ClassDB::bind_method(D_METHOD("get_process_mode"),&Particles2D::get_process_mode);
+	ClassDB::bind_method(D_METHOD("set_process_mode", "mode"), &Particles2D::set_process_mode);
+	ClassDB::bind_method(D_METHOD("get_process_mode"), &Particles2D::get_process_mode);
 
-	ClassDB::bind_method(D_METHOD("set_amount","amount"),&Particles2D::set_amount);
-	ClassDB::bind_method(D_METHOD("get_amount"),&Particles2D::get_amount);
+	ClassDB::bind_method(D_METHOD("set_amount", "amount"), &Particles2D::set_amount);
+	ClassDB::bind_method(D_METHOD("get_amount"), &Particles2D::get_amount);
 
-	ClassDB::bind_method(D_METHOD("set_lifetime","lifetime"),&Particles2D::set_lifetime);
-	ClassDB::bind_method(D_METHOD("get_lifetime"),&Particles2D::get_lifetime);
+	ClassDB::bind_method(D_METHOD("set_lifetime", "lifetime"), &Particles2D::set_lifetime);
+	ClassDB::bind_method(D_METHOD("get_lifetime"), &Particles2D::get_lifetime);
 
-	ClassDB::bind_method(D_METHOD("set_time_scale","time_scale"),&Particles2D::set_time_scale);
-	ClassDB::bind_method(D_METHOD("get_time_scale"),&Particles2D::get_time_scale);
+	ClassDB::bind_method(D_METHOD("set_time_scale", "time_scale"), &Particles2D::set_time_scale);
+	ClassDB::bind_method(D_METHOD("get_time_scale"), &Particles2D::get_time_scale);
 
-	ClassDB::bind_method(D_METHOD("set_pre_process_time","time"),&Particles2D::set_pre_process_time);
-	ClassDB::bind_method(D_METHOD("get_pre_process_time"),&Particles2D::get_pre_process_time);
+	ClassDB::bind_method(D_METHOD("set_pre_process_time", "time"), &Particles2D::set_pre_process_time);
+	ClassDB::bind_method(D_METHOD("get_pre_process_time"), &Particles2D::get_pre_process_time);
 
-	ClassDB::bind_method(D_METHOD("set_emit_timeout","value"),&Particles2D::set_emit_timeout);
-	ClassDB::bind_method(D_METHOD("get_emit_timeout"),&Particles2D::get_emit_timeout);
+	ClassDB::bind_method(D_METHOD("set_emit_timeout", "value"), &Particles2D::set_emit_timeout);
+	ClassDB::bind_method(D_METHOD("get_emit_timeout"), &Particles2D::get_emit_timeout);
 
-	ClassDB::bind_method(D_METHOD("set_param","param","value"),&Particles2D::set_param);
-	ClassDB::bind_method(D_METHOD("get_param","param"),&Particles2D::get_param);
+	ClassDB::bind_method(D_METHOD("set_param", "param", "value"), &Particles2D::set_param);
+	ClassDB::bind_method(D_METHOD("get_param", "param"), &Particles2D::get_param);
 
-	ClassDB::bind_method(D_METHOD("set_randomness","param","value"),&Particles2D::set_randomness);
-	ClassDB::bind_method(D_METHOD("get_randomness","param"),&Particles2D::get_randomness);
+	ClassDB::bind_method(D_METHOD("set_randomness", "param", "value"), &Particles2D::set_randomness);
+	ClassDB::bind_method(D_METHOD("get_randomness", "param"), &Particles2D::get_randomness);
 
-	ClassDB::bind_method(D_METHOD("set_texture:Texture","texture"),&Particles2D::set_texture);
-	ClassDB::bind_method(D_METHOD("get_texture:Texture"),&Particles2D::get_texture);
+	ClassDB::bind_method(D_METHOD("set_texture:Texture", "texture"), &Particles2D::set_texture);
+	ClassDB::bind_method(D_METHOD("get_texture:Texture"), &Particles2D::get_texture);
 
-	ClassDB::bind_method(D_METHOD("set_color","color"),&Particles2D::set_color);
-	ClassDB::bind_method(D_METHOD("get_color"),&Particles2D::get_color);
+	ClassDB::bind_method(D_METHOD("set_color", "color"), &Particles2D::set_color);
+	ClassDB::bind_method(D_METHOD("get_color"), &Particles2D::get_color);
 
-	ClassDB::bind_method(D_METHOD("set_color_ramp:ColorRamp","color_ramp"),&Particles2D::set_color_ramp);
-	ClassDB::bind_method(D_METHOD("get_color_ramp:ColorRamp"),&Particles2D::get_color_ramp);
+	ClassDB::bind_method(D_METHOD("set_color_ramp:ColorRamp", "color_ramp"), &Particles2D::set_color_ramp);
+	ClassDB::bind_method(D_METHOD("get_color_ramp:ColorRamp"), &Particles2D::get_color_ramp);
 
-	ClassDB::bind_method(D_METHOD("set_emissor_offset","offset"),&Particles2D::set_emissor_offset);
-	ClassDB::bind_method(D_METHOD("get_emissor_offset"),&Particles2D::get_emissor_offset);
+	ClassDB::bind_method(D_METHOD("set_emissor_offset", "offset"), &Particles2D::set_emissor_offset);
+	ClassDB::bind_method(D_METHOD("get_emissor_offset"), &Particles2D::get_emissor_offset);
 
-	ClassDB::bind_method(D_METHOD("set_flip_h","enable"),&Particles2D::set_flip_h);
-	ClassDB::bind_method(D_METHOD("is_flipped_h"),&Particles2D::is_flipped_h);
+	ClassDB::bind_method(D_METHOD("set_flip_h", "enable"), &Particles2D::set_flip_h);
+	ClassDB::bind_method(D_METHOD("is_flipped_h"), &Particles2D::is_flipped_h);
 
-	ClassDB::bind_method(D_METHOD("set_flip_v","enable"),&Particles2D::set_flip_v);
-	ClassDB::bind_method(D_METHOD("is_flipped_v"),&Particles2D::is_flipped_v);
+	ClassDB::bind_method(D_METHOD("set_flip_v", "enable"), &Particles2D::set_flip_v);
+	ClassDB::bind_method(D_METHOD("is_flipped_v"), &Particles2D::is_flipped_v);
 
-	ClassDB::bind_method(D_METHOD("set_h_frames","enable"),&Particles2D::set_h_frames);
-	ClassDB::bind_method(D_METHOD("get_h_frames"),&Particles2D::get_h_frames);
+	ClassDB::bind_method(D_METHOD("set_h_frames", "enable"), &Particles2D::set_h_frames);
+	ClassDB::bind_method(D_METHOD("get_h_frames"), &Particles2D::get_h_frames);
 
-	ClassDB::bind_method(D_METHOD("set_v_frames","enable"),&Particles2D::set_v_frames);
-	ClassDB::bind_method(D_METHOD("get_v_frames"),&Particles2D::get_v_frames);
+	ClassDB::bind_method(D_METHOD("set_v_frames", "enable"), &Particles2D::set_v_frames);
+	ClassDB::bind_method(D_METHOD("get_v_frames"), &Particles2D::get_v_frames);
 
-	ClassDB::bind_method(D_METHOD("set_emission_half_extents","extents"),&Particles2D::set_emission_half_extents);
-	ClassDB::bind_method(D_METHOD("get_emission_half_extents"),&Particles2D::get_emission_half_extents);
+	ClassDB::bind_method(D_METHOD("set_emission_half_extents", "extents"), &Particles2D::set_emission_half_extents);
+	ClassDB::bind_method(D_METHOD("get_emission_half_extents"), &Particles2D::get_emission_half_extents);
 
-	ClassDB::bind_method(D_METHOD("set_color_phases","phases"),&Particles2D::set_color_phases);
-	ClassDB::bind_method(D_METHOD("get_color_phases"),&Particles2D::get_color_phases);
+	ClassDB::bind_method(D_METHOD("set_color_phases", "phases"), &Particles2D::set_color_phases);
+	ClassDB::bind_method(D_METHOD("get_color_phases"), &Particles2D::get_color_phases);
 
-	ClassDB::bind_method(D_METHOD("set_color_phase_color","phase","color"),&Particles2D::set_color_phase_color);
-	ClassDB::bind_method(D_METHOD("get_color_phase_color","phase"),&Particles2D::get_color_phase_color);
+	ClassDB::bind_method(D_METHOD("set_color_phase_color", "phase", "color"), &Particles2D::set_color_phase_color);
+	ClassDB::bind_method(D_METHOD("get_color_phase_color", "phase"), &Particles2D::get_color_phase_color);
 
-	ClassDB::bind_method(D_METHOD("set_color_phase_pos","phase","pos"),&Particles2D::set_color_phase_pos);
-	ClassDB::bind_method(D_METHOD("get_color_phase_pos","phase"),&Particles2D::get_color_phase_pos);
+	ClassDB::bind_method(D_METHOD("set_color_phase_pos", "phase", "pos"), &Particles2D::set_color_phase_pos);
+	ClassDB::bind_method(D_METHOD("get_color_phase_pos", "phase"), &Particles2D::get_color_phase_pos);
 
-	ClassDB::bind_method(D_METHOD("pre_process","time"),&Particles2D::pre_process);
-	ClassDB::bind_method(D_METHOD("reset"),&Particles2D::reset);
+	ClassDB::bind_method(D_METHOD("pre_process", "time"), &Particles2D::pre_process);
+	ClassDB::bind_method(D_METHOD("reset"), &Particles2D::reset);
 
-	ClassDB::bind_method(D_METHOD("set_use_local_space","enable"),&Particles2D::set_use_local_space);
-	ClassDB::bind_method(D_METHOD("is_using_local_space"),&Particles2D::is_using_local_space);
+	ClassDB::bind_method(D_METHOD("set_use_local_space", "enable"), &Particles2D::set_use_local_space);
+	ClassDB::bind_method(D_METHOD("is_using_local_space"), &Particles2D::is_using_local_space);
 
-	ClassDB::bind_method(D_METHOD("set_initial_velocity","velocity"),&Particles2D::set_initial_velocity);
-	ClassDB::bind_method(D_METHOD("get_initial_velocity"),&Particles2D::get_initial_velocity);
+	ClassDB::bind_method(D_METHOD("set_initial_velocity", "velocity"), &Particles2D::set_initial_velocity);
+	ClassDB::bind_method(D_METHOD("get_initial_velocity"), &Particles2D::get_initial_velocity);
 
-	ClassDB::bind_method(D_METHOD("set_explosiveness","amount"),&Particles2D::set_explosiveness);
-	ClassDB::bind_method(D_METHOD("get_explosiveness"),&Particles2D::get_explosiveness);
+	ClassDB::bind_method(D_METHOD("set_explosiveness", "amount"), &Particles2D::set_explosiveness);
+	ClassDB::bind_method(D_METHOD("get_explosiveness"), &Particles2D::get_explosiveness);
 
-	ClassDB::bind_method(D_METHOD("set_emission_points","points"),&Particles2D::set_emission_points);
-	ClassDB::bind_method(D_METHOD("get_emission_points"),&Particles2D::get_emission_points);
+	ClassDB::bind_method(D_METHOD("set_emission_points", "points"), &Particles2D::set_emission_points);
+	ClassDB::bind_method(D_METHOD("get_emission_points"), &Particles2D::get_emission_points);
 
 	ADD_SIGNAL(MethodInfo("emission_finished"));
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"config/amount",PROPERTY_HINT_EXP_RANGE,"1,1024"),"set_amount","get_amount") ;
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"config/lifetime",PROPERTY_HINT_EXP_RANGE,"0.1,3600,0.1"),"set_lifetime","get_lifetime") ;
-	ADD_PROPERTYNO(PropertyInfo(Variant::REAL,"config/time_scale",PROPERTY_HINT_EXP_RANGE,"0.01,128,0.01"),"set_time_scale","get_time_scale") ;
-	ADD_PROPERTYNZ(PropertyInfo(Variant::REAL,"config/preprocess",PROPERTY_HINT_EXP_RANGE,"0.1,3600,0.1"),"set_pre_process_time","get_pre_process_time") ;
-	ADD_PROPERTYNZ(PropertyInfo(Variant::REAL,"config/emit_timeout",PROPERTY_HINT_RANGE,"0,3600,0.1"),"set_emit_timeout","get_emit_timeout") ;
-	ADD_PROPERTYNO(PropertyInfo(Variant::BOOL,"config/emitting"),"set_emitting","is_emitting") ;
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"config/process_mode",PROPERTY_HINT_ENUM, "Fixed,Idle"),"set_process_mode","get_process_mode");
-	ADD_PROPERTYNZ(PropertyInfo(Variant::VECTOR2,"config/offset"),"set_emissor_offset","get_emissor_offset");
-	ADD_PROPERTYNZ(PropertyInfo(Variant::VECTOR2,"config/half_extents"),"set_emission_half_extents","get_emission_half_extents");
-	ADD_PROPERTYNO(PropertyInfo(Variant::BOOL,"config/local_space"),"set_use_local_space","is_using_local_space");
-	ADD_PROPERTYNO(PropertyInfo(Variant::REAL,"config/explosiveness",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_explosiveness","get_explosiveness");
-	ADD_PROPERTYNZ(PropertyInfo(Variant::BOOL,"config/flip_h"),"set_flip_h","is_flipped_h");
-	ADD_PROPERTYNZ(PropertyInfo(Variant::BOOL,"config/flip_v"),"set_flip_v","is_flipped_v");
-	ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT,"config/texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture");
-	ADD_PROPERTYNO(PropertyInfo(Variant::INT,"config/h_frames",PROPERTY_HINT_RANGE,"1,512,1"),"set_h_frames","get_h_frames");
-	ADD_PROPERTYNO(PropertyInfo(Variant::INT,"config/v_frames",PROPERTY_HINT_RANGE,"1,512,1"),"set_v_frames","get_v_frames");
-
-
-	for(int i=0;i<PARAM_MAX;i++) {
-		ADD_PROPERTYI(PropertyInfo(Variant::REAL,_particlesframe_property_names[i],PROPERTY_HINT_RANGE,_particlesframe_property_ranges[i]),"set_param","get_param",i);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "config/amount", PROPERTY_HINT_EXP_RANGE, "1,1024"), "set_amount", "get_amount");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "config/lifetime", PROPERTY_HINT_EXP_RANGE, "0.1,3600,0.1"), "set_lifetime", "get_lifetime");
+	ADD_PROPERTYNO(PropertyInfo(Variant::REAL, "config/time_scale", PROPERTY_HINT_EXP_RANGE, "0.01,128,0.01"), "set_time_scale", "get_time_scale");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::REAL, "config/preprocess", PROPERTY_HINT_EXP_RANGE, "0.1,3600,0.1"), "set_pre_process_time", "get_pre_process_time");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::REAL, "config/emit_timeout", PROPERTY_HINT_RANGE, "0,3600,0.1"), "set_emit_timeout", "get_emit_timeout");
+	ADD_PROPERTYNO(PropertyInfo(Variant::BOOL, "config/emitting"), "set_emitting", "is_emitting");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "config/process_mode", PROPERTY_HINT_ENUM, "Fixed,Idle"), "set_process_mode", "get_process_mode");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::VECTOR2, "config/offset"), "set_emissor_offset", "get_emissor_offset");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::VECTOR2, "config/half_extents"), "set_emission_half_extents", "get_emission_half_extents");
+	ADD_PROPERTYNO(PropertyInfo(Variant::BOOL, "config/local_space"), "set_use_local_space", "is_using_local_space");
+	ADD_PROPERTYNO(PropertyInfo(Variant::REAL, "config/explosiveness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_explosiveness", "get_explosiveness");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::BOOL, "config/flip_h"), "set_flip_h", "is_flipped_h");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::BOOL, "config/flip_v"), "set_flip_v", "is_flipped_v");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT, "config/texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture");
+	ADD_PROPERTYNO(PropertyInfo(Variant::INT, "config/h_frames", PROPERTY_HINT_RANGE, "1,512,1"), "set_h_frames", "get_h_frames");
+	ADD_PROPERTYNO(PropertyInfo(Variant::INT, "config/v_frames", PROPERTY_HINT_RANGE, "1,512,1"), "set_v_frames", "get_v_frames");
+
+	for (int i = 0; i < PARAM_MAX; i++) {
+		ADD_PROPERTYI(PropertyInfo(Variant::REAL, _particlesframe_property_names[i], PROPERTY_HINT_RANGE, _particlesframe_property_ranges[i]), "set_param", "get_param", i);
 	}
 
-	for(int i=0;i<PARAM_MAX;i++) {
-		ADD_PROPERTYINZ(PropertyInfo(Variant::REAL,_particlesframe_property_rnames[i],PROPERTY_HINT_RANGE,"-1,1,0.01"),"set_randomness","get_randomness",i);
+	for (int i = 0; i < PARAM_MAX; i++) {
+		ADD_PROPERTYINZ(PropertyInfo(Variant::REAL, _particlesframe_property_rnames[i], PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_randomness", "get_randomness", i);
 	}
 
-	ADD_PROPERTYNZ( PropertyInfo( Variant::INT, "color_phases/count",PROPERTY_HINT_RANGE,"0,4,1", 0), "set_color_phases", "get_color_phases");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::INT, "color_phases/count", PROPERTY_HINT_RANGE, "0,4,1", 0), "set_color_phases", "get_color_phases");
 
 	//Backward compatibility. They will be converted to color ramp
-	for(int i=0;i<MAX_COLOR_PHASES;i++) {
-		String phase="phase_"+itos(i)+"/";
-		ADD_PROPERTYI( PropertyInfo( Variant::REAL, phase+"pos", PROPERTY_HINT_RANGE,"0,1,0.01", 0),"set_color_phase_pos","get_color_phase_pos",i );
-		ADD_PROPERTYI( PropertyInfo( Variant::COLOR, phase+"color", PROPERTY_HINT_NONE, "", 0),"set_color_phase_color","get_color_phase_color",i );
+	for (int i = 0; i < MAX_COLOR_PHASES; i++) {
+		String phase = "phase_" + itos(i) + "/";
+		ADD_PROPERTYI(PropertyInfo(Variant::REAL, phase + "pos", PROPERTY_HINT_RANGE, "0,1,0.01", 0), "set_color_phase_pos", "get_color_phase_pos", i);
+		ADD_PROPERTYI(PropertyInfo(Variant::COLOR, phase + "color", PROPERTY_HINT_NONE, "", 0), "set_color_phase_color", "get_color_phase_color", i);
 	}
 
-	ADD_PROPERTYNO(PropertyInfo(Variant::COLOR, "color/color"),"set_color","get_color");
-	ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT,"color/color_ramp",PROPERTY_HINT_RESOURCE_TYPE,"ColorRamp"),"set_color_ramp","get_color_ramp");
-
-	ADD_PROPERTYNZ(PropertyInfo(Variant::POOL_VECTOR2_ARRAY,"emission_points",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"set_emission_points","get_emission_points");
+	ADD_PROPERTYNO(PropertyInfo(Variant::COLOR, "color/color"), "set_color", "get_color");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT, "color/color_ramp", PROPERTY_HINT_RESOURCE_TYPE, "ColorRamp"), "set_color_ramp", "get_color_ramp");
 
-	BIND_CONSTANT( PARAM_DIRECTION );
-	BIND_CONSTANT( PARAM_SPREAD );
-	BIND_CONSTANT( PARAM_LINEAR_VELOCITY );
-	BIND_CONSTANT( PARAM_SPIN_VELOCITY );
-	BIND_CONSTANT( PARAM_ORBIT_VELOCITY );
-	BIND_CONSTANT( PARAM_GRAVITY_DIRECTION );
-	BIND_CONSTANT( PARAM_GRAVITY_STRENGTH );
-	BIND_CONSTANT( PARAM_RADIAL_ACCEL );
-	BIND_CONSTANT( PARAM_TANGENTIAL_ACCEL );
-	BIND_CONSTANT( PARAM_DAMPING );
-	BIND_CONSTANT( PARAM_INITIAL_ANGLE );
-	BIND_CONSTANT( PARAM_INITIAL_SIZE );
-	BIND_CONSTANT( PARAM_FINAL_SIZE );
-	BIND_CONSTANT( PARAM_HUE_VARIATION );
-	BIND_CONSTANT( PARAM_ANIM_SPEED_SCALE );
-	BIND_CONSTANT( PARAM_ANIM_INITIAL_POS );
-	BIND_CONSTANT( PARAM_MAX );
+	ADD_PROPERTYNZ(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "emission_points", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_emission_points", "get_emission_points");
 
-	BIND_CONSTANT( MAX_COLOR_PHASES );
+	BIND_CONSTANT(PARAM_DIRECTION);
+	BIND_CONSTANT(PARAM_SPREAD);
+	BIND_CONSTANT(PARAM_LINEAR_VELOCITY);
+	BIND_CONSTANT(PARAM_SPIN_VELOCITY);
+	BIND_CONSTANT(PARAM_ORBIT_VELOCITY);
+	BIND_CONSTANT(PARAM_GRAVITY_DIRECTION);
+	BIND_CONSTANT(PARAM_GRAVITY_STRENGTH);
+	BIND_CONSTANT(PARAM_RADIAL_ACCEL);
+	BIND_CONSTANT(PARAM_TANGENTIAL_ACCEL);
+	BIND_CONSTANT(PARAM_DAMPING);
+	BIND_CONSTANT(PARAM_INITIAL_ANGLE);
+	BIND_CONSTANT(PARAM_INITIAL_SIZE);
+	BIND_CONSTANT(PARAM_FINAL_SIZE);
+	BIND_CONSTANT(PARAM_HUE_VARIATION);
+	BIND_CONSTANT(PARAM_ANIM_SPEED_SCALE);
+	BIND_CONSTANT(PARAM_ANIM_INITIAL_POS);
+	BIND_CONSTANT(PARAM_MAX);
 
+	BIND_CONSTANT(MAX_COLOR_PHASES);
 }
 
 Particles2D::Particles2D() {
 
-	for(int i=0;i<PARAM_MAX;i++) {
+	for (int i = 0; i < PARAM_MAX; i++) {
 
-		param[i]=0;
-		randomness[i]=0;
+		param[i] = 0;
+		randomness[i] = 0;
 	}
 
-
-	set_param(PARAM_SPREAD,10);
-	set_param(PARAM_LINEAR_VELOCITY,20);
-	set_param(PARAM_GRAVITY_STRENGTH,9.8);
-	set_param(PARAM_RADIAL_ACCEL,0);
-	set_param(PARAM_TANGENTIAL_ACCEL,0);
-	set_param(PARAM_INITIAL_ANGLE,0.0);
-	set_param(PARAM_INITIAL_SIZE,1.0);
-	set_param(PARAM_FINAL_SIZE,1.0);
-	set_param(PARAM_ANIM_SPEED_SCALE,1.0);
-
-	set_color(Color(1,1,1,1));
-
-	time=0;
-	lifetime=2;
-	emitting=false;
+	set_param(PARAM_SPREAD, 10);
+	set_param(PARAM_LINEAR_VELOCITY, 20);
+	set_param(PARAM_GRAVITY_STRENGTH, 9.8);
+	set_param(PARAM_RADIAL_ACCEL, 0);
+	set_param(PARAM_TANGENTIAL_ACCEL, 0);
+	set_param(PARAM_INITIAL_ANGLE, 0.0);
+	set_param(PARAM_INITIAL_SIZE, 1.0);
+	set_param(PARAM_FINAL_SIZE, 1.0);
+	set_param(PARAM_ANIM_SPEED_SCALE, 1.0);
+
+	set_color(Color(1, 1, 1, 1));
+
+	time = 0;
+	lifetime = 2;
+	emitting = false;
 	particles.resize(32);
-	active_count=-1;
+	active_count = -1;
 	set_emitting(true);
-	process_mode=PROCESS_IDLE;
-	local_space=true;
-	preprocess=0;
-	time_scale=1.0;
-
+	process_mode = PROCESS_IDLE;
+	local_space = true;
+	preprocess = 0;
+	time_scale = 1.0;
 
-	flip_h=false;
-	flip_v=false;
+	flip_h = false;
+	flip_v = false;
 
-	v_frames=1;
-	h_frames=1;
+	v_frames = 1;
+	h_frames = 1;
 
 	emit_timeout = 0;
 	time_to_live = 0;
-	explosiveness=1.0;
+	explosiveness = 1.0;
 }